Enable OpenCode and Droid in Maestro CLI

docs/cli.md

@@ -75,9 +75,9 @@ On failure, `success` is `false` and an `error` field is included:
 }
 ```
 
-Error codes: `AGENT_NOT_FOUND`, `AGENT_UNSUPPORTED`, `CLAUDE_NOT_FOUND`, `CODEX_NOT_FOUND`.
+Error codes: `AGENT_NOT_FOUND`, `AGENT_UNSUPPORTED`, `CLAUDE_NOT_FOUND`, `CODEX_NOT_FOUND`, `OPENCODE_NOT_FOUND`, `DROID_NOT_FOUND`.
 
-Supported agent types: `claude-code`, `codex`.
+Supported agent types: `claude-code`, `codex`, `opencode`, `factory-droid`. The `send` command supports all four.
 
 ### Listing Sessions
 
@@ -241,5 +241,5 @@ The `send` command always outputs JSON (no `--json` flag needed).
 
 ## Requirements
 
-- At least one AI agent CLI must be installed and in PATH (Claude Code, Codex, or OpenCode)
+- At least one AI agent CLI must be installed in PATH, set via customPath, or configured via sshRemoteConfig (Claude Code, Codex, OpenCode, or Factory Droid — can run on an SSH remote host)
 - Maestro config files must exist (created automatically when you use the GUI)

src/__tests__/cli/commands/send.test.ts

@@ -81,6 +81,7 @@ describe('send command', () => {
 			'claude-code',
 			'/path/to/project',
 			'Hello world',
+			undefined,
 			undefined
 		);
 		expect(consoleSpy).toHaveBeenCalledTimes(1);
@@ -128,7 +129,8 @@ describe('send command', () => {
 			'claude-code',
 			'/path/to/project',
 			'Continue from before',
-			'session-xyz-789'
+			'session-xyz-789',
+			undefined
 		);
 
 		const output = JSON.parse(consoleSpy.mock.calls[0][0]);
@@ -153,6 +155,7 @@ describe('send command', () => {
 			'claude-code',
 			'/custom/project/path',
 			'Do something',
+			undefined,
 			undefined
 		);
 	});
@@ -173,7 +176,13 @@ describe('send command', () => {
 
 		expect(detectCodex).toHaveBeenCalled();
 		expect(detectClaude).not.toHaveBeenCalled();
-		expect(spawnAgent).toHaveBeenCalledWith('codex', expect.any(String), 'Use codex', undefined);
+		expect(spawnAgent).toHaveBeenCalledWith(
+			'codex',
+			expect.any(String),
+			'Use codex',
+			undefined,
+			undefined
+		);
 	});
 
 	it('should exit with error when agent ID is not found', async () => {

src/__tests__/cli/services/agent-spawner.test.ts

@@ -18,6 +18,7 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { EventEmitter } from 'events';
+import type { AgentSshRemoteConfig } from '../../../shared/types';
 
 // Create mock spawn function at module level
 const mockSpawn = vi.fn();
@@ -35,11 +36,28 @@ const mockChild = Object.assign(new EventEmitter(), {
 // Mock child_process before imports
 vi.mock('child_process', async (importOriginal) => {
 	const actual = await importOriginal<typeof import('child_process')>();
+	const actualDefault = (
+		actual as typeof import('child_process') & {
+			default?: typeof import('child_process');
+		}
+	).default;
+	const execFile =
+		actual.execFile ??
+		actualDefault?.execFile ??
+		((...args: unknown[]) => {
+			const callback = args[args.length - 1];
+			if (typeof callback === 'function') {
+				callback(null, '', '');
+			}
+		});
 	return {
 		...actual,
+		execFile,
 		spawn: (...args: unknown[]) => mockSpawn(...args),
 		default: {
+			...(actualDefault ?? {}),
 			...actual,
+			execFile,
 			spawn: (...args: unknown[]) => mockSpawn(...args),
 		},
 	};
@@ -69,8 +87,25 @@ vi.mock('os', () => ({
 
 // Mock storage service
 const mockGetAgentCustomPath = vi.fn();
+const mockGetAgentConfigValues = vi.fn(() => ({}));
+const mockReadSshRemotes = vi.fn(() => []);
+
+const mockWrapSpawnWithSsh = vi.fn(async () => ({
+	command: 'wrapped-cmd',
+	args: ['wrapped-arg-1', 'wrapped-arg-2'],
+	cwd: '/wrapped',
+	customEnvVars: undefined,
+	prompt: undefined,
+	sshRemoteUsed: null,
+}));
 vi.mock('../../../cli/services/storage', () => ({
 	getAgentCustomPath: (...args: unknown[]) => mockGetAgentCustomPath(...args),
+	getAgentConfigValues: (...args: unknown[]) => mockGetAgentConfigValues(...args),
+	readSshRemotes: (...args: unknown[]) => mockReadSshRemotes(...args),
+}));
+
+vi.mock('../../../main/utils/ssh-spawn-wrapper', () => ({
+	wrapSpawnWithSsh: (...args: unknown[]) => mockWrapSpawnWithSsh(...args),
 }));
 
 import {
@@ -678,6 +713,136 @@ Some text with [x] in it that's not a checkbox
 		});
 	});
 
+	describe('detectOpenCode', () => {
+		beforeEach(() => {
+			vi.resetModules();
+		});
+
+		it('should detect OpenCode via PATH detection', async () => {
+			mockGetAgentCustomPath.mockReturnValue(undefined);
+			mockSpawn.mockReturnValue(mockChild);
+
+			const { detectOpenCode: freshDetectOpenCode } =
+				await import('../../../cli/services/agent-spawner');
+
+			const resultPromise = freshDetectOpenCode();
+
+			await new Promise((resolve) => setTimeout(resolve, 0));
+			mockStdout.emit('data', Buffer.from('/usr/local/bin/opencode\n'));
+			await new Promise((resolve) => setTimeout(resolve, 0));
+			mockChild.emit('close', 0);
+
+			const result = await resultPromise;
+
+			expect(result.available).toBe(true);
+			expect(result.path).toBe('/usr/local/bin/opencode');
+			expect(result.source).toBe('path');
+		});
+
+		it('should short-circuit to remote availability when SSH is enabled', async () => {
+			const sshRemoteConfig: AgentSshRemoteConfig = {
+				enabled: true,
+				remoteId: 'remote-opencode',
+			};
+			mockGetAgentCustomPath.mockReturnValue(undefined);
+			mockSpawn.mockReturnValue(mockChild);
+
+			vi.resetModules();
+			const { detectOpenCode: freshDetectOpenCode } =
+				await import('../../../cli/services/agent-spawner');
+
+			const result = await freshDetectOpenCode('/custom/opencode', sshRemoteConfig);
+
+			expect(result.available).toBe(true);
+			expect(result.path).toBeUndefined();
+			expect(result.source).toBe('settings');
+		});
+
+		it('should preserve cached source when override matches cached path', async () => {
+			mockGetAgentCustomPath.mockReturnValue(undefined);
+			mockSpawn.mockReturnValue(mockChild);
+
+			const { detectOpenCode: freshDetectOpenCode } =
+				await import('../../../cli/services/agent-spawner');
+
+			const resultPromise = freshDetectOpenCode();
+
+			await new Promise((resolve) => setTimeout(resolve, 0));
+			mockStdout.emit('data', Buffer.from('/usr/local/bin/opencode\n'));
+			await new Promise((resolve) => setTimeout(resolve, 0));
+			mockChild.emit('close', 0);
+
+			const result1 = await resultPromise;
+			expect(result1.source).toBe('path');
+
+			const result2 = await freshDetectOpenCode('/usr/local/bin/opencode');
+			expect(result2.source).toBe('path');
+		});
+	});
+
+	describe('detectDroid', () => {
+		beforeEach(() => {
+			vi.resetModules();
+		});
+
+		it('should detect Factory Droid via PATH detection', async () => {
+			mockGetAgentCustomPath.mockReturnValue(undefined);
+			mockSpawn.mockReturnValue(mockChild);
+
+			const { detectDroid: freshDetectDroid } = await import('../../../cli/services/agent-spawner');
+
+			const resultPromise = freshDetectDroid();
+
+			await new Promise((resolve) => setTimeout(resolve, 0));
+			mockStdout.emit('data', Buffer.from('/usr/local/bin/droid\n'));
+			await new Promise((resolve) => setTimeout(resolve, 0));
+			mockChild.emit('close', 0);
+
+			const result = await resultPromise;
+
+			expect(result.available).toBe(true);
+			expect(result.path).toBe('/usr/local/bin/droid');
+			expect(result.source).toBe('path');
+		});
+
+		it('should short-circuit to remote availability when SSH is enabled', async () => {
+			const sshRemoteConfig: AgentSshRemoteConfig = {
+				enabled: true,
+				remoteId: 'remote-droid',
+			};
+			mockGetAgentCustomPath.mockReturnValue(undefined);
+			mockSpawn.mockReturnValue(mockChild);
+
+			const { detectDroid: freshDetectDroid } = await import('../../../cli/services/agent-spawner');
+
+			const result = await freshDetectDroid('/custom/droid', sshRemoteConfig);
+
+			expect(result.available).toBe(true);
+			expect(result.path).toBeUndefined();
+			expect(result.source).toBe('settings');
+		});
+
+		it('should preserve cached source when override matches cached path', async () => {
+			mockGetAgentCustomPath.mockReturnValue(undefined);
+			mockSpawn.mockReturnValue(mockChild);
+
+			const { detectDroid: freshDetectDroid } = await import('../../../cli/services/agent-spawner');
+
+			const resultPromise = freshDetectDroid();
+
+			await new Promise((resolve) => setTimeout(resolve, 0));
+			mockStdout.emit('data', Buffer.from('/usr/local/bin/droid\n'));
+			await new Promise((resolve) => setTimeout(resolve, 0));
+			mockChild.emit('close', 0);
+
+			const result1 = await resultPromise;
+			expect(result1.source).toBe('path');
+
+			const result2 = await freshDetectDroid('/usr/local/bin/droid');
+			expect(result2.source).toBe('path');
+		});
+	});
+
 	describe('spawnAgent', () => {
 		beforeEach(() => {
 			mockSpawn.mockReturnValue(mockChild);
@@ -1150,6 +1315,80 @@ Some text with [x] in it that's not a checkbox
 			await resultPromise;
 		});
 
+		it('should wrap OpenCode spawn with SSH when enabled', async () => {
+			const sshRemoteConfig: AgentSshRemoteConfig = {
+				enabled: true,
+				remoteId: 'remote-opencode',
+			};
+			mockWrapSpawnWithSsh.mockClear();
+
+			const resultPromise = spawnAgent(
+				'opencode',
+				'/project/path',
+				'OpenCode remote task',
+				undefined,
+				{ sshRemoteConfig }
+			);
+
+			await new Promise((resolve) => setTimeout(resolve, 0));
+
+			expect(mockWrapSpawnWithSsh).toHaveBeenCalledTimes(1);
+			const [config, configSshRemote, configStore] = mockWrapSpawnWithSsh.mock.calls[0];
+
+			expect(config).toMatchObject({
+				command: expect.any(String),
+				args: expect.any(Array),
+				cwd: '/project/path',
+			});
+			expect(configSshRemote).toEqual(sshRemoteConfig);
+			expect(configStore).toEqual({
+				getSshRemotes: expect.any(Function),
+			});
+
+			mockStdout.emit('data', Buffer.from('{"type":"result","text":"OpenCode done"}\n'));
+			mockChild.emit('close', 0);
+
+			const result = await resultPromise;
+			expect(result.success).toBe(true);
+		});
+
+		it('should wrap Factory Droid spawn with SSH when enabled', async () => {
+			const sshRemoteConfig: AgentSshRemoteConfig = {
+				enabled: true,
+				remoteId: 'remote-droid',
+			};
+			mockWrapSpawnWithSsh.mockClear();
+
+			const resultPromise = spawnAgent(
+				'factory-droid',
+				'/project/path',
+				'Droid remote task',
+				undefined,
+				{ sshRemoteConfig }
+			);
+
+			await new Promise((resolve) => setTimeout(resolve, 0));
+
+			expect(mockWrapSpawnWithSsh).toHaveBeenCalledTimes(1);
+			const [config, configSshRemote, configStore] = mockWrapSpawnWithSsh.mock.calls[0];
+
+			expect(config).toMatchObject({
+				command: expect.any(String),
+				args: expect.any(Array),
+				cwd: '/project/path',
+			});
+			expect(configSshRemote).toEqual(sshRemoteConfig);
+			expect(configStore).toEqual({
+				getSshRemotes: expect.any(Function),
+			});
+
+			mockStdout.emit('data', Buffer.from('{"type":"result","text":"Droid done"}\n'));
+			mockChild.emit('close', 0);
+
+			const result = await resultPromise;
+			expect(result.success).toBe(true);
+		});
+
 		it('should include user home paths', async () => {
 			const resultPromise = spawnAgent('claude-code', '/project', 'prompt');
 			await new Promise((resolve) => setTimeout(resolve, 0));