Add Edge Workers commands with safe deploy and explicit enable

.github/workflows/windows-tests.yml

@@ -37,5 +37,15 @@ jobs:
       - name: Unit Tests
         run: npm run jest
 
+      # Work around intermittent hosted-runner Docker startup failures:
+      # https://github.com/actions/runner-images/issues/13729
+      - name: Ensure Docker is running
+        shell: powershell
+        run: |
+          $dockerService = Get-Service -Name "docker"
+          if ($dockerService.Status -ne "Running") {
+            Start-Service -Name "docker"
+          }
+
       - name: Test Command line
         run: ./__tests__/e2e_test.bat

README.md

@@ -9,6 +9,7 @@ VIP-CLI is a tool for interacting with and managing your [WordPress VIP applicat
 - [CONTRIBUTING.md](https://github.com/Automattic/vip-cli/blob/trunk/docs/CONTRIBUTING.md) for information on how to contribute patches and features, also issue and pull request labels.
 - [DEBUGGING.md](https://github.com/Automattic/vip-cli/blob/trunk/docs/DEBUGGING.md) for information on how to debug the software.
 - [TESTING.md](https://github.com/Automattic/vip-cli/blob/trunk/docs/TESTING.md) for details on testing the software and individual tasks.
+- [EDGE-WORKERS.md](https://github.com/Automattic/vip-cli/blob/trunk/docs/EDGE-WORKERS.md) for the edge-worker scaffold, validation, deployment, and operational safety contract.
 - [RELEASING.md](https://github.com/Automattic/vip-cli/blob/trunk/docs/RELEASING.md) for details on deploying a new release.
 - [SECURITY.md](https://github.com/Automattic/vip-cli/blob/trunk/docs/SECURITY.md) for information if you **found a security issue**.
 

__tests__/bin/vip-edge-workers-build.js

@@ -0,0 +1,143 @@
+import path from 'node:path';
+
+import { edgeWorkersBuildCommand } from '../../src/bin/vip-edge-workers-build';
+import * as exit from '../../src/lib/cli/exit';
+import * as lib from '../../src/lib/edge-workers';
+import * as project from '../../src/lib/edge-workers/project';
+import * as tracker from '../../src/lib/tracker';
+
+jest.spyOn( console, 'log' ).mockImplementation( () => {} );
+jest.spyOn( exit, 'withError' ).mockImplementation( () => {
+	throw 'EXIT_WITH_ERROR';
+} );
+
+jest.mock( '../../src/lib/cli/command', () => {
+	const commandMock = {
+		argv: () => commandMock,
+		examples: () => commandMock,
+		option: () => commandMock,
+	};
+	return jest.fn( () => commandMock );
+} );
+
+jest.mock( '../../src/lib/edge-workers', () => ( {
+	buildWorker: jest.fn(),
+} ) );
+
+jest.mock( '../../src/lib/edge-workers/project', () => ( {
+	discoverWorkers: jest.fn(),
+	findWorker: jest.fn(),
+	resolveProjectDir: jest.fn(),
+} ) );
+
+jest.mock( '../../src/lib/tracker', () => ( {
+	trackEvent: jest.fn(),
+} ) );
+
+const worker = name => ( {
+	dir: `/project/workers/${ name }`,
+	manifest: { name, entry: 'assembly/index.ts' },
+} );
+
+describe( 'edgeWorkersBuildCommand()', () => {
+	beforeEach( () => {
+		jest.clearAllMocks();
+		project.resolveProjectDir.mockReturnValue( '/project' );
+		project.findWorker.mockImplementation( ( _projectDir, name ) => worker( name ) );
+		project.discoverWorkers.mockReturnValue( [ worker( 'alpha' ), worker( 'beta' ) ] );
+		lib.buildWorker.mockImplementation( ( _projectDir, selectedWorker ) => ( {
+			wasmPath: `/project/build/${ selectedWorker.manifest.name }.wasm`,
+			sizeBytes: selectedWorker.manifest.name.length,
+		} ) );
+	} );
+
+	it( 'builds one named worker', async () => {
+		await edgeWorkersBuildCommand( [ 'alpha' ] );
+
+		expect( project.findWorker ).toHaveBeenCalledWith( '/project', 'alpha' );
+		expect( project.discoverWorkers ).not.toHaveBeenCalled();
+		expect( lib.buildWorker ).toHaveBeenCalledWith( '/project', worker( 'alpha' ) );
+	} );
+
+	it( 'builds all discovered workers when no name is supplied', async () => {
+		await edgeWorkersBuildCommand();
+
+		expect( project.discoverWorkers ).toHaveBeenCalledWith( '/project' );
+		expect( lib.buildWorker ).toHaveBeenCalledTimes( 2 );
+	} );
+
+	it( 'builds all discovered workers with --all', async () => {
+		await edgeWorkersBuildCommand( [], { all: true } );
+
+		expect( project.discoverWorkers ).toHaveBeenCalledWith( '/project' );
+		expect( lib.buildWorker ).toHaveBeenCalledTimes( 2 );
+	} );
+
+	it( 'rejects a worker name together with --all', async () => {
+		await expect( edgeWorkersBuildCommand( [ 'alpha' ], { all: true } ) ).rejects.toBe(
+			'EXIT_WITH_ERROR'
+		);
+
+		expect( exit.withError ).toHaveBeenCalledWith(
+			'Supply either a worker name or --all, not both.'
+		);
+		expect( project.findWorker ).not.toHaveBeenCalled();
+		expect( project.discoverWorkers ).not.toHaveBeenCalled();
+		expect( lib.buildWorker ).not.toHaveBeenCalled();
+	} );
+
+	it( 'reports when the project has no workers', async () => {
+		project.discoverWorkers.mockReturnValue( [] );
+
+		await expect( edgeWorkersBuildCommand() ).rejects.toBe( 'EXIT_WITH_ERROR' );
+
+		expect( exit.withError ).toHaveBeenCalledWith(
+			'No workers found in this project. Create one with `vip edge-workers new`.'
+		);
+		expect( tracker.trackEvent ).toHaveBeenCalledWith( 'edge_workers_build_command_error', {
+			name: undefined,
+			error: 'build_failed',
+		} );
+		expect( lib.buildWorker ).not.toHaveBeenCalled();
+	} );
+
+	it( 'keeps compiler diagnostics local and out of analytics', async () => {
+		const secret = 'SENTINEL_BUILD_SECRET';
+		const sourcePath = '/private/customer/project/workers/alpha/assembly/index.ts';
+		const diagnostic = `Compilation failed at ${ sourcePath }: const token = "${ secret }";\n\u001b[31merror`;
+		lib.buildWorker.mockImplementation( () => {
+			throw new Error( diagnostic );
+		} );
+
+		await expect( edgeWorkersBuildCommand( [ 'alpha' ] ) ).rejects.toBe( 'EXIT_WITH_ERROR' );
+
+		expect( tracker.trackEvent ).toHaveBeenCalledWith( 'edge_workers_build_command_error', {
+			name: 'alpha',
+			error: 'build_failed',
+		} );
+		expect( JSON.stringify( tracker.trackEvent.mock.calls ) ).not.toContain( secret );
+		expect( JSON.stringify( tracker.trackEvent.mock.calls ) ).not.toContain( sourcePath );
+		expect( exit.withError ).toHaveBeenCalledWith( expect.stringContaining( secret ) );
+		expect( exit.withError ).toHaveBeenCalledWith( expect.stringContaining( sourcePath ) );
+		expect( tracker.trackEvent ).not.toHaveBeenCalledWith(
+			'edge_workers_build_command_success',
+			expect.anything()
+		);
+		expect( console.log ).not.toHaveBeenCalledWith( expect.stringMatching( /^✓/ ) );
+		expect( exit.withError ).toHaveBeenCalledTimes( 1 );
+	} );
+
+	it( 'prints the relative artifact path and byte size', async () => {
+		await edgeWorkersBuildCommand( [ 'alpha' ] );
+
+		expect( console.log ).toHaveBeenCalledWith(
+			`✓ Built "alpha" → ${ path.relative( '/project', '/project/build/alpha.wasm' ) } (5 bytes)`
+		);
+		expect( tracker.trackEvent ).toHaveBeenCalledWith( 'edge_workers_build_command_success', {
+			count: 1,
+		} );
+		const buildOrder = lib.buildWorker.mock.invocationCallOrder[ 0 ];
+		const successOrder = tracker.trackEvent.mock.invocationCallOrder.at( -1 );
+		expect( buildOrder ).toBeLessThan( successOrder );
+	} );
+} );

__tests__/bin/vip-edge-workers-delete.js

@@ -0,0 +1,165 @@
+import { edgeWorkersDeleteCommand } from '../../src/bin/vip-edge-workers-delete';
+import * as edgeWorkersApi from '../../src/lib/api/edge-workers';
+import * as exit from '../../src/lib/cli/exit';
+import { confirm } from '../../src/lib/envvar/input';
+import * as tracker from '../../src/lib/tracker';
+
+jest.spyOn( console, 'log' ).mockImplementation( () => {} );
+jest.spyOn( exit, 'withError' ).mockImplementation( () => {
+	throw 'EXIT_WITH_ERROR';
+} );
+
+jest.mock( '../../src/lib/cli/command', () => {
+	const commandMock = {
+		argv: () => commandMock,
+		examples: () => commandMock,
+		option: () => commandMock,
+	};
+	return jest.fn( () => commandMock );
+} );
+
+jest.mock( '../../src/lib/api/edge-workers', () => ( {
+	appQuery: 'mock-app-query',
+	deleteEdgeWorker: jest.fn(),
+	findEdgeWorkerByName: jest.fn(),
+} ) );
+
+jest.mock( '../../src/lib/envvar/input', () => ( {
+	confirm: jest.fn(),
+} ) );
+
+jest.mock( '../../src/lib/tracker', () => ( {
+	trackEventWithEnv: jest.fn(),
+} ) );
+
+const opts = {
+	app: { id: 1, name: 'example-app' },
+	env: { id: 3, type: 'production' },
+	force: false,
+};
+
+const worker = {
+	id: 7,
+	name: 'headers',
+	location: null,
+	phases: [ 'client_response' ],
+	onFailure: 'continue',
+	active: true,
+	createdAt: '2026-08-19T00:00:00.000Z',
+	updatedAt: '2026-08-19T00:00:00.000Z',
+};
+
+describe( 'edgeWorkersDeleteCommand()', () => {
+	beforeEach( () => {
+		jest.clearAllMocks();
+		edgeWorkersApi.findEdgeWorkerByName.mockResolvedValue( worker );
+		edgeWorkersApi.deleteEdgeWorker.mockResolvedValue();
+		confirm.mockResolvedValue( true );
+		tracker.trackEventWithEnv.mockResolvedValue();
+	} );
+
+	it( 'resolves the target and does not prompt or delete when it is not found', async () => {
+		edgeWorkersApi.findEdgeWorkerByName.mockResolvedValue( null );
+
+		await expect( edgeWorkersDeleteCommand( [ 'missing' ], opts ) ).rejects.toBe(
+			'EXIT_WITH_ERROR'
+		);
+
+		expect( edgeWorkersApi.findEdgeWorkerByName ).toHaveBeenCalledWith( 1, 3, 'missing' );
+		expect( confirm ).not.toHaveBeenCalled();
+		expect( edgeWorkersApi.deleteEdgeWorker ).not.toHaveBeenCalled();
+		expect( exit.withError ).toHaveBeenCalledTimes( 1 );
+		expect( console.log ).not.toHaveBeenCalledWith( expect.stringMatching( /^✓/ ) );
+		expect( tracker.trackEventWithEnv ).not.toHaveBeenCalledWith(
+			1,
+			3,
+			'edge_workers_delete_command_success',
+			expect.anything()
+		);
+	} );
+
+	it( 'confirms the exact resolved target before deleting', async () => {
+		const order = [];
+		edgeWorkersApi.findEdgeWorkerByName.mockImplementation( async () => {
+			order.push( 'resolve' );
+			return worker;
+		} );
+		confirm.mockImplementation( async message => {
+			expect( message ).toBe(
+				'Permanently delete edge worker "headers" from example-app.production?'
+			);
+			order.push( 'confirm' );
+			return true;
+		} );
+		edgeWorkersApi.deleteEdgeWorker.mockImplementation( async () => {
+			order.push( 'delete' );
+		} );
+
+		await edgeWorkersDeleteCommand( [ 'headers' ], opts );
+
+		expect( order ).toEqual( [ 'resolve', 'confirm', 'delete' ] );
+	} );
+
+	it( 'does not delete when confirmation is declined', async () => {
+		confirm.mockResolvedValue( false );
+
+		await expect( edgeWorkersDeleteCommand( [ 'headers' ], opts ) ).rejects.toBe(
+			'EXIT_WITH_ERROR'
+		);
+
+		expect( edgeWorkersApi.deleteEdgeWorker ).not.toHaveBeenCalled();
+		expect( exit.withError ).toHaveBeenCalledWith(
+			'Failed to delete edge worker: Command cancelled by user.'
+		);
+	} );
+
+	it( 'uses force as the explicit prompt bypass', async () => {
+		await edgeWorkersDeleteCommand( [ 'headers' ], { ...opts, force: true } );
+
+		expect( confirm ).not.toHaveBeenCalled();
+		expect( edgeWorkersApi.deleteEdgeWorker ).toHaveBeenCalledWith( 3, 7 );
+	} );
+
+	it( 'reports API rejection without success output or telemetry', async () => {
+		edgeWorkersApi.deleteEdgeWorker.mockRejectedValue( new Error( 'API unavailable' ) );
+
+		await expect( edgeWorkersDeleteCommand( [ 'headers' ], opts ) ).rejects.toBe(
+			'EXIT_WITH_ERROR'
+		);
+
+		expect( exit.withError ).toHaveBeenCalledWith(
+			'Failed to delete edge worker: API unavailable'
+		);
+		expect( tracker.trackEventWithEnv ).toHaveBeenCalledWith(
+			1,
+			3,
+			'edge_workers_delete_command_error',
+			{ name: 'headers', error: 'delete_failed' }
+		);
+		expect( console.log ).not.toHaveBeenCalledWith( '✓ Deleted edge worker "headers".' );
+		expect( tracker.trackEventWithEnv ).not.toHaveBeenCalledWith(
+			1,
+			3,
+			'edge_workers_delete_command_success',
+			expect.anything()
+		);
+	} );
+
+	it( 'prints and tracks success only after deletion succeeds', async () => {
+		await edgeWorkersDeleteCommand( [ 'headers' ], opts );
+
+		expect( edgeWorkersApi.deleteEdgeWorker ).toHaveBeenCalledWith( 3, 7 );
+		expect( console.log ).toHaveBeenCalledWith( '✓ Deleted edge worker "headers".' );
+		expect( tracker.trackEventWithEnv ).toHaveBeenCalledWith(
+			1,
+			3,
+			'edge_workers_delete_command_success',
+			{ name: 'headers' }
+		);
+		const deletionOrder = edgeWorkersApi.deleteEdgeWorker.mock.invocationCallOrder[ 0 ];
+		const outputOrder = console.log.mock.invocationCallOrder[ 0 ];
+		const successOrder = tracker.trackEventWithEnv.mock.invocationCallOrder.at( -1 );
+		expect( deletionOrder ).toBeLessThan( outputOrder );
+		expect( deletionOrder ).toBeLessThan( successOrder );
+	} );
+} );