@shepai/cli 1.171.0 → 1.172.0-pr528.108a424

package/dist/packages/core/src/infrastructure/services/agents/common/executors/copilot-cli-executor.service.js

@@ -0,0 +1,494 @@
+/**
+ * Copilot CLI Executor Service
+ *
+ * Infrastructure implementation of IAgentExecutor for the GitHub Copilot CLI agent.
+ * Executes prompts via the `copilot` CLI subprocess with JSONL output format.
+ *
+ * Key differences from other executors:
+ * - Prompt is delivered via the -p flag (not stdin piping)
+ * - Large prompts use temp-file indirection to avoid Windows ENAMETOOLONG spawn failures
+ * - Auth is GitHub OAuth only — no API key injection is possible or supported
+ * - --resume=<sessionId> format (with equals sign) for session resume
+ *
+ * Uses constructor dependency injection for the spawn function
+ * to enable testability without mocking node:child_process directly.
+ */
+import { getCurrentPhase, getLogPrefix } from '../../feature-agent/log-context.js';
+import { randomUUID } from 'node:crypto';
+import { unlink, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+/** Features supported by Copilot CLI */
+const SUPPORTED_FEATURES = new Set(['session-resume', 'streaming']);
+/**
+ * Base flags always passed to the copilot CLI for non-interactive headless operation.
+ * - --allow-all: bypass tool permission prompts (autonomous execution equivalent of --dangerously-skip-permissions)
+ * - --output-format json: structured JSONL event stream on stdout
+ * - -s: silent mode (suppress CLI progress UI on stderr, keeping it clean for error detection)
+ * - --no-custom-instructions: disable repo-level custom instructions for predictable behavior
+ * - --no-ask-user: never prompt for user input during execution
+ */
+const BASE_FLAGS = [
+    '--allow-all',
+    '--output-format',
+    'json',
+    '-s',
+    '--no-custom-instructions',
+    '--no-ask-user',
+];
+/**
+ * Conservative threshold for prompt characters passed through CLI args.
+ * Above this, we use file indirection to avoid process spawn arg-length failures.
+ */
+const MAX_PROMPT_ARG_CHARS = 12_000;
+/** Prefix for temporary prompt files used by large prompt indirection mode. */
+const PROMPT_FILE_PREFIX = 'shep-copilot-prompt-';
+/**
+ * Legacy model aliases that appeared in older settings payloads.
+ * Copilot CLI expects dotted model versions (e.g. 4.5), not hyphenated (4-5).
+ */
+const LEGACY_MODEL_ALIASES = {
+    'claude-sonnet-4-5': 'claude-sonnet-4.5',
+    'claude-sonnet-4-6': 'claude-sonnet-4.6',
+    'claude-opus-4-5': 'claude-opus-4.5',
+    'claude-opus-4-6': 'claude-opus-4.6',
+    'claude-haiku-4-5': 'claude-haiku-4.5',
+    'gpt-4-1': 'gpt-4.1',
+    'gpt-5-2': 'gpt-5.2',
+    'gpt-5-2-codex': 'gpt-5.2-codex',
+    'gpt-5-3-codex': 'gpt-5.3-codex',
+    'gpt-5-4': 'gpt-5.4',
+    'gpt-5-4-mini': 'gpt-5.4-mini',
+};
+/**
+ * Executor service for GitHub Copilot CLI agent.
+ * Uses subprocess spawning to interact with the `copilot` CLI.
+ */
+export class CopilotCliExecutorService {
+    spawn;
+    authConfig;
+    agentType = 'copilot-cli';
+    /** When true, suppresses debug logging (set per-call via options.silent) */
+    silent = false;
+    constructor(spawn, authConfig) {
+        this.spawn = spawn;
+        this.authConfig = authConfig;
+    }
+    /** Debug logging — writes to stdout so it appears in the worker log file */
+    log(message) {
+        if (this.silent)
+            return;
+        const ts = new Date().toISOString();
+        process.stdout.write(`[${ts}] ${getCurrentPhase()}${getLogPrefix()}${message}\n`);
+    }
+    supportsFeature(feature) {
+        return SUPPORTED_FEATURES.has(feature);
+    }
+    async execute(prompt, options) {
+        this.silent = options?.silent ?? false;
+        // Copilot CLI is OAuth-only. Surface a clear error if token auth is attempted.
+        if (this.authConfig?.authMethod === 'token') {
+            throw new Error('GitHub Copilot CLI does not support token-based authentication. ' +
+                'Auth is managed via GitHub OAuth. Run: copilot auth login');
+        }
+        let preparedPrompt = this.prepareDirectPrompt(prompt);
+        if (this.shouldUsePromptFile(prompt)) {
+            preparedPrompt = await this.preparePromptFileIndirection(prompt);
+        }
+        const args = this.buildArgs(preparedPrompt.promptArg, options);
+        const spawnOpts = this.buildSpawnOptions(options);
+        this.log(`Spawning: copilot ${args.map((a) => (a.length > 80 ? `${a.slice(0, 77)}...` : a)).join(' ')}`);
+        this.log(`Spawn cwd: ${spawnOpts.cwd ?? '(inherited)'}`);
+        let proc;
+        try {
+            proc = this.spawn('copilot', args, spawnOpts);
+        }
+        catch (error) {
+            await preparedPrompt.cleanup();
+            throw error;
+        }
+        this.log(`Subprocess PID: ${proc.pid ?? 'undefined (spawn may have failed)'}`);
+        this.log(`Prompt length: ${prompt.length} chars (${preparedPrompt.usedFileIndirection ? 'delivered via temp prompt file indirection' : 'delivered via -p flag'})`);
+        const executionPromise = new Promise((resolve, reject) => {
+            let lineBuffer = '';
+            let stderr = '';
+            let timedOut = false;
+            let timeoutId;
+            // State accumulated from JSONL events
+            let resultText = '';
+            let sessionId;
+            let usage;
+            if (options?.timeout) {
+                timeoutId = setTimeout(() => {
+                    timedOut = true;
+                    proc.kill();
+                }, options.timeout);
+            }
+            const processLine = (line) => {
+                try {
+                    const parsed = JSON.parse(line);
+                    const type = parsed.type;
+                    if (type === 'assistant.message' && parsed.content) {
+                        resultText += parsed.content;
+                    }
+                    else if (type === 'result') {
+                        if (parsed.sessionId)
+                            sessionId = parsed.sessionId;
+                        if (parsed.usage)
+                            usage = this.extractUsage(parsed.usage);
+                    }
+                }
+                catch {
+                    // Malformed JSON line — skip gracefully
+                }
+            };
+            proc.stdout?.on('data', (chunk) => {
+                lineBuffer += chunk.toString();
+                const lines = lineBuffer.split('\n');
+                lineBuffer = lines.pop() ?? '';
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (trimmed)
+                        processLine(trimmed);
+                }
+            });
+            proc.stderr?.on('data', (chunk) => {
+                const data = chunk.toString();
+                stderr += data;
+                this.log(`stderr: ${data.trimEnd()}`);
+            });
+            proc.on('error', (error) => {
+                this.log(`Process error event: ${error.message}`);
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                if (error.code === 'ENOENT') {
+                    reject(new Error('GitHub Copilot CLI ("copilot") not found. ' +
+                        'Install via: npm install -g @githubnext/github-copilot-cli, ' +
+                        'then authenticate with: copilot auth login'));
+                }
+                else {
+                    reject(error);
+                }
+            });
+            proc.on('close', (code) => {
+                // Flush remaining line buffer
+                if (lineBuffer.trim())
+                    processLine(lineBuffer.trim());
+                this.log(`Process closed with code ${code}, result=${resultText.length} chars`);
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                if (timedOut) {
+                    reject(new Error('Agent execution timed out'));
+                    return;
+                }
+                if (code !== 0 && code !== null) {
+                    // Check for auth-specific error patterns to provide actionable guidance
+                    const authError = this.detectAuthError(stderr);
+                    if (authError) {
+                        reject(new Error(authError));
+                        return;
+                    }
+                    const message = stderr.trim()
+                        ? `Process exited with code ${code}: ${stderr.trim()}`
+                        : `Process exited with code ${code}`;
+                    reject(new Error(message));
+                    return;
+                }
+                const result = { result: resultText };
+                if (sessionId)
+                    result.sessionId = sessionId;
+                if (usage)
+                    result.usage = usage;
+                resolve(result);
+            });
+        });
+        return executionPromise.finally(async () => {
+            await preparedPrompt.cleanup();
+        });
+    }
+    async *executeStream(prompt, options) {
+        this.silent = options?.silent ?? false;
+        // Copilot CLI is OAuth-only. Surface a clear error if token auth is attempted.
+        if (this.authConfig?.authMethod === 'token') {
+            yield {
+                type: 'error',
+                content: 'GitHub Copilot CLI does not support token-based authentication. ' +
+                    'Auth is managed via GitHub OAuth. Run: copilot auth login',
+                timestamp: new Date(),
+            };
+            return;
+        }
+        let preparedPrompt = this.prepareDirectPrompt(prompt);
+        if (this.shouldUsePromptFile(prompt)) {
+            preparedPrompt = await this.preparePromptFileIndirection(prompt);
+        }
+        const args = this.buildArgs(preparedPrompt.promptArg, options);
+        const spawnOpts = this.buildSpawnOptions(options);
+        let proc;
+        try {
+            proc = this.spawn('copilot', args, spawnOpts);
+        }
+        catch (error) {
+            await preparedPrompt.cleanup();
+            yield {
+                type: 'error',
+                content: error.message,
+                timestamp: new Date(),
+            };
+            return;
+        }
+        let lineBuffer = '';
+        let stderr = '';
+        let timedOut = false;
+        let timeoutId;
+        // Accumulated final response text (from assistant.message events)
+        let resultText = '';
+        const queue = [];
+        let resolveWait = null;
+        let spawnError = null;
+        function enqueue(event) {
+            queue.push(event);
+            if (resolveWait) {
+                resolveWait();
+                resolveWait = null;
+            }
+        }
+        function waitForItem() {
+            if (queue.length > 0)
+                return Promise.resolve();
+            return new Promise((r) => {
+                resolveWait = r;
+            });
+        }
+        if (options?.timeout) {
+            timeoutId = setTimeout(() => {
+                timedOut = true;
+                proc.kill();
+                enqueue({ type: 'error', content: 'Agent execution timed out', timestamp: new Date() });
+                enqueue(null);
+            }, options.timeout);
+        }
+        const processStreamLine = (line) => {
+            try {
+                const parsed = JSON.parse(line);
+                const type = parsed.type;
+                if (type === 'assistant.message_delta' && parsed.delta) {
+                    enqueue({
+                        type: 'progress',
+                        content: parsed.delta,
+                        timestamp: new Date(),
+                    });
+                    return;
+                }
+                if (type === 'assistant.message' && parsed.content) {
+                    // Accumulate final text; streaming progress already yielded via deltas
+                    resultText += parsed.content;
+                    return;
+                }
+                if (type === 'result') {
+                    // Final event — yield result with accumulated text
+                    enqueue({
+                        type: 'result',
+                        content: resultText,
+                        timestamp: new Date(),
+                    });
+                    return;
+                }
+                if (type === 'error') {
+                    enqueue({
+                        type: 'error',
+                        content: parsed.message ?? parsed.content ?? 'Unknown error',
+                        timestamp: new Date(),
+                    });
+                    return;
+                }
+                // Unknown event types — skip gracefully
+            }
+            catch {
+                // Non-JSON line — emit as raw progress
+                enqueue({ type: 'progress', content: line, timestamp: new Date() });
+            }
+        };
+        proc.stdout?.on('data', (chunk) => {
+            lineBuffer += chunk.toString();
+            const lines = lineBuffer.split('\n');
+            lineBuffer = lines.pop() ?? '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                processStreamLine(trimmed);
+            }
+        });
+        proc.stderr?.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        proc.on('error', (err) => {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            spawnError = err;
+            enqueue(null);
+        });
+        proc.on('close', (code) => {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            if (timedOut)
+                return; // already handled by timeout callback
+            if (lineBuffer.trim()) {
+                processStreamLine(lineBuffer.trim());
+            }
+            if (code !== 0 && code !== null) {
+                const authError = this.detectAuthError(stderr);
+                const msg = authError ??
+                    (stderr.trim()
+                        ? `Process exited with code ${code}: ${stderr.trim()}`
+                        : `Process exited with code ${code}`);
+                enqueue({ type: 'error', content: msg, timestamp: new Date() });
+            }
+            enqueue(null);
+        });
+        try {
+            while (true) {
+                await waitForItem();
+                const item = queue.shift();
+                if (item === null || item === undefined) {
+                    if (spawnError !== null) {
+                        yield {
+                            type: 'error',
+                            content: spawnError.message,
+                            timestamp: new Date(),
+                        };
+                    }
+                    return;
+                }
+                yield item;
+            }
+        }
+        finally {
+            await preparedPrompt.cleanup();
+        }
+    }
+    /**
+     * Build CLI args for the copilot invocation.
+     * Prompt is passed via -p flag (not stdin).
+     */
+    buildArgs(prompt, options) {
+        const args = ['-p', prompt, ...BASE_FLAGS];
+        if (options?.model) {
+            args.push('--model', this.normalizeModel(options.model));
+        }
+        if (options?.resumeSession)
+            args.push(`--resume=${options.resumeSession}`);
+        // Unsupported options — log and ignore
+        if (options?.allowedTools?.length) {
+            this.log('allowedTools option is not supported by Copilot CLI — ignoring');
+        }
+        if (options?.systemPrompt) {
+            this.log('systemPrompt option is not supported by Copilot CLI — ignoring');
+        }
+        if (options?.outputSchema) {
+            this.log('outputSchema option is not supported by Copilot CLI — ignoring');
+        }
+        return args;
+    }
+    /**
+     * Normalize legacy model names to the canonical Copilot CLI form.
+     */
+    normalizeModel(model) {
+        const alias = LEGACY_MODEL_ALIASES[model];
+        if (alias) {
+            this.log(`Normalizing legacy model alias "${model}" to "${alias}"`);
+            return alias;
+        }
+        // Generic fallback for legacy GPT names like gpt-5-2-codex -> gpt-5.2-codex.
+        const genericGptAlias = model.replace(/^gpt-(\d+)-(\d+)(.*)$/i, 'gpt-$1.$2$3');
+        if (genericGptAlias !== model) {
+            this.log(`Normalizing legacy model alias "${model}" to "${genericGptAlias}"`);
+            return genericGptAlias;
+        }
+        return model;
+    }
+    /**
+     * Prepare prompt delivery for Copilot CLI.
+     * Uses temporary file indirection for large prompts to avoid ENAMETOOLONG.
+     */
+    shouldUsePromptFile(prompt) {
+        return prompt.length > MAX_PROMPT_ARG_CHARS;
+    }
+    prepareDirectPrompt(prompt) {
+        return {
+            promptArg: prompt,
+            usedFileIndirection: false,
+            cleanup: async () => {
+                // No temp file created for short prompts.
+            },
+        };
+    }
+    async preparePromptFileIndirection(prompt) {
+        const promptFilePath = join(tmpdir(), `${PROMPT_FILE_PREFIX}${randomUUID()}.txt`);
+        await writeFile(promptFilePath, prompt, 'utf8');
+        const promptArg = 'The full original user prompt is stored in this file:\n' +
+            `${promptFilePath}\n` +
+            'Read that file completely, then execute its instructions exactly as if its content was passed directly as the prompt. ' +
+            'Do not summarize or reinterpret the instructions before executing them.';
+        return {
+            promptArg,
+            usedFileIndirection: true,
+            cleanup: async () => {
+                try {
+                    await unlink(promptFilePath);
+                }
+                catch {
+                    // Ignore cleanup failures (file may already be gone).
+                }
+            },
+        };
+    }
+    buildSpawnOptions(options) {
+        const spawnOpts = {};
+        if (options?.cwd)
+            spawnOpts.cwd = options.cwd;
+        // Explicitly pipe stdio so streams are available
+        spawnOpts.stdio = ['pipe', 'pipe', 'pipe'];
+        // On Windows: windowsHide=true to prevent blank console windows.
+        // Copilot CLI is a Node.js binary, so shell=true is NOT needed.
+        if (process.platform === 'win32') {
+            spawnOpts.windowsHide = true;
+        }
+        // Strip CLAUDECODE env var to prevent "nested session" error when shep
+        // is invoked from within a Claude Code session.
+        const { CLAUDECODE: _, ...cleanEnv } = process.env;
+        // Copilot CLI uses GitHub OAuth — no API key injection.
+        spawnOpts.env = cleanEnv;
+        return spawnOpts;
+    }
+    /**
+     * Extract token usage from the Copilot CLI result event usage object.
+     * Returns undefined if usage data is absent (does not throw).
+     */
+    extractUsage(usage) {
+        if (typeof usage.inputTokens !== 'number' || typeof usage.outputTokens !== 'number') {
+            return undefined;
+        }
+        return { inputTokens: usage.inputTokens, outputTokens: usage.outputTokens };
+    }
+    /**
+     * Detect authentication-related errors in stderr and return a user-friendly message.
+     * Returns null if no auth error is detected.
+     */
+    detectAuthError(stderr) {
+        if (!stderr)
+            return null;
+        const lowerStderr = stderr.toLowerCase();
+        if (lowerStderr.includes('not logged in') ||
+            lowerStderr.includes('authentication') ||
+            lowerStderr.includes('auth') ||
+            lowerStderr.includes('unauthorized') ||
+            lowerStderr.includes('login required')) {
+            return ('GitHub Copilot CLI authentication required. ' +
+                'Run: copilot auth login\n' +
+                `Original error: ${stderr.trim()}`);
+        }
+        return null;
+    }
+}

package/dist/packages/core/src/infrastructure/services/tool-installer/tools/codex.json

@@ -0,0 +1,32 @@
+{
+  "name": "Codex CLI",
+  "summary": "AI-powered code assistant from OpenAI",
+  "description": "Codex CLI is an AI-powered code assistant from OpenAI that helps you write, understand, and debug code with advanced AI capabilities.",
+  "tags": ["cli-agent"],
+  "author": "OpenAI",
+  "website": "https://developers.openai.com/codex/cli",
+  "platforms": ["linux", "darwin", "win32"],
+  "iconUrl": "https://cdn.simpleicons.org/openai",
+  "binary": "codex",
+  "packageManager": "npm",
+  "commands": {
+    "linux": "npm i -g @openai/codex",
+    "darwin": "npm i -g @openai/codex",
+    "win32": "npm i -g @openai/codex"
+  },
+  "timeout": 300000,
+  "documentationUrl": "https://developers.openai.com/codex",
+  "verifyCommand": "codex --version",
+  "autoInstall": true,
+  "openDirectory": "cd {dir} && exec codex",
+  "spawnOptions": {
+    "shell": true,
+    "stdio": "inherit",
+    "detached": false
+  },
+  "terminalCommand": {
+    "linux": "x-terminal-emulator -e bash -c 'cd {dir} && exec codex'",
+    "darwin": "open -a Terminal.app bash -c 'cd {dir} && exec codex'",
+    "win32": "start pwsh.exe 'cd {dir} && codex'"
+  }
+}

package/dist/packages/core/src/infrastructure/services/tool-installer/tools/copilot.json

@@ -0,0 +1,32 @@
+{
+  "name": "GitHub Copilot CLI",
+  "summary": "AI-powered code assistant from GitHub",
+  "description": "GitHub Copilot CLI is an AI-powered code assistant from GitHub that helps you write, understand, and debug code with advanced AI capabilities.",
+  "tags": ["cli-agent"],
+  "author": "GitHub",
+  "website": "https://github.com/features/copilot/cli",
+  "platforms": ["linux", "darwin", "win32"],
+  "iconUrl": "https://cdn.simpleicons.org/githubcopilot",
+  "binary": "copilot",
+  "packageManager": "curl",
+  "commands": {
+    "linux": "curl -fsSL https://gh.io/copilot-install | bash",
+    "darwin": "curl -fsSL https://gh.io/copilot-install | bash",
+    "win32": "npm install -g @github/copilot-cli"
+  },
+  "timeout": 300000,
+  "documentationUrl": "https://docs.github.com/en/copilot/how-tos/copilot-cli/use-copilot-cli-agents/overview",
+  "verifyCommand": "copilot --version",
+  "autoInstall": true,
+  "openDirectory": "cd {dir} && exec copilot",
+  "spawnOptions": {
+    "shell": true,
+    "stdio": "inherit",
+    "detached": false
+  },
+  "terminalCommand": {
+    "linux": "x-terminal-emulator -e bash -c 'cd {dir} && exec copilot'",
+    "darwin": "open -a Terminal.app bash -c 'cd {dir} && exec copilot'",
+    "win32": "start pwsh.exe 'cd {dir} && copilot'"
+  }
+}

package/dist/src/presentation/tui/prompts/agent-select.prompt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-select.prompt.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/tui/prompts/agent-select.prompt.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAIzD;;;;;GAKG;AACH,wBAAgB,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;EA2CtC"}
+{"version":3,"file":"agent-select.prompt.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/tui/prompts/agent-select.prompt.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAIzD;;;;;GAKG;AACH,wBAAgB,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;EAgDtC"}

package/dist/src/presentation/tui/prompts/agent-select.prompt.js

@@ -33,6 +33,11 @@ export function createAgentSelectConfig() {
                 value: AgentType.CodexCli,
                 description: t('tui:prompts.selectAgent.choices.codexCli.description'),
             },
+            {
+                name: t('tui:prompts.selectAgent.choices.copilotCli.name'),
+                value: AgentType.CopilotCli,
+                description: t('tui:prompts.selectAgent.choices.copilotCli.description'),
+            },
             {
                 name: t('tui:prompts.selectAgent.choices.cursor.name'),
                 value: AgentType.Cursor,

package/dist/src/presentation/web/app/actions/check-agent-auth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check-agent-auth.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/web/app/actions/check-agent-auth.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,+CAA+C;IAC/C,SAAS,EAAE,OAAO,CAAC;IACnB,8CAA8C;IAC9C,aAAa,EAAE,OAAO,CAAC;IACvB,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,gDAAgD;IAChD,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,0FAA0F;IAC1F,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,wDAAwD;IACxD,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AA6FD;;;GAGG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,eAAe,CAAC,CAwF/D"}
+{"version":3,"file":"check-agent-auth.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/web/app/actions/check-agent-auth.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,+CAA+C;IAC/C,SAAS,EAAE,OAAO,CAAC;IACnB,8CAA8C;IAC9C,aAAa,EAAE,OAAO,CAAC;IACvB,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;IACd,gDAAgD;IAChD,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,0FAA0F;IAC1F,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,wDAAwD;IACxD,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AA6GD;;;GAGG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,eAAe,CAAC,CAwF/D"}

package/dist/src/presentation/web/app/actions/check-agent-auth.js

@@ -11,6 +11,7 @@ const AGENT_LABELS = {
     cursor: 'Cursor Agent',
     'gemini-cli': 'Gemini CLI',
     aider: 'Aider',
+    copilot: 'Copilot CLI',
     continue: 'Continue',
     dev: 'Demo',
 };
@@ -18,11 +19,13 @@ const AGENT_TOOL_MAP = {
     'claude-code': 'claude-code',
     cursor: 'cursor-cli',
     'gemini-cli': 'gemini-cli',
+    copilot: 'copilot-cli',
 };
 const AGENT_BINARY_MAP = {
     'claude-code': 'claude',
     cursor: 'cursor-agent',
     'gemini-cli': 'gemini',
+    copilot: 'copilot',
 };
 /**
  * Tier 1: Instant credential/env check (~5ms, no subprocess).
@@ -60,6 +63,17 @@ function tier1AuthCheck(agentType) {
             const accountsPath = join(home, '.gemini', 'google_accounts.json');
             return existsSync(accountsPath);
         }
+        case 'copilot-cli': {
+            if (process.env['GITHUB_TOKEN'])
+                return true;
+            if (process.env['GH_TOKEN'])
+                return true;
+            if (process.env['GITHUB_AUTH_TOKEN'])
+                return true;
+            // GitHub CLI stores creds after `gh auth login` — check common locations
+            const ghDir = IS_WINDOWS ? join(home, '.copilot') : join(home, '.config', 'gh');
+            return existsSync(ghDir);
+        }
         default:
             // dev, aider, continue — assume no auth needed
             return true;
@@ -82,6 +96,10 @@ function tier2AuthVerify(agentType, binaryName) {
                 cmd = binaryName;
                 args = ['status'];
                 break;
+            case 'copilot-cli':
+                cmd = 'gh';
+                args = ['auth', 'status'];
+                break;
             default:
                 // No tier 2 command available — trust tier 1
                 resolve(true);

package/dist/src/presentation/web/app/actions/get-all-agent-models.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-all-agent-models.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/web/app/actions/get-all-agent-models.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,SAAS,EAAE,CAAC;CACrB;AAmBD,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC,CA+BpE"}
+{"version":3,"file":"get-all-agent-models.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/web/app/actions/get-all-agent-models.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,SAAS,EAAE,CAAC;CACrB;AAqBD,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC,CA+BpE"}

package/dist/src/presentation/web/app/actions/get-all-agent-models.js

@@ -4,6 +4,7 @@ import { getModelMeta } from '../../lib/model-metadata.js';
 const AGENT_LABELS = {
     'claude-code': 'Claude Code',
     'codex-cli': 'Codex CLI',
+    'copilot-cli': 'Copilot CLI',
     cursor: 'Cursor CLI',
     'gemini-cli': 'Gemini CLI',
     dev: 'Demo',
@@ -12,8 +13,9 @@ const AGENT_LABELS = {
 const AGENT_ORDER = {
     'claude-code': 0,
     'codex-cli': 1,
-    cursor: 2,
-    'gemini-cli': 3,
+    'copilot-cli': 2,
+    cursor: 3,
+    'gemini-cli': 4,
     dev: 99,
 };
 export async function getAllAgentModels() {

package/dist/src/presentation/web/components/common/feature-node/agent-type-icons.d.ts

@@ -1,6 +1,6 @@
 import type { ComponentType, SVGProps } from 'react';
 /** Agent type values mirroring the TypeSpec AgentType enum. */
-export type AgentTypeValue = 'claude-code' | 'codex-cli' | 'cursor' | 'gemini-cli' | 'aider' | 'continue' | 'dev';
+export type AgentTypeValue = 'claude-code' | 'codex-cli' | 'copilot-cli' | 'cursor' | 'gemini-cli' | 'aider' | 'continue' | 'dev';
 type IconProps = SVGProps<SVGSVGElement> & {
     className?: string;
 };

package/dist/src/presentation/web/components/common/feature-node/agent-type-icons.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-type-icons.d.ts","sourceRoot":"","sources":["../../../../../../../src/presentation/web/components/common/feature-node/agent-type-icons.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAIrD,+DAA+D;AAC/D,MAAM,MAAM,cAAc,GACtB,aAAa,GACb,WAAW,GACX,QAAQ,GACR,YAAY,GACZ,OAAO,GACP,UAAU,GACV,KAAK,CAAC;AAEV,KAAK,SAAS,GAAG,QAAQ,CAAC,aAAa,CAAC,GAAG;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAmBlE,6DAA6D;AAC7D,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,2CAOhD;AA4DD,6CAA6C;AAC7C,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,cAAc,EAAE,MAAM,CAQ1D,CAAC;AAEF,wEAAwE;AACxE,wBAAgB,gBAAgB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,aAAa,CAAC,SAAS,CAAC,CAK7E"}
+{"version":3,"file":"agent-type-icons.d.ts","sourceRoot":"","sources":["../../../../../../../src/presentation/web/components/common/feature-node/agent-type-icons.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAIrD,+DAA+D;AAC/D,MAAM,MAAM,cAAc,GACtB,aAAa,GACb,WAAW,GACX,aAAa,GACb,QAAQ,GACR,YAAY,GACZ,OAAO,GACP,UAAU,GACV,KAAK,CAAC;AAEV,KAAK,SAAS,GAAG,QAAQ,CAAC,aAAa,CAAC,GAAG;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAmBlE,6DAA6D;AAC7D,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,2CAOhD;AA6DD,6CAA6C;AAC7C,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,cAAc,EAAE,MAAM,CAS1D,CAAC;AAEF,wEAAwE;AACxE,wBAAgB,gBAAgB,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,aAAa,CAAC,SAAS,CAAC,CAK7E"}