@straiffi/archon 1.2.33 → 1.3.0

package/dist/server/lib/agent.js

@@ -6,6 +6,7 @@ import db from '../db.js';
 import { getChatSession, updateChatSessionUsageSnapshot } from './chats.js';
 import { normalizeModelId } from './models.js';
 import { PLAN_MODE_QUESTION_TOOL_NAME } from './planModeQuestions.js';
+import { getSpecSession, updateSpecSessionResumeId, updateSpecSessionStatus, updateSpecSessionTitle, updateSpecSessionUsageSnapshot } from './specs.js';
 import { resolveOpencodeDbPath } from './runtimePaths.js';
 import { markTicketDescriptionVisibleInBundle } from './ticketMessages.js';
 import { getTicket } from './tickets.js';
@@ -20,6 +21,7 @@ const OPENCODE_STEP_FINISH_USAGE_QUERY = "SELECT data FROM part WHERE session_id
 const OPENCODE_STEP_FINISH_USAGE_SINCE_QUERY = "SELECT data FROM part WHERE session_id = ? AND time_created >= ? AND json_extract(data, '$.type') = 'step-finish' ORDER BY time_created DESC LIMIT 1";
 const OPENCODE_SESSION_COST_QUERY = 'SELECT cost FROM session WHERE id = ?';
 const GET_PERSISTED_CHAT_STATE_QUERY = 'SELECT agent_log, streaming_response, opencode_session_id FROM chat_sessions WHERE id = ?';
+const GET_PERSISTED_SPEC_STATE_QUERY = 'SELECT agent_log, streaming_response, opencode_session_id FROM spec_sessions WHERE id = ?';
 const EMPTY_CHAT_USAGE_SNAPSHOT = {
     usage_snapshot_context_window: null,
     usage_snapshot_max_output_tokens: null,
@@ -174,9 +176,15 @@ const hasMatchingUsageSnapshot = (current, next) => {
 };
 const activeBuildProcesses = new Map();
 const activeChatProcesses = new Map();
+const activeSpecProcesses = new Map();
 const getErrorMessage = (error) => {
     return error instanceof Error ? error.message : String(error);
 };
+export const formatAgentErrorForTranscript = (error) => {
+    const rawMessage = getErrorMessage(error);
+    const cleaned = rawMessage.replace(/^Agent exited with code \S+\n/, '').trim();
+    return cleaned || rawMessage;
+};
 const getPersistedChatState = (chatSessionId) => {
     const row = db.prepare(GET_PERSISTED_CHAT_STATE_QUERY).get(chatSessionId);
     if (!row) {
@@ -188,6 +196,17 @@ const getPersistedChatState = (chatSessionId) => {
         opencodeSessionId: row.opencode_session_id ?? null,
     };
 };
+const getPersistedSpecState = (specSessionId) => {
+    const row = db.prepare(GET_PERSISTED_SPEC_STATE_QUERY).get(specSessionId);
+    if (!row) {
+        return null;
+    }
+    return {
+        agentLog: row.agent_log ?? null,
+        streamingResponse: row.streaming_response ?? null,
+        opencodeSessionId: row.opencode_session_id ?? null,
+    };
+};
 const preferNonEmptyChatValue = (value, fallback) => {
     if (typeof value === 'string' && value.trim()) {
         return value;
@@ -205,6 +224,14 @@ const getPreservedChatOutput = ({ chatSessionId, log, response, }) => {
         opencodeSessionId: persistedState?.opencodeSessionId ?? null,
     };
 };
+const getPreservedSpecOutput = ({ specSessionId, log, response, }) => {
+    const persistedState = getPersistedSpecState(specSessionId);
+    return {
+        log: preferNonEmptyChatValue(log, persistedState?.agentLog ?? null),
+        response: preferNonEmptyChatValue(response, persistedState?.streamingResponse ?? null),
+        opencodeSessionId: persistedState?.opencodeSessionId ?? null,
+    };
+};
 const updateStatus = (ticketId, status, log, io, streamingResponse = null, options = {}) => {
     db.prepare('UPDATE tickets SET agent_status = ?, agent_log = ?, streaming_response = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(status, log ?? null, streamingResponse ?? null, ticketId);
     const updatedTicket = getTicket(ticketId);
@@ -245,6 +272,30 @@ const updateChatSessionId = (chatSessionId, tool, sessionId, io) => {
         io.emit('chat-session:updated', chatSession);
     }
 };
+const updateSpecSessionStatusLocal = (specSessionId, status, log, io, streamingResponse = null) => {
+    updateSpecSessionStatus(specSessionId, status, log, streamingResponse);
+    const specSession = getSpecSession(specSessionId, { includeMessages: true });
+    if (specSession) {
+        io.emit('spec-session:updated', specSession);
+    }
+};
+const updateSpecSessionIdLocal = (specSessionId, tool, sessionId, io) => {
+    updateSpecSessionResumeId(specSessionId, tool, sessionId);
+    const specSession = getSpecSession(specSessionId, { includeMessages: true });
+    if (specSession) {
+        io.emit('spec-session:updated', specSession);
+    }
+};
+const updateSpecSessionOpencodeMetadata = (specSessionId, sessionId, title, io) => {
+    updateSpecSessionResumeId(specSessionId, 'opencode', sessionId);
+    if (title) {
+        updateSpecSessionTitle(specSessionId, title);
+    }
+    const specSession = getSpecSession(specSessionId, { includeMessages: true });
+    if (specSession) {
+        io.emit('spec-session:updated', specSession);
+    }
+};
 const createThrottledProgressUpdater = (flushUpdate) => {
     let timer = null;
     let hasPendingUpdate = false;
@@ -300,7 +351,7 @@ const readOpencodeSession = (statement, value) => {
         opencodeDb.close();
     }
 };
-const readOpencodeUsageSnapshot = ({ sessionId, spawnTimestamp = null, }) => {
+export const readOpencodeUsageSnapshot = ({ sessionId, spawnTimestamp = null, }) => {
     const opencodeDb = openOpencodeDatabase();
     try {
         const costRow = opencodeDb.prepare(OPENCODE_SESSION_COST_QUERY).get(sessionId);
@@ -367,6 +418,38 @@ export const refreshChatSessionUsageSnapshot = (chatSessionId, options = {}) =>
     updateChatSessionUsageSnapshot(chatSessionId, nextUsageSnapshot);
     return getChatSession(chatSessionId, { includeMessages: options.includeMessages });
 };
+export const refreshSpecSessionUsageSnapshot = (specSessionId, options = {}) => {
+    const specSession = getSpecSession(specSessionId, { includeMessages: options.includeMessages });
+    if (!specSession || specSession.tool !== 'opencode' || !specSession.opencode_session_id) {
+        return specSession;
+    }
+    let nextUsageSnapshot;
+    try {
+        nextUsageSnapshot = readOpencodeUsageSnapshot({
+            sessionId: specSession.opencode_session_id,
+        });
+    }
+    catch {
+        return specSession;
+    }
+    if (hasMatchingUsageSnapshot(specSession, nextUsageSnapshot)) {
+        return specSession;
+    }
+    updateSpecSessionUsageSnapshot(specSessionId, nextUsageSnapshot);
+    return getSpecSession(specSessionId, { includeMessages: options.includeMessages });
+};
+export const storeTicketUsageSnapshot = (ticketId, opencodeSessionId) => {
+    try {
+        const snapshot = readOpencodeUsageSnapshot({ sessionId: opencodeSessionId });
+        if (snapshot.usage_snapshot_total_tokens === null) {
+            return;
+        }
+        db.prepare('UPDATE tickets SET usage_snapshot_json = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(JSON.stringify(snapshot), ticketId);
+    }
+    catch {
+        // Best-effort usage snapshot storage.
+    }
+};
 const updateChatSessionOpencodeMetadata = (chatSessionId, sessionId, title, io) => {
     db.prepare('UPDATE chat_sessions SET opencode_session_id = ?, title = COALESCE(?, title), updated_at = CURRENT_TIMESTAMP WHERE id = ?').run(sessionId, title, chatSessionId);
     const chatSession = getChatSession(chatSessionId, { includeMessages: true });
@@ -442,6 +525,74 @@ const createOpencodeMetadataRefresher = ({ chatSessionId, io, spawnTimestamp, in
         },
     };
 };
+const createSpecOpencodeMetadataRefresher = ({ specSessionId, io, spawnTimestamp, initialSessionId = null, }) => {
+    let lookupTimer = null;
+    let stopped = false;
+    let knownSessionId = initialSessionId;
+    let lastAppliedSessionId = null;
+    let lastAppliedTitle = null;
+    const clearLookupTimer = () => {
+        if (!lookupTimer) {
+            return;
+        }
+        clearTimeout(lookupTimer);
+        lookupTimer = null;
+    };
+    const readCurrentSession = () => {
+        if (knownSessionId) {
+            return readOpencodeSession(OPENCODE_SESSION_BY_ID_QUERY, knownSessionId);
+        }
+        if (spawnTimestamp === null) {
+            return null;
+        }
+        return readOpencodeSession(OPENCODE_SESSION_BY_CREATED_AT_QUERY, spawnTimestamp);
+    };
+    const refresh = () => {
+        if (stopped) {
+            return { hasSession: false, hasResolvedTitle: false, sessionId: knownSessionId };
+        }
+        try {
+            const session = readCurrentSession();
+            if (!session) {
+                return { hasSession: false, hasResolvedTitle: false, sessionId: knownSessionId };
+            }
+            knownSessionId = session.id;
+            if (session.id !== lastAppliedSessionId || session.title !== lastAppliedTitle) {
+                updateSpecSessionOpencodeMetadata(specSessionId, session.id, session.title, io);
+                lastAppliedSessionId = session.id;
+                lastAppliedTitle = session.title;
+            }
+            return {
+                hasSession: true,
+                hasResolvedTitle: session.title !== null,
+                sessionId: session.id,
+            };
+        }
+        catch {
+            return { hasSession: false, hasResolvedTitle: false, sessionId: knownSessionId };
+        }
+    };
+    const scheduleRetry = () => {
+        if (stopped) {
+            return;
+        }
+        clearLookupTimer();
+        lookupTimer = setTimeout(() => {
+            const result = refresh();
+            if (!result.hasResolvedTitle) {
+                scheduleRetry();
+            }
+        }, OPENCODE_SESSION_METADATA_LOOKUP_DELAY_MS);
+    };
+    return {
+        refresh,
+        scheduleRetry,
+        stop: () => {
+            stopped = true;
+            clearLookupTimer();
+        },
+    };
+};
 const TOOL_CALL_PREVIEW_MAX_LENGTH = 100;
 const APPLY_PATCH_START_MARKER = '[[archon-apply-patch]]';
 const APPLY_PATCH_END_MARKER = '[[/archon-apply-patch]]';
@@ -763,6 +914,17 @@ const parseOpencodeJsonEvent = (event, cwd) => {
             responseFragment: null,
         };
     }
+    if (event.type === 'error') {
+        const text = event.part?.text?.trim()
+            || (typeof event.error === 'string' ? event.error.trim() : '')
+            || '';
+        if (text) {
+            return {
+                logFragment: `**Error:** ${text}`,
+                responseFragment: text,
+            };
+        }
+    }
     return { logFragment: null, responseFragment: null };
 };
 const parseOpencodeJsonLine = (line, cwd) => {
@@ -869,6 +1031,13 @@ const untrackChatProcess = (chatSessionId, state) => {
     state.metadataRefresher?.stop();
     state.metadataRefresher = null;
 };
+const untrackSpecProcess = (specSessionId, state) => {
+    if (activeSpecProcesses.get(specSessionId) === state) {
+        activeSpecProcesses.delete(specSessionId);
+    }
+    state.metadataRefresher?.stop();
+    state.metadataRefresher = null;
+};
 export const isBuildAgentRunning = (ticketId) => activeBuildProcesses.has(ticketId);
 export const stopAllBuildAgents = async () => {
     const ticketIds = [...activeBuildProcesses.keys()];
@@ -903,6 +1072,21 @@ export const stopChatAgent = async (chatSessionId) => {
     }
     return true;
 };
+export const stopSpecAgent = async (specSessionId) => {
+    const state = activeSpecProcesses.get(specSessionId);
+    if (!state?.child) {
+        return false;
+    }
+    state.stopRequested = true;
+    state.metadataRefresher?.stop();
+    killProcess(state.child, 'SIGTERM');
+    await waitForProcessExit(state.child, 5000);
+    if (isProcessAlive(state.child)) {
+        killProcess(state.child, 'SIGKILL');
+        await waitForProcessExit(state.child, 1000);
+    }
+    return true;
+};
 export const runAgent = ({ ticketId, tool, prompt, cwd, io, model, variant = null, resumeSessionId = null, sessionField = 'session_id', trackBuildProcess = false, emitSuccessUpdate = true, opencodeAgentMode, }) => {
     const resolvedModel = normalizeModelId(model);
     return new Promise((resolve, reject) => {
@@ -1445,4 +1629,294 @@ export const runChatAgent = ({ chatSessionId, tool, prompt, files = [], cwd, io,
         });
     });
 };
+export const runSpecAgent = ({ specSessionId, tool, prompt, files = [], cwd, io, model, variant = null, resumeSessionId = null, }) => {
+    const resolvedModel = normalizeModelId(model);
+    return new Promise((resolve, reject) => {
+        let sessionId = null;
+        let spawnTimestamp = null;
+        let opencodeMetadataRefresher = null;
+        let settled = false;
+        let usageSnapshot = EMPTY_CHAT_USAGE_SNAPSHOT;
+        const specState = {
+            child: null,
+            stopRequested: false,
+            metadataRefresher: null,
+        };
+        const settle = (handler) => (value) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            opencodeMetadataRefresher?.stop();
+            untrackSpecProcess(specSessionId, specState);
+            handler(value);
+        };
+        const resolveOnce = settle(resolve);
+        const rejectOnce = settle(reject);
+        const [cmd, args] = tool === 'claude'
+            ? (() => {
+                sessionId = resumeSessionId || randomUUID();
+                return [
+                    'claude',
+                    [
+                        '--permission-mode',
+                        'plan',
+                        '--disallowedTools',
+                        PLAN_MODE_QUESTION_TOOL_NAME,
+                        '--print',
+                        '--verbose',
+                        '--output-format',
+                        'stream-json',
+                        resumeSessionId ? '--resume' : '--session-id',
+                        sessionId,
+                        prompt,
+                    ],
+                ];
+            })()
+            : ['opencode', ['run', '--agent', 'plan', '--format', 'json', ...(resumeSessionId ? ['--session', resumeSessionId] : []), ...(resolvedModel ? ['--model', resolvedModel] : []), ...(variant ? ['--variant', variant] : []), ...files.flatMap(filePath => ['--file', filePath]), ...(files.length > 0 ? ['--'] : []), prompt]];
+        updateSpecSessionStatusLocal(specSessionId, 'running', null, io);
+        if (tool === 'claude' && sessionId) {
+            updateSpecSessionIdLocal(specSessionId, tool, sessionId, io);
+        }
+        if (tool === 'opencode') {
+            spawnTimestamp = Date.now();
+            opencodeMetadataRefresher = createSpecOpencodeMetadataRefresher({
+                specSessionId,
+                io,
+                spawnTimestamp,
+                initialSessionId: resumeSessionId,
+            });
+            specState.metadataRefresher = opencodeMetadataRefresher;
+            if (resumeSessionId) {
+                const result = opencodeMetadataRefresher.refresh();
+                if (!result.hasResolvedTitle) {
+                    opencodeMetadataRefresher.scheduleRetry();
+                }
+            }
+        }
+        const child = spawn(cmd, args, {
+            cwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            env: { ...process.env, PWD: cwd },
+            detached: process.platform !== 'win32',
+        });
+        specState.child = child;
+        activeSpecProcesses.set(specSessionId, specState);
+        if (tool === 'claude') {
+            const logLines = [];
+            const responseLines = [];
+            let remainder = '';
+            const stderrChunks = [];
+            const progressUpdater = createThrottledProgressUpdater(() => {
+                updateSpecSessionStatusLocal(specSessionId, 'running', logLines.join('\n\n'), io, responseLines.join('\n\n'));
+            });
+            child.stdout?.on('data', (chunk) => {
+                const text = remainder + chunk.toString();
+                const lines = text.split('\n');
+                remainder = lines.pop() ?? '';
+                for (const line of lines) {
+                    const { logFragment, responseFragment } = parseClaudeStreamJsonLine(line);
+                    usageSnapshot = mergeUsageFromJsonLine(usageSnapshot, line);
+                    if (logFragment !== null) {
+                        logLines.push(logFragment);
+                    }
+                    if (responseFragment !== null) {
+                        responseLines.push(responseFragment);
+                    }
+                    if (logFragment !== null || responseFragment !== null) {
+                        progressUpdater.schedule();
+                    }
+                }
+            });
+            child.stderr?.on('data', (chunk) => stderrChunks.push(chunk));
+            child.on('close', code => {
+                progressUpdater.cancel();
+                if (remainder.trim()) {
+                    usageSnapshot = mergeUsageFromJsonLine(usageSnapshot, remainder);
+                    const { logFragment, responseFragment } = parseClaudeStreamJsonLine(remainder);
+                    if (logFragment !== null) {
+                        logLines.push(logFragment);
+                    }
+                    if (responseFragment !== null) {
+                        responseLines.push(responseFragment);
+                    }
+                }
+                const errOutput = Buffer.concat(stderrChunks).toString();
+                const finalLog = logLines.join('\n\n') || errOutput;
+                const finalResponse = responseLines.join('\n\n') || errOutput;
+                if (specState.stopRequested) {
+                    const preservedOutput = getPreservedSpecOutput({
+                        specSessionId,
+                        log: finalLog,
+                        response: finalResponse,
+                    });
+                    updateSpecSessionStatusLocal(specSessionId, 'running', preservedOutput.log, io, preservedOutput.response);
+                    resolveOnce({
+                        completionStatus: 'stopped',
+                        finalResponse: preservedOutput.response,
+                        usageSnapshot,
+                    });
+                    return;
+                }
+                const modelError = isModelResolutionError(finalLog);
+                if (code === 0 && !modelError) {
+                    const finalOutput = getPreservedSpecOutput({
+                        specSessionId,
+                        log: finalLog,
+                        response: finalResponse,
+                    });
+                    updateSpecSessionStatusLocal(specSessionId, 'running', finalOutput.log, io, finalOutput.response);
+                    resolveOnce({
+                        completionStatus: 'done',
+                        finalResponse: finalOutput.response,
+                        usageSnapshot,
+                    });
+                    return;
+                }
+                updateSpecSessionStatusLocal(specSessionId, 'error', finalLog + (errOutput ? '\n\n' + errOutput : ''), io, finalResponse);
+                rejectOnce(new Error(`Agent exited with code ${code ?? 'null'}\n${finalLog}`));
+            });
+            child.on('error', err => {
+                progressUpdater.cancel();
+                if (specState.stopRequested) {
+                    const log = logLines.join('\n\n') || null;
+                    const response = responseLines.join('\n\n') || null;
+                    const preservedOutput = getPreservedSpecOutput({
+                        specSessionId,
+                        log,
+                        response,
+                    });
+                    updateSpecSessionStatusLocal(specSessionId, 'running', preservedOutput.log, io, preservedOutput.response);
+                    resolveOnce({
+                        completionStatus: 'stopped',
+                        finalResponse: preservedOutput.response,
+                        usageSnapshot,
+                    });
+                    return;
+                }
+                updateSpecSessionStatusLocal(specSessionId, 'error', getErrorMessage(err), io);
+                rejectOnce(err instanceof Error ? err : new Error(getErrorMessage(err)));
+            });
+            return;
+        }
+        const logLines = [];
+        const responseLines = [];
+        let remainder = '';
+        const stderrChunks = [];
+        const progressUpdater = createThrottledProgressUpdater(() => {
+            updateSpecSessionStatusLocal(specSessionId, 'running', logLines.join('\n\n'), io, responseLines.join('\n\n'));
+        });
+        child.stdout?.on('data', (chunk) => {
+            const text = remainder + chunk.toString();
+            const lines = text.split('\n');
+            remainder = lines.pop() ?? '';
+            for (const line of lines) {
+                usageSnapshot = mergeUsageFromJsonLine(usageSnapshot, line);
+                const { logFragment, responseFragment } = parseOpencodeJsonLine(line, cwd);
+                if (logFragment !== null) {
+                    logLines.push(logFragment);
+                }
+                if (responseFragment !== null) {
+                    responseLines.push(responseFragment);
+                }
+                if (logFragment !== null || responseFragment !== null) {
+                    progressUpdater.schedule();
+                }
+            }
+        });
+        child.stderr?.on('data', (chunk) => stderrChunks.push(chunk));
+        if (!resumeSessionId) {
+            opencodeMetadataRefresher?.scheduleRetry();
+        }
+        child.on('close', code => {
+            progressUpdater.cancel();
+            if (remainder.trim()) {
+                usageSnapshot = mergeUsageFromJsonLine(usageSnapshot, remainder);
+                const { logFragment, responseFragment } = parseOpencodeJsonLine(remainder, cwd);
+                if (logFragment !== null) {
+                    logLines.push(logFragment);
+                }
+                if (responseFragment !== null) {
+                    responseLines.push(responseFragment);
+                }
+            }
+            const stderrOutput = Buffer.concat(stderrChunks).toString();
+            const log = logLines.join('\n\n') || stderrOutput;
+            const finalResponse = responseLines.join('\n\n') || stderrOutput;
+            const preservedOutput = specState.stopRequested
+                ? getPreservedSpecOutput({
+                    specSessionId,
+                    log,
+                    response: finalResponse,
+                })
+                : null;
+            const metadataResult = opencodeMetadataRefresher?.refresh();
+            const resolvedOpencodeSessionId = metadataResult?.sessionId
+                ?? preservedOutput?.opencodeSessionId
+                ?? getSpecSession(specSessionId)?.opencode_session_id
+                ?? resumeSessionId;
+            if (specState.stopRequested) {
+                if (resolvedOpencodeSessionId) {
+                    usageSnapshot = resolveOpencodeUsageSnapshot({
+                        current: usageSnapshot,
+                        sessionId: resolvedOpencodeSessionId,
+                        spawnTimestamp,
+                    });
+                }
+                updateSpecSessionStatusLocal(specSessionId, 'running', preservedOutput?.log ?? null, io, preservedOutput?.response ?? null);
+                resolveOnce({
+                    completionStatus: 'stopped',
+                    finalResponse: preservedOutput?.response ?? null,
+                    usageSnapshot,
+                });
+                return;
+            }
+            const modelError = isModelResolutionError(log);
+            if (code === 0 && !modelError) {
+                const finalOutput = getPreservedSpecOutput({
+                    specSessionId,
+                    log,
+                    response: finalResponse,
+                });
+                if (resolvedOpencodeSessionId && spawnTimestamp !== null) {
+                    usageSnapshot = resolveOpencodeUsageSnapshot({
+                        current: usageSnapshot,
+                        sessionId: resolvedOpencodeSessionId,
+                        spawnTimestamp,
+                    });
+                }
+                updateSpecSessionStatusLocal(specSessionId, 'running', finalOutput.log, io, finalOutput.response);
+                resolveOnce({
+                    completionStatus: 'done',
+                    finalResponse: finalOutput.response,
+                    usageSnapshot,
+                });
+                return;
+            }
+            updateSpecSessionStatusLocal(specSessionId, 'error', log, io, finalResponse);
+            rejectOnce(new Error(`Agent exited with code ${code ?? 'null'}\n${log}`));
+        });
+        child.on('error', err => {
+            progressUpdater.cancel();
+            if (specState.stopRequested) {
+                const log = logLines.join('\n\n') || null;
+                const response = responseLines.join('\n\n') || null;
+                const preservedOutput = getPreservedSpecOutput({
+                    specSessionId,
+                    log,
+                    response,
+                });
+                updateSpecSessionStatusLocal(specSessionId, 'running', preservedOutput.log, io, preservedOutput.response);
+                resolveOnce({
+                    completionStatus: 'stopped',
+                    finalResponse: preservedOutput.response,
+                    usageSnapshot,
+                });
+                return;
+            }
+            updateSpecSessionStatusLocal(specSessionId, 'error', getErrorMessage(err), io);
+            rejectOnce(err instanceof Error ? err : new Error(getErrorMessage(err)));
+        });
+    });
+};
 //# sourceMappingURL=agent.js.map