@cloudcli-ai/cloudcli 1.37.2 → 1.37.4

package/dist-server/server/modules/agent/agent.routes.js

@@ -17,6 +17,8 @@ export function createAgentRouter(dependencies) {
     const githubTokensDb = dependencies.githubTokens;
     const projectsDb = dependencies.projects;
     const providerModelsService = dependencies.models;
+    const sessionGateway = dependencies.sessions;
+    const runRegistry = dependencies.runs;
     const queryClaudeSDK = dependencies.queryClaude;
     const spawnCursor = dependencies.queryCursor;
     const queryCodex = dependencies.queryCodex;
@@ -321,13 +323,15 @@ export function createAgentRouter(dependencies) {
                 await fs.mkdir(path.dirname(cloneDir), { recursive: true });
                 console.log('🔄 Cloning repository:', githubUrl);
                 console.log('📁 Destination:', cloneDir);
-                // Execute git clone
+                // Execute git clone. The host was validated above; the helper is
+                // still scoped to github.com over https so the token can answer no
+                // other challenge (a redirect, say).
                 const gitEnvironment = githubToken ? {
                     ...process.env,
                     GIT_CONFIG_COUNT: '2',
                     GIT_CONFIG_KEY_0: 'credential.helper',
                     GIT_CONFIG_VALUE_0: '',
-                    GIT_CONFIG_KEY_1: 'credential.helper',
+                    GIT_CONFIG_KEY_1: 'credential.https://github.com.helper',
                     GIT_CONFIG_VALUE_1: '!f() { echo username=x-access-token; echo "password=$CLOUDCLI_GITHUB_TOKEN"; }; f',
                     CLOUDCLI_GITHUB_TOKEN: githubToken,
                     GIT_TERMINAL_PROMPT: '0'
@@ -403,21 +407,27 @@ export function createAgentRouter(dependencies) {
         }
     }
     /**
-     * SSE Stream Writer - Adapts SDK/CLI output to Server-Sent Events
+     * SSE Stream Writer - the HTTP response as one audience of a registered run.
+     *
+     * The provider runtime no longer writes here directly: it writes to the
+     * run's gateway writer, which remaps, sequences and buffers every event
+     * and forwards it — as a JSON string, the way it reaches a websocket — to
+     * each connection watching the run, this one included. The route's own
+     * events (status, session-id, GitHub results, done) are objects.
      */
     class SSEStreamWriter {
-        constructor(res, userId = null) {
+        constructor(res) {
             this.res = res;
-            this.sessionId = null;
-            this.userId = userId;
-            this.isSSEStreamWriter = true; // Marker for transport detection
+        }
+        /** What the gateway writer checks before forwarding: open until the response has ended. */
+        get readyState() {
+            return this.res.writableEnded ? 3 : 1;
         }
         send(data) {
             if (this.res.writableEnded) {
                 return;
             }
-            // Format as SSE - providers send raw objects, we stringify
-            this.res.write(`data: ${JSON.stringify(data)}\n\n`);
+            this.res.write(`data: ${typeof data === 'string' ? data : JSON.stringify(data)}\n\n`);
         }
         end() {
             if (!this.res.writableEnded) {
@@ -425,118 +435,66 @@ export function createAgentRouter(dependencies) {
                 this.res.end();
             }
         }
-        setSessionId(sessionId) {
-            this.sessionId = sessionId;
-            this.send({ type: 'session-id', sessionId });
-        }
-        getSessionId() {
-            return this.sessionId;
-        }
     }
     /**
-     * Non-streaming response collector
+     * Non-streaming response collector - the same audience role, kept in
+     * memory until the run ends.
      */
     class ResponseCollector {
-        constructor(userId = null) {
+        constructor() {
             this.messages = [];
-            this.sessionId = null;
-            this.userId = userId;
         }
+        readyState = 1;
         send(data) {
-            // Store ALL messages for now - we'll filter when returning
-            this.messages.push(data);
-            // Extract sessionId if present
+            // The run's events arrive as JSON strings; the route's own as objects.
+            // Stored as objects either way so the filters below read one shape.
+            let record = data;
             if (typeof data === 'string') {
                 try {
-                    const parsed = JSON.parse(data);
-                    if (parsed.sessionId) {
-                        this.sessionId = parsed.sessionId;
-                    }
+                    record = JSON.parse(data);
                 }
                 catch (e) {
-                    // Not JSON, ignore
+                    // Not JSON, keep as is
                 }
             }
-            else if (data && data.sessionId) {
-                this.sessionId = data.sessionId;
-            }
+            this.messages.push(record);
         }
         end() {
             // Do nothing - we'll collect all messages
         }
-        setSessionId(sessionId) {
-            this.sessionId = sessionId;
-        }
-        getSessionId() {
-            return this.sessionId;
-        }
         getMessages() {
             return this.messages;
         }
         /**
-         * Get filtered assistant messages only
+         * The assistant's replies, as the normalized `text` events the run
+         * produced. (Earlier versions filtered a `claude-response` shape no
+         * runtime has emitted since the providers were unified, so this was
+         * always empty.)
          */
         getAssistantMessages() {
-            const assistantMessages = [];
-            for (const msg of this.messages) {
-                // Skip initial status message
-                if (msg && msg.type === 'status') {
-                    continue;
-                }
-                // Handle JSON strings
-                if (typeof msg === 'string') {
-                    try {
-                        const parsed = JSON.parse(msg);
-                        // Only include claude-response messages with assistant type
-                        if (parsed.type === 'claude-response' && parsed.data && parsed.data.type === 'assistant') {
-                            assistantMessages.push(parsed.data);
-                        }
-                    }
-                    catch (e) {
-                        // Not JSON, skip
-                    }
-                }
-            }
-            return assistantMessages;
+            return this.messages.filter((msg) => msg && msg.kind === 'text' && msg.role === 'assistant');
         }
         /**
-         * Calculate total tokens from all messages
+         * The run's token usage, from the last context-window report the
+         * runtime streamed (`status` / `token_budget`, which the Claude and Codex
+         * runtimes emit per assistant message); zeros for a runtime that
+         * reports none.
          */
         getTotalTokens() {
-            let totalInput = 0;
-            let totalOutput = 0;
-            let totalCacheRead = 0;
-            let totalCacheCreation = 0;
+            let budget = null;
             for (const msg of this.messages) {
-                let data = msg;
-                // Parse if string
-                if (typeof msg === 'string') {
-                    try {
-                        data = JSON.parse(msg);
-                    }
-                    catch (e) {
-                        continue;
-                    }
-                }
-                // Extract usage from claude-response messages
-                if (data && data.type === 'claude-response' && data.data) {
-                    const msgData = data.data;
-                    if (msgData.message && msgData.message.usage) {
-                        const usage = msgData.message.usage;
-                        totalInput += usage.input_tokens || 0;
-                        totalOutput += usage.output_tokens || 0;
-                        totalCacheRead += usage.cache_read_input_tokens || 0;
-                        totalCacheCreation += usage.cache_creation_input_tokens || 0;
-                    }
+                if (msg && msg.kind === 'status' && msg.text === 'token_budget' && msg.tokenBudget) {
+                    budget = msg.tokenBudget;
                 }
             }
-            const inputTokens = totalInput + totalCacheRead + totalCacheCreation;
+            const inputTokens = budget?.inputTokens ?? 0;
+            const outputTokens = budget?.outputTokens ?? 0;
             return {
                 inputTokens,
-                outputTokens: totalOutput,
-                cacheReadTokens: totalCacheRead,
-                cacheCreationTokens: totalCacheCreation,
-                totalTokens: inputTokens + totalOutput
+                outputTokens,
+                cacheReadTokens: budget?.cacheReadTokens ?? 0,
+                cacheCreationTokens: budget?.cacheCreationTokens ?? 0,
+                totalTokens: inputTokens + outputTokens
             };
         }
     }
@@ -579,6 +537,11 @@ export function createAgentRouter(dependencies) {
      *                          - true: Returns text/event-stream with incremental updates
      *                          - false: Returns complete JSON response after completion
      *
+     * @param {string} sessionId - (Optional) Continue an existing session: the id an earlier
+     *                             response reported as `sessionId` / in its `session-id` event.
+     *                             A session already mid-run is refused (409); an unknown id, 404.
+     *                             Omitted: a new session is created for the run.
+     *
      * @param {string} model - (Optional) Model identifier for providers.
      *
      *                        Claude models: 'default', 'sonnet', 'opus', 'haiku', 'sonnet[1m]', 'opus[1m]', 'fable'
@@ -716,11 +679,21 @@ export function createAgentRouter(dependencies) {
      * RESPONSE FORMATS
      * ================================================================================================
      *
+     * Every run is registered with the chat run registry like a message sent
+     * from the UI: it is on GET /api/providers/sessions/running while it goes,
+     * a tab that opens the session subscribes to it live, and its events
+     * reach this response the way they reach a tab — `sessionId` is the app
+     * session id, each event carries a `seq`, and the provider's own
+     * `session_created` is folded into the session row instead of forwarded.
+     *
      * Streaming Response (stream=true):
      *   Content-Type: text/event-stream
      *   Events:
      *     - { type: "status", message: "...", projectPath: "..." }
-     *     - { type: "claude-response", data: {...} }
+     *     - { type: "session-id", sessionId: "..." }   // the app session id, usable as `sessionId` later
+     *     - { kind: "text" | "tool_use" | ... , sessionId, seq, ... }   // the provider's normalized events
+     *     - { kind: "complete", ... }
+     *     - { type: "status", message: "Run aborted", aborted: true }   // only when a tab aborted the run; no branch/PR follows
      *     - { type: "github-branch", branch: { name: "...", url: "..." } }
      *     - { type: "github-pr", pullRequest: { number: 42, url: "..." } }
      *     - { type: "github-error", error: "..." }
@@ -729,9 +702,10 @@ export function createAgentRouter(dependencies) {
      * Non-Streaming Response (stream=false):
      *   Content-Type: application/json
      *   {
-     *     success: true,
-     *     sessionId: "session-123",
-     *     messages: [...],        // Assistant messages only (filtered)
+     *     success: true,          // false, with aborted: true, when a tab aborted the run
+     *     sessionId: "session-123",          // the app session id; pass it back as `sessionId` to continue
+     *     providerSessionId: "native-id",    // the provider's own id, for tooling that drives the CLI directly
+     *     messages: [...],        // The assistant's replies: the run's normalized `text` events
      *     tokens: {
      *       inputTokens: 150,
      *       outputTokens: 50,
@@ -751,7 +725,7 @@ export function createAgentRouter(dependencies) {
      *   }
      *
      * Error Response:
-     *   HTTP Status: 400, 401, 500
+     *   HTTP Status: 400, 401, 404 (unknown sessionId), 409 (session already mid-run), 500
      *   Content-Type: application/json
      *   { success: false, error: "Error description" }
      *
@@ -783,7 +757,15 @@ export function createAgentRouter(dependencies) {
      *   }
      */
     router.post('/', validateExternalApiKey, async (req, res) => {
-        const { githubUrl, projectPath, message, provider = 'claude', model, githubToken, branchName, sessionId } = req.body;
+        const { githubUrl, projectPath, message, model, githubToken, branchName } = req.body;
+        // Transport input is typed here, before anything binds it to a query:
+        // the lookup below runs outside the try, where a throw would be an
+        // unhandled rejection.
+        if (req.body.sessionId !== undefined && req.body.sessionId !== null && typeof req.body.sessionId !== 'string') {
+            return res.status(400).json({ error: 'sessionId must be a string' });
+        }
+        const sessionId = typeof req.body.sessionId === 'string' && req.body.sessionId.trim() ? req.body.sessionId.trim() : null;
+        const requestedProvider = req.body.provider === undefined || req.body.provider === null ? null : req.body.provider;
         const effort = typeof req.body.effort === 'string' && req.body.effort.trim()
             ? req.body.effort.trim()
             : undefined;
@@ -800,7 +782,7 @@ export function createAgentRouter(dependencies) {
         if (!message || !message.trim()) {
             return res.status(400).json({ error: 'message is required' });
         }
-        if (!['claude', 'cursor', 'codex', 'opencode'].includes(provider)) {
+        if (requestedProvider !== null && !['claude', 'cursor', 'codex', 'opencode'].includes(requestedProvider)) {
             return res.status(400).json({ error: 'provider must be "claude", "cursor", "codex", or "opencode"' });
         }
         // Validate GitHub branch/PR creation requirements
@@ -808,9 +790,33 @@ export function createAgentRouter(dependencies) {
         if ((createBranch || createPR) && !githubUrl && !projectPath) {
             return res.status(400).json({ error: 'createBranch and createPR require either githubUrl or projectPath with a GitHub remote' });
         }
+        // A run continues a session the caller names, by its app id or — for a
+        // caller that stored what an earlier response called `sessionId` — the
+        // provider-native one, which the row is also keyed by once indexed. The
+        // row, not the request, says which provider the session belongs to, as
+        // it does for a chat send; a request that names another is refused.
+        let sessionRow = null;
+        if (sessionId) {
+            sessionRow = sessionGateway.getSessionById(sessionId) ?? sessionGateway.getSessionByProviderSessionId(sessionId);
+            if (!sessionRow) {
+                return res.status(404).json({ error: `Session "${sessionId}" was not found` });
+            }
+            if (requestedProvider !== null && requestedProvider !== sessionRow.provider) {
+                return res.status(400).json({ error: `Session "${sessionRow.session_id}" belongs to provider "${sessionRow.provider}"` });
+            }
+            // Refused before any side effect — a clone per retry would pile up
+            // under external-projects. startRun below still has the last word.
+            if (runRegistry.isProcessing(sessionRow.session_id)) {
+                return res.status(409).json({ error: `Session "${sessionRow.session_id}" already has a run in progress` });
+            }
+        }
+        const provider = sessionRow?.provider ?? requestedProvider ?? 'claude';
         let finalProjectPath = null;
         let clonedProjectCreated = false;
         let writer = null;
+        // The run as the chat socket registers one: on the running-sessions
+        // list, subscribable from any tab, and completed on every exit path.
+        let run = null;
         try {
             // Determine the final project path
             if (githubUrl) {
@@ -841,6 +847,11 @@ export function createAgentRouter(dependencies) {
                 }
             }
             finalProjectPath = normalizeProjectPath(finalProjectPath);
+            // A continued session runs where it lives, as a chat send does; a
+            // request that resolved to another directory is not that session.
+            if (sessionRow && sessionRow.project_path && normalizeProjectPath(sessionRow.project_path) !== finalProjectPath) {
+                throw new Error(`Session "${sessionRow.session_id}" belongs to project ${sessionRow.project_path}, not ${finalProjectPath}`);
+            }
             // Register project path in DB (or reuse existing active registration)
             const registrationResult = projectsDb.createProjectPath(finalProjectPath, null);
             if (registrationResult.outcome === 'active_conflict') {
@@ -849,81 +860,104 @@ export function createAgentRouter(dependencies) {
             else {
                 console.log('Project registered:', registrationResult.project);
             }
-            // Set up writer based on streaming mode
+            // A brand-new run gets its app session row first, as a chat send does:
+            // the id is stable for the conversation, the sidebar can list it, and
+            // the provider-native id is mapped onto it when the runtime announces it.
+            const appSessionId = sessionRow
+                ? sessionRow.session_id
+                : sessionGateway.createAppSession(provider, finalProjectPath, message.trim()).sessionId;
+            // Registered before any header goes out, so a session already mid-run
+            // is refused with a plain 409 rather than an empty stream. The HTTP
+            // response is the run's first audience; a tab that opens the session
+            // subscribes as another, and replays what it missed.
+            const audience = stream ? new SSEStreamWriter(res) : new ResponseCollector();
+            run = runRegistry.startRun({
+                appSessionId,
+                provider,
+                providerSessionId: sessionRow?.provider_session_id ?? null,
+                connection: audience,
+                userId: req.user.id,
+            });
+            if (!run) {
+                if (cleanup && githubUrl && clonedProjectCreated) {
+                    cleanupProject(finalProjectPath, null);
+                }
+                return res.status(409).json({ error: `Session "${appSessionId}" already has a run in progress` });
+            }
+            writer = audience;
             if (stream) {
                 // Set up SSE headers for streaming
                 res.setHeader('Content-Type', 'text/event-stream');
                 res.setHeader('Cache-Control', 'no-cache');
                 res.setHeader('Connection', 'keep-alive');
                 res.setHeader('X-Accel-Buffering', 'no'); // Disable nginx buffering
-                writer = new SSEStreamWriter(res, req.user.id);
-                // Send initial status
-                writer.send({
-                    type: 'status',
-                    message: githubUrl ? 'Repository cloned and session started' : 'Session started',
-                    projectPath: finalProjectPath
-                });
-            }
-            else {
-                // Non-streaming mode: collect messages
-                writer = new ResponseCollector(req.user.id);
-                // Collect initial status message
-                writer.send({
-                    type: 'status',
-                    message: githubUrl ? 'Repository cloned and session started' : 'Session started',
-                    projectPath: finalProjectPath
-                });
             }
-            const codexModels = (await providerModelsService.getProviderModels('codex')).models;
-            const opencodeModels = (await providerModelsService.getProviderModels('opencode')).models;
+            // The route's own opening events. `session-id` is the app session id:
+            // what the UI opens the conversation under, and what a later request
+            // passes back as `sessionId` to continue it.
+            writer.send({
+                type: 'status',
+                message: githubUrl ? 'Repository cloned and session started' : 'Session started',
+                projectPath: finalProjectPath
+            });
+            writer.send({ type: 'session-id', sessionId: appSessionId });
+            const codexModels = await providerModelsService.getProviderModels('codex');
+            const opencodeModels = await providerModelsService.getProviderModels('opencode');
             // Start the appropriate session
             if (provider === 'claude') {
                 console.log('🤖 Starting Claude SDK session');
                 await queryClaudeSDK(message.trim(), {
                     projectPath: finalProjectPath,
                     cwd: finalProjectPath,
-                    sessionId: sessionId || null,
+                    sessionId: appSessionId,
                     model: model,
                     effort,
                     permissionMode: 'bypassPermissions' // Bypass all permissions for API calls
-                }, writer);
+                }, run.writer);
             }
             else if (provider === 'cursor') {
                 console.log('🖱️ Starting Cursor CLI session');
                 await spawnCursor(message.trim(), {
                     projectPath: finalProjectPath,
                     cwd: finalProjectPath,
-                    sessionId: sessionId || null,
+                    sessionId: appSessionId,
                     model: model || undefined,
                     skipPermissions: true // Bypass permissions for Cursor
-                }, writer);
+                }, run.writer);
             }
             else if (provider === 'codex') {
                 console.log('🤖 Starting Codex SDK session');
                 await queryCodex(message.trim(), {
                     projectPath: finalProjectPath,
                     cwd: finalProjectPath,
-                    sessionId: sessionId || null,
+                    sessionId: appSessionId,
                     model: model || codexModels.DEFAULT,
                     effort,
                     permissionMode: 'bypassPermissions'
-                }, writer);
+                }, run.writer);
             }
             else if (provider === 'opencode') {
                 console.log('Starting OpenCode CLI session');
                 await spawnOpenCode(message.trim(), {
                     projectPath: finalProjectPath,
                     cwd: finalProjectPath,
-                    sessionId: sessionId || null,
+                    sessionId: appSessionId,
                     model: model || opencodeModels.DEFAULT,
                     effort,
                     permissionMode: 'bypassPermissions' // Agent runs are non-interactive, like the other providers above
-                }, writer);
+                }, run.writer);
+            }
+            // A tab can now abort the run (`chat.abort`), on which the runtime
+            // returns as it does on completion. What the interrupted agent left
+            // behind is not a result to branch or open a PR from.
+            const aborted = run.events.some((event) => event.kind === 'complete' && event.aborted === true);
+            if (aborted) {
+                writer.send({ type: 'status', message: 'Run aborted', aborted: true });
             }
             // Handle GitHub branch and PR creation after successful agent completion
             let branchInfo = null;
             let prInfo = null;
-            if (createBranch || createPR) {
+            if (!aborted && (createBranch || createPR)) {
                 try {
                     console.log('🔄 Starting GitHub branch/PR creation workflow...');
                     // Get GitHub token
@@ -1098,8 +1132,12 @@ export function createAgentRouter(dependencies) {
                 const assistantMessages = writer.getAssistantMessages();
                 const tokenSummary = writer.getTotalTokens();
                 const response = {
-                    success: true,
-                    sessionId: writer.getSessionId(),
+                    success: !aborted,
+                    ...(aborted ? { aborted: true } : {}),
+                    sessionId: appSessionId,
+                    // The provider-native id, for a caller that drives the CLI itself
+                    // (`claude --resume`); `sessionId` is what this API and the UI use.
+                    providerSessionId: run.writer.getSessionId(),
                     messages: assistantMessages,
                     tokens: tokenSummary,
                     projectPath: finalProjectPath
@@ -1116,7 +1154,7 @@ export function createAgentRouter(dependencies) {
             // Clean up if requested
             if (cleanup && githubUrl && clonedProjectCreated) {
                 // Only cleanup if we cloned a repo (not for existing project paths)
-                const sessionIdForCleanup = writer.getSessionId();
+                const sessionIdForCleanup = run.writer.getSessionId();
                 setTimeout(() => {
                     cleanupProject(finalProjectPath, sessionIdForCleanup);
                 }, 5000);
@@ -1126,7 +1164,7 @@ export function createAgentRouter(dependencies) {
             console.error('❌ External session error:', error);
             // Clean up on error
             if (finalProjectPath && cleanup && githubUrl && clonedProjectCreated) {
-                const sessionIdForCleanup = writer ? writer.getSessionId() : null;
+                const sessionIdForCleanup = run ? run.writer.getSessionId() : null;
                 cleanupProject(finalProjectPath, sessionIdForCleanup);
             }
             if (stream) {
@@ -1137,7 +1175,7 @@ export function createAgentRouter(dependencies) {
                     res.setHeader('Cache-Control', 'no-cache');
                     res.setHeader('Connection', 'keep-alive');
                     res.setHeader('X-Accel-Buffering', 'no');
-                    writer = new SSEStreamWriter(res, req.user.id);
+                    writer = new SSEStreamWriter(res);
                 }
                 if (!res.writableEnded) {
                     writer.send({
@@ -1155,6 +1193,15 @@ export function createAgentRouter(dependencies) {
                 });
             }
         }
+        finally {
+            // Safety net, as for a chat send: a runtime that threw or resolved
+            // without its terminal `complete` would leave the session listed as
+            // running in every tab. Scoped to this run, so a run the session
+            // started meanwhile is left alone.
+            if (run) {
+                runRegistry.completeRunIfCurrent(run, { exitCode: 1 });
+            }
+        }
     });
     return router;
 }