@agent-link/agent 0.1.235 → 0.1.237

package/dist/copilot.js

@@ -0,0 +1,676 @@
+/**
+ * Copilot CLI process driver for AgentLink.
+ *
+ * Parallel to claude.ts but simpler:
+ * - Each turn spawns a new `copilot -p "..." --output-format json` process
+ * - No persistent process, no stdin input stream, no control_request protocol
+ * - JSONL stdout parsed and emitted as backend_event messages
+ * - Session state stored at ~/.copilot/session-state/<id>/
+ */
+import { spawn, execFileSync } from 'child_process';
+import { createInterface } from 'readline';
+import { readdirSync, readFileSync, writeFileSync, existsSync, rmSync, statSync } from 'fs';
+import { join, resolve } from 'path';
+import { homedir, platform } from 'os';
+import { randomUUID } from 'crypto';
+import { copilotCapabilities } from './backends/types.js';
+// ── Module state ───────────────────────────────────────────────────────────
+const conversations = new Map();
+const sendFns = new Set();
+let globalModel = null;
+// ── Send fanout (same pattern as claude.ts) ────────────────────────────────
+function sendFn(msg) {
+    const eventType = msg.type === 'backend_event'
+        ? `backend_event:${msg.event?.type || '?'}`
+        : String(msg.type);
+    console.log(`[Copilot] send: ${eventType} (${sendFns.size} listeners)`);
+    for (const fn of sendFns) {
+        try {
+            fn(msg);
+        }
+        catch (e) { /* ignore */ }
+    }
+}
+export function addCopilotSendFn(fn) {
+    sendFns.add(fn);
+    return () => { sendFns.delete(fn); };
+}
+// ── Session ref helper ─────────────────────────────────────────────────────
+function sessionRef(sessionId) {
+    return {
+        backendType: 'copilot',
+        backendSessionId: sessionId,
+    };
+}
+// ── Resolve copilot executable path ────────────────────────────────────────
+let resolvedCopilotPath = null;
+function resolveCopilotPath() {
+    if (resolvedCopilotPath)
+        return resolvedCopilotPath;
+    const isWin = platform() === 'win32';
+    // Try where/which
+    try {
+        const bin = isWin ? 'where' : 'which';
+        const output = execFileSync(bin, ['copilot'], {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: 5000,
+            windowsHide: true,
+        }).toString().trim();
+        const lines = output.split('\n').map(l => l.trim()).filter(Boolean);
+        if (isWin && lines.length > 1) {
+            resolvedCopilotPath = lines.find(l => /\.(cmd|exe)$/i.test(l)) || lines[0];
+        }
+        else {
+            resolvedCopilotPath = lines[0] || null;
+        }
+    }
+    catch {
+        // where/which failed — try PowerShell on Windows
+        if (isWin) {
+            try {
+                const psOutput = execFileSync('powershell.exe', [
+                    '-NoProfile', '-Command',
+                    '(Get-Command copilot -ErrorAction SilentlyContinue).Source',
+                ], {
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                    timeout: 8000,
+                    windowsHide: true,
+                }).toString().trim();
+                if (psOutput && existsSync(psOutput)) {
+                    resolvedCopilotPath = psOutput;
+                }
+            }
+            catch { /* ignore */ }
+        }
+    }
+    if (!resolvedCopilotPath) {
+        // Fallback: just use 'copilot' and hope it's in PATH
+        resolvedCopilotPath = 'copilot';
+    }
+    console.log(`[Copilot] Resolved command: ${resolvedCopilotPath}`);
+    return resolvedCopilotPath;
+}
+// ── Conversation management ────────────────────────────────────────────────
+export function getCopilotConversation(conversationId) {
+    return conversations.get(conversationId);
+}
+/**
+ * Rebind a running copilot conversation to a new conversationId.
+ * Used when web client refreshes and generates a new UUID for the same session.
+ * Returns true if a running conversation was found and rebound.
+ */
+export function rebindCopilotConversation(copilotSessionId, newConvId) {
+    for (const [oldConvId, state] of conversations) {
+        if (state.copilotSessionId === copilotSessionId && oldConvId !== newConvId) {
+            conversations.delete(oldConvId);
+            state.conversationId = newConvId;
+            conversations.set(newConvId, state);
+            return true;
+        }
+    }
+    return false;
+}
+export function createCopilotPlaceholder(conversationId, opts) {
+    if (conversations.has(conversationId))
+        return;
+    conversations.set(conversationId, {
+        conversationId,
+        child: null,
+        abortController: null,
+        copilotSessionId: null,
+        lastCopilotSessionId: null,
+        workDir: process.cwd(),
+        turnActive: false,
+        providerId: opts?.providerId || 'copilot',
+        model: null,
+        sessionNotified: false,
+    });
+}
+export function restartCopilotConversation(conversationId, opts) {
+    const state = conversations.get(conversationId);
+    const wasTurnActive = state?.turnActive || false;
+    const copilotSessionId = state?.copilotSessionId || null;
+    if (state) {
+        cleanupCopilotConversation(conversationId);
+    }
+    conversations.set(conversationId, {
+        conversationId,
+        child: null,
+        abortController: null,
+        copilotSessionId: null,
+        lastCopilotSessionId: copilotSessionId,
+        workDir: state?.workDir || process.cwd(),
+        turnActive: false,
+        providerId: opts?.providerId || state?.providerId || 'copilot',
+        model: opts?.model || state?.model || null,
+        sessionNotified: false,
+    });
+    return { wasTurnActive, copilotSessionId };
+}
+export function setModel(conversationId, model) {
+    if (conversationId) {
+        const state = conversations.get(conversationId);
+        if (state)
+            state.model = model;
+    }
+    else {
+        globalModel = model;
+    }
+}
+export function handleCopilotChat(conversationId, text, workDir, options, _files) {
+    let state = conversations.get(conversationId);
+    if (!state) {
+        state = {
+            conversationId,
+            child: null,
+            abortController: null,
+            copilotSessionId: null,
+            lastCopilotSessionId: null,
+            workDir,
+            turnActive: false,
+            providerId: 'copilot',
+            model: null,
+            sessionNotified: false,
+        };
+        conversations.set(conversationId, state);
+    }
+    state.workDir = workDir;
+    // Determine session to resume
+    const resumeId = options?.resumeSessionId
+        || state.copilotSessionId
+        || state.lastCopilotSessionId;
+    // For new sessions, pre-assign a sessionId via --session-id so we know it
+    // immediately (don't have to wait for the `result` event).
+    if (!resumeId) {
+        state.copilotSessionId = randomUUID();
+    }
+    // Build args
+    const args = [
+        '-p', text,
+        '--output-format', 'json',
+        '--allow-all-tools',
+        '-s',
+        '--no-ask-user',
+    ];
+    if (resumeId) {
+        args.push(`--resume=${resumeId}`);
+    }
+    else {
+        args.push(`--session-id=${state.copilotSessionId}`);
+    }
+    const model = state.model || globalModel;
+    if (model) {
+        args.push('--model', model);
+    }
+    args.push('-C', workDir);
+    // Spawn copilot process
+    const controller = new AbortController();
+    state.abortController = controller;
+    state.turnActive = true;
+    // Emit turn_started
+    sendFn({
+        type: 'backend_event',
+        conversationId,
+        event: {
+            type: 'turn_started',
+            session: sessionRef(resumeId || 'pending'),
+        },
+    });
+    const copilotCmd = resolveCopilotPath();
+    // On Windows, .cmd files can't be spawned directly — use cmd.exe /c
+    const isWin = platform() === 'win32';
+    const spawnCmd = isWin ? (process.env.COMSPEC || 'cmd.exe') : copilotCmd;
+    const spawnArgs = isWin ? ['/c', copilotCmd, ...args] : args;
+    const child = spawn(spawnCmd, spawnArgs, {
+        cwd: workDir,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        windowsHide: true,
+        signal: controller.signal,
+    });
+    state.child = child;
+    // Parse JSONL stdout
+    const rl = createInterface({ input: child.stdout });
+    let stderrBuf = '';
+    child.stderr?.on('data', (chunk) => {
+        stderrBuf += chunk.toString();
+    });
+    rl.on('line', (line) => {
+        if (!line.trim())
+            return;
+        try {
+            const event = JSON.parse(line);
+            handleCopilotEvent(state, event);
+        }
+        catch {
+            // Non-JSON output, ignore
+        }
+    });
+    child.on('close', (code) => {
+        state.child = null;
+        state.abortController = null;
+        if (state.turnActive) {
+            state.turnActive = false;
+            // If turn wasn't completed by a result event, emit error or cancellation
+            if (code !== 0 && code !== null) {
+                const errMsg = stderrBuf.trim() || `Copilot process exited with code ${code}`;
+                sendFn({
+                    type: 'backend_event',
+                    conversationId,
+                    event: { type: 'error', message: errMsg },
+                });
+            }
+            // Emit backend_event turn_completed so web clears processing state
+            sendFn({
+                type: 'backend_event',
+                conversationId,
+                event: {
+                    type: 'turn_completed',
+                    session: sessionRef(state.copilotSessionId || ''),
+                },
+            });
+            // Also emit top-level turn_completed for backward compat
+            sendFn({
+                type: 'turn_completed',
+                conversationId,
+                workDir: state.workDir,
+                claudeSessionId: state.copilotSessionId,
+            });
+        }
+    });
+    child.on('error', (err) => {
+        state.child = null;
+        state.turnActive = false;
+        sendFn({
+            type: 'backend_event',
+            conversationId,
+            event: { type: 'error', message: `Failed to start copilot: ${err.message}` },
+        });
+        sendFn({
+            type: 'backend_event',
+            conversationId,
+            event: {
+                type: 'turn_completed',
+                session: sessionRef(state.copilotSessionId || ''),
+            },
+        });
+        sendFn({
+            type: 'turn_completed',
+            conversationId,
+            workDir: state.workDir,
+        });
+    });
+}
+// ── JSONL event handler ────────────────────────────────────────────────────
+function handleCopilotEvent(state, event) {
+    const convId = state.conversationId;
+    // On first non-ephemeral event, notify web so sidebar refreshes
+    // and currentClaudeSessionId is set correctly.
+    if (!state.sessionNotified && !event.ephemeral) {
+        state.sessionNotified = true;
+        sendFn({
+            type: 'backend_event',
+            conversationId: convId,
+            event: { type: 'session_started', session: sessionRef(state.copilotSessionId || 'pending') },
+        });
+    }
+    const session = sessionRef(state.copilotSessionId || 'pending');
+    switch (event.type) {
+        case 'assistant.message_delta': {
+            const data = event.data;
+            if (data?.deltaContent) {
+                sendFn({
+                    type: 'backend_event',
+                    conversationId: convId,
+                    event: { type: 'text_delta', session, text: data.deltaContent },
+                });
+            }
+            break;
+        }
+        case 'assistant.reasoning_delta': {
+            const data = event.data;
+            if (data?.deltaContent) {
+                sendFn({
+                    type: 'backend_event',
+                    conversationId: convId,
+                    event: { type: 'reasoning_delta', session, text: data.deltaContent },
+                });
+            }
+            break;
+        }
+        case 'assistant.message': {
+            const data = event.data;
+            // Emit tool_started for each tool request (skip report_intent)
+            if (data?.toolRequests) {
+                for (const tr of data.toolRequests) {
+                    if (tr.name === 'report_intent')
+                        continue;
+                    sendFn({
+                        type: 'backend_event',
+                        conversationId: convId,
+                        event: {
+                            type: 'tool_started',
+                            session,
+                            tool: {
+                                id: tr.toolCallId,
+                                name: tr.name,
+                                itemKind: tr.name,
+                                input: tr.arguments,
+                                status: 'in_progress',
+                            },
+                        },
+                    });
+                }
+            }
+            break;
+        }
+        case 'tool.execution_complete': {
+            const data = event.data;
+            if (data?.toolCallId) {
+                // Skip report_intent results
+                if (data.toolName === 'report_intent')
+                    break;
+                sendFn({
+                    type: 'backend_event',
+                    conversationId: convId,
+                    event: {
+                        type: 'tool_completed',
+                        session,
+                        tool: {
+                            id: data.toolCallId,
+                            name: data.toolName || '',
+                            output: data.success
+                                ? (data.result?.content || data.result?.detailedContent)
+                                : (data.error?.message || 'Tool execution failed'),
+                            isError: !data.success,
+                            status: 'completed',
+                        },
+                    },
+                });
+            }
+            break;
+        }
+        case 'result': {
+            const sessionId = event.sessionId;
+            if (sessionId) {
+                state.copilotSessionId = sessionId;
+            }
+            state.turnActive = false;
+            // Emit backend_event turn_completed
+            sendFn({
+                type: 'backend_event',
+                conversationId: convId,
+                event: {
+                    type: 'turn_completed',
+                    session: sessionRef(state.copilotSessionId || ''),
+                },
+            });
+            // Also emit top-level turn_completed (for backward compat with web)
+            const usage = event.usage;
+            sendFn({
+                type: 'turn_completed',
+                conversationId: convId,
+                workDir: state.workDir,
+                claudeSessionId: state.copilotSessionId,
+                usage: {
+                    outputTokens: 0,
+                    inputTokens: 0,
+                    totalCost: 0,
+                    durationMs: Number(usage?.totalApiDurationMs ?? 0),
+                    model: '',
+                },
+            });
+            break;
+        }
+    }
+}
+// ── Cancel ──────────────────────────────────────────────────────────────────
+export function cancelCopilotExecution(conversationId) {
+    const state = conversations.get(conversationId);
+    if (!state?.child)
+        return;
+    state.turnActive = false;
+    // Notify web that execution was cancelled
+    sendFn({
+        type: 'backend_event',
+        conversationId,
+        event: { type: 'turn_cancelled', session: sessionRef(state.copilotSessionId || '') },
+    });
+    sendFn({ type: 'execution_cancelled', conversationId });
+    if (platform() === 'win32') {
+        try {
+            spawn('cmd', ['/c', 'taskkill', '/pid', String(state.child.pid), '/f', '/t'], {
+                stdio: 'ignore',
+            });
+        }
+        catch { /* ignore */ }
+    }
+    else {
+        state.child.kill('SIGTERM');
+    }
+    state.child = null;
+    state.abortController = null;
+}
+function cleanupCopilotConversation(conversationId) {
+    const state = conversations.get(conversationId);
+    if (!state)
+        return;
+    if (state.child) {
+        cancelCopilotExecution(conversationId);
+    }
+    // Preserve session ID for resume
+    if (state.copilotSessionId) {
+        state.lastCopilotSessionId = state.copilotSessionId;
+    }
+    conversations.delete(conversationId);
+}
+export function cleanupAllCopilotConversations() {
+    for (const convId of conversations.keys()) {
+        cleanupCopilotConversation(convId);
+    }
+}
+// ── Session listing ────────────────────────────────────────────────────────
+const COPILOT_SESSION_DIR = join(homedir(), '.copilot', 'session-state');
+function parseSimpleYaml(content) {
+    const result = {};
+    for (const line of content.split('\n')) {
+        const match = line.match(/^(\w[\w_-]*)\s*:\s*(.*)$/);
+        if (match) {
+            let val = match[2].trim();
+            // Remove quotes
+            if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+                val = val.slice(1, -1);
+            }
+            result[match[1]] = val;
+        }
+    }
+    return result;
+}
+export function listCopilotSessions(workDir) {
+    if (!existsSync(COPILOT_SESSION_DIR))
+        return [];
+    const sessions = [];
+    const normalizedWorkDir = workDir.replace(/\\/g, '/').toLowerCase();
+    try {
+        const dirs = readdirSync(COPILOT_SESSION_DIR, { withFileTypes: true });
+        for (const dir of dirs) {
+            if (!dir.isDirectory())
+                continue;
+            const wsPath = join(COPILOT_SESSION_DIR, dir.name, 'workspace.yaml');
+            if (!existsSync(wsPath))
+                continue;
+            try {
+                const yaml = parseSimpleYaml(readFileSync(wsPath, 'utf-8'));
+                const cwd = (yaml.cwd || '').replace(/\\/g, '/').toLowerCase();
+                // Filter by workDir match
+                if (cwd !== normalizedWorkDir)
+                    continue;
+                const updatedAt = yaml.updated_at ? new Date(yaml.updated_at).getTime() : 0;
+                const title = yaml.name || 'Untitled';
+                sessions.push({
+                    sessionId: yaml.id || dir.name,
+                    title,
+                    preview: title.length > 60 ? title.substring(0, 60) + '...' : title,
+                    lastModified: updatedAt || statSync(wsPath).mtimeMs,
+                });
+            }
+            catch {
+                // Skip broken workspace.yaml
+            }
+        }
+    }
+    catch {
+        // Session dir not readable
+    }
+    sessions.sort((a, b) => b.lastModified - a.lastModified);
+    return sessions;
+}
+// ── Session history ────────────────────────────────────────────────────────
+export function readCopilotSessionMessages(_workDir, sessionId) {
+    const eventsPath = join(COPILOT_SESSION_DIR, sessionId, 'events.jsonl');
+    if (!existsSync(eventsPath))
+        return [];
+    const messages = [];
+    try {
+        const content = readFileSync(eventsPath, 'utf-8');
+        for (const line of content.split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                const event = JSON.parse(line);
+                // Skip ephemeral events
+                if (event.ephemeral)
+                    continue;
+                switch (event.type) {
+                    case 'user.message': {
+                        const data = event.data;
+                        if (data?.content) {
+                            messages.push({ role: 'user', content: data.content });
+                        }
+                        break;
+                    }
+                    case 'assistant.message': {
+                        const data = event.data;
+                        // Add thinking message if reasoning is present
+                        if (data?.reasoningText) {
+                            messages.push({ role: 'assistant', content: data.reasoningText, isThinking: true });
+                        }
+                        if (data?.content) {
+                            messages.push({ role: 'assistant', content: data.content });
+                        }
+                        if (data?.toolRequests) {
+                            for (const tr of data.toolRequests) {
+                                if (tr.name === 'report_intent')
+                                    continue;
+                                messages.push({
+                                    role: 'tool',
+                                    content: '',
+                                    toolName: tr.name,
+                                    toolInput: JSON.stringify(tr.arguments || {}),
+                                });
+                            }
+                        }
+                        break;
+                    }
+                    case 'tool.execution_complete': {
+                        const data = event.data;
+                        if (data?.toolName === 'report_intent')
+                            break;
+                        if (data) {
+                            // Find the most recent tool message without output and update it
+                            for (let i = messages.length - 1; i >= 0; i--) {
+                                if (messages[i].role === 'tool' && messages[i].toolName === data.toolName && !messages[i].toolOutput) {
+                                    messages[i].toolOutput = data.success
+                                        ? (data.result?.content || '')
+                                        : (data.error?.message || 'Failed');
+                                    break;
+                                }
+                            }
+                        }
+                        break;
+                    }
+                }
+            }
+            catch {
+                // Skip unparseable lines
+            }
+        }
+    }
+    catch {
+        // File not readable
+    }
+    return messages;
+}
+export function listAllCopilotSessions(limit = 500) {
+    if (!existsSync(COPILOT_SESSION_DIR))
+        return [];
+    const sessions = [];
+    try {
+        const dirs = readdirSync(COPILOT_SESSION_DIR, { withFileTypes: true });
+        for (const dir of dirs) {
+            if (!dir.isDirectory())
+                continue;
+            const wsPath = join(COPILOT_SESSION_DIR, dir.name, 'workspace.yaml');
+            if (!existsSync(wsPath))
+                continue;
+            try {
+                const yaml = parseSimpleYaml(readFileSync(wsPath, 'utf-8'));
+                const updatedAt = yaml.updated_at ? new Date(yaml.updated_at).getTime() : 0;
+                const title = yaml.name || 'Untitled';
+                const cwd = yaml.cwd || '';
+                // Derive folder name from cwd (last segment)
+                const folderName = cwd.replace(/[\\/]+$/, '').split(/[\\/]/).pop() || cwd;
+                sessions.push({
+                    sessionId: yaml.id || dir.name,
+                    projectPath: cwd,
+                    projectFolder: folderName,
+                    title,
+                    firstPrompt: title,
+                    lastModified: updatedAt || statSync(wsPath).mtimeMs,
+                });
+            }
+            catch { /* skip */ }
+        }
+    }
+    catch { /* dir not readable */ }
+    sessions.sort((a, b) => b.lastModified - a.lastModified);
+    return sessions.slice(0, limit);
+}
+// ── Session rename ─────────────────────────────────────────────────────────
+export function renameCopilotSession(_workDir, sessionId, newTitle) {
+    const wsPath = resolve(COPILOT_SESSION_DIR, sessionId, 'workspace.yaml');
+    if (!wsPath.startsWith(resolve(COPILOT_SESSION_DIR)))
+        return false;
+    if (!existsSync(wsPath))
+        return false;
+    try {
+        let content = readFileSync(wsPath, 'utf-8');
+        // Replace name: line
+        content = content.replace(/^name:\s*.*/m, `name: ${newTitle}`);
+        // Set user_named: true
+        content = content.replace(/^user_named:\s*.*/m, 'user_named: true');
+        writeFileSync(wsPath, content, 'utf-8');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ── Session deletion ───────────────────────────────────────────────────────
+export function deleteCopilotSession(_workDir, sessionId) {
+    const sessionDir = resolve(COPILOT_SESSION_DIR, sessionId);
+    // Prevent path traversal — ensure resolved path is under session-state dir
+    if (!sessionDir.startsWith(resolve(COPILOT_SESSION_DIR)))
+        return false;
+    if (!existsSync(sessionDir))
+        return false;
+    try {
+        rmSync(sessionDir, { recursive: true, force: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ── Capabilities export ────────────────────────────────────────────────────
+export { copilotCapabilities };
+//# sourceMappingURL=copilot.js.map