@ctrl-spc/cs 0.7.15 → 0.7.16

package/dist/mcp.js

@@ -1,3 +1,4 @@
+import { deferMcpCleanup, pendingMcpCleanup, acknowledgeMcpCleanup } from './daemon-processes.js';
 import { listStructureArtifactsHandler, getStructureArtifactHandler, searchAgentCardsHandler, createStructureArtifactHandler, updateStructureArtifactHandler } from './product-tools.js';
 import { createEpicHandler, createSprintHandler, listStructureHandler, updateStructureHandler } from './product-tools.js';
 export { createEpicHandler, createSprintHandler, listStructureHandler, updateStructureHandler } from './product-tools.js';
@@ -20,9 +21,10 @@ import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
 import { workflowToolPermission, validateWorkflowToolTarget, WORKFLOW_TOOL_TEACHING, WORKFLOW_AUTHORING_TEACHING, authorToolMentions } from './workflows.js';
 import { workflowToolForName, validateApprovalAction } from './workflow-tool-mentions.js';
+import { clientSessionCurrent } from './supabase.js';
 import { TOOLS_SERVER_PORT, SESSION_TTL_MS } from './env.js';
 import { agentPath } from './agents.js';
-import { mcpToken, readMcpToken, readSession } from './config.js';
+import { mcpToken, readMcpToken } from './config.js';
 import { FIREWALL_WRITING_RULE } from './firewall.js';
 /* The path rule itself, moved out so `workflows.ts` can ask the same question
    before it builds a workflow. `refuseAbsolutePaths` below is still v2's own
@@ -9237,6 +9239,7 @@ runTodoIdSource = null) {
                     await releaseSessionReservations([prevTodo.sessionId], client);
                 }
                 openSessions.set(connectionId, {
+                    accountId: userId,
                     sessionId: opened.id,
                     taskId: null,
                     todoId: args.todo_id,
@@ -9380,6 +9383,7 @@ runTodoIdSource = null) {
             // Record the new session in the registry keyed by connectionId, with a
             // fresh activity-TTL (extended by every subsequent tool call).
             openSessions.set(connectionId, {
+                accountId: userId,
                 sessionId: session.id,
                 taskId: session.task_id,
                 expiresAt: Date.now() + SESSION_TTL_MS,
@@ -11034,7 +11038,7 @@ export async function releaseSessionReservations(sessionIds,
 /** The client to use. The lifecycle helpers hold `toolsClient`; the tool
  *  handlers hold their own per-connection client and pass it, matching what
  *  they use for the session-status write immediately above each call. */
-client = toolsClient) {
+client = toolsClient, strict = false) {
     if (!client || sessionIds.length === 0)
         return;
     try {
@@ -11049,6 +11053,8 @@ client = toolsClient) {
             throw new Error(error.message);
     }
     catch (err) {
+        if (strict)
+            throw err;
         /* NOTHING ABOVE THIS, following `noteDroppedActivity` and the session
            helpers. The session is already ended, which is the fact the product
            reads; an unreleased lease degrades to exactly the pre-slice behaviour
@@ -11366,64 +11372,49 @@ export async function noteDroppedActivity(todoId) {
         console.warn(`recording a dropped activity write failed: ${errorMessage(err)}`);
     }
 }
-/** Mark ONE connection's open session ended (connection closed). Best-effort. */
-export async function endConnectionSession(connectionId) {
-    const s = openSessions.get(connectionId);
-    /* 18c Slice 6: the remembered session is cleared HERE and only here, because
-       it is scoped to the CONNECTION rather than to the session. The connection
-       is gone, so nothing can produce anything else under it. */
-    lastSessionByConnection.delete(connectionId);
-    if (!toolsClient || !s) {
-        openSessions.delete(connectionId);
+/** Flush only the authenticated account's durable cleanup, using its captured client. */
+export async function reconcileMcpCleanup(client, accountId) {
+    const sessionIds = pendingMcpCleanup(accountId);
+    if (!sessionIds.length)
         return;
-    }
+    const { error } = await client.from('cliv2_agent_sessions').update({ status: 'ended' }).in('id', sessionIds);
+    if (error)
+        throw error;
+    await releaseSessionReservations(sessionIds, client, true);
+    acknowledgeMcpCleanup(accountId, sessionIds);
+}
+/** Retire the local connection immediately; cloud cleanup survives authentication loss. */
+export async function endConnectionSession(connectionId) {
+    const client = toolsClient;
+    const session = openSessions.get(connectionId);
+    if (session)
+        deferMcpCleanup([session]);
     openSessions.delete(connectionId);
-    try {
-        const { error } = await toolsClient
-            .from('cliv2_agent_sessions')
-            .update({ status: 'ended' })
-            .eq('id', s.sessionId);
-        if (error)
-            throw error;
-    }
-    catch (err) {
-        console.warn(`ending session on connection close failed: ${err.message}`);
-    }
-    /* 18c SLICE 9 (GAP 15), ROUTE 4a. THE CONNECTION IS GONE, so nothing can
-       ever release these leases by asking. This is what covers every orchestrator
-       finish path: they all end the agent PROCESS, and a dead process's MCP
-       connection closes here. See `releaseSessionReservations` for why the fix
-       hangs off the session rather than off those ten callers. */
-    await releaseSessionReservations([s.sessionId]);
-}
-/** Mark ALL open sessions ended and clear the registry (server stop / logout). */
-export async function endAllOpenSessions() {
-    if (openSessions.size === 0) {
-        return;
+    lastSessionByConnection.delete(connectionId);
+    if (client && session) {
+        try {
+            await reconcileMcpCleanup(client, session.accountId);
+        }
+        catch {
+            console.warn('Session cleanup is waiting for its original account to reconnect.');
+        }
     }
-    const sessionIds = [...openSessions.values()].map((s) => s.sessionId);
+}
+export async function endAllOpenSessions(client = toolsClient) {
+    const sessions = [...openSessions.values()];
+    deferMcpCleanup(sessions);
     openSessions.clear();
-    /* 18c Slice 6: server stop or logout. Every connection is going away, so no
-       later write can legitimately attribute to any of these. */
     lastSessionByConnection.clear();
-    if (!toolsClient)
+    if (!client)
         return;
-    try {
-        const { error } = await toolsClient
-            .from('cliv2_agent_sessions')
-            .update({ status: 'ended' })
-            .in('id', sessionIds);
-        if (error)
-            throw error;
-    }
-    catch (err) {
-        console.warn(`ending all open sessions failed: ${err.message}`);
+    for (const accountId of new Set(sessions.map(session => session.accountId))) {
+        try {
+            await reconcileMcpCleanup(client, accountId);
+        }
+        catch {
+            console.warn('Session cleanup is waiting for its original account to reconnect.');
+        }
     }
-    /* 18c SLICE 9 (GAP 15), ROUTE 4b. Server stop or logout: every session is
-       over at once, so every lease any of them holds goes with them. On logout in
-       particular, leaving them active would have the next sign-in's first run
-       collide with an account that is no longer even connected. */
-    await releaseSessionReservations(sessionIds);
 }
 async function readJsonBody(req) {
     const chunks = [];
@@ -11537,7 +11528,7 @@ export async function startToolsServer(deps) {
         // clear session.json — it can't reach this server's in-memory session. So
         // every request (including ones on an already-open MCP connection) re-checks
         // the on-disk session; once it's gone, nothing is served for the old account.
-        if (!readSession()) {
+        if (!clientSessionCurrent(deps.client)) {
             res.writeHead(401, { 'Content-Type': 'text/plain' }).end('Logged out');
             return;
         }
@@ -11563,6 +11554,12 @@ export async function startToolsServer(deps) {
                 await existing.handleRequest(req, res);
                 return;
             }
+            if (sessionId) {
+                // MCP clients reinitialize after a lost session only when it returns 404.
+                sessionTodoIds.delete(sessionId);
+                res.writeHead(404, { 'Content-Type': 'text/plain' }).end('Session not found');
+                return;
+            }
             if (req.method !== 'POST') {
                 res.writeHead(400, { 'Content-Type': 'text/plain' }).end('Bad Request: no valid session ID provided');
                 return;
@@ -11668,9 +11665,11 @@ export async function stopToolsServer() {
     // D2b: flip every open work session to ended (this needs toolsClient) BEFORE
     // dropping the client reference, so the board's "working" chips clear on server
     // stop / logout; then release the client alongside the reg-status resets.
-    await endAllOpenSessions();
-    toolsClient = null;
+    const client = toolsClient;
     await h.close();
+    void endAllOpenSessions(client).catch(error => console.warn(`Session cleanup remains incomplete: ${String(error)}`));
+    if (toolsClient === client)
+        toolsClient = null;
 }
 /** Whether the tools server is currently listening, and its fixed port. */
 export function toolsServerStatus() {