@rubytech/create-maxy-code 0.1.357 → 0.1.359

package/payload/platform/services/claude-session-manager/dist/http-server.js

@@ -20,7 +20,7 @@
 // manager does not know.
 import { Hono } from 'hono';
 import { stream } from 'hono/streaming';
-import { existsSync, statSync, createReadStream, watchFile, unwatchFile, rmSync, mkdirSync, renameSync, readFileSync, writeFileSync, openSync, readSync, closeSync } from 'node:fs';
+import { existsSync, statSync, createReadStream, watchFile, unwatchFile, rmSync, mkdirSync, renameSync, readFileSync, writeFileSync, appendFileSync, openSync, readSync, closeSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { buildWaChannelMcpServers, buildWaChannelArgv, waChannelMcpConfigPath, isDevChannelPrompt } from './wa-channel-mcp.js';
 import { buildWebchatChannelMcpServers, buildWebchatChannelArgv, webchatChannelMcpConfigPath } from './webchat-channel-mcp.js';
@@ -28,8 +28,9 @@ import { buildTelegramChannelMcpServers, buildTelegramChannelArgv, telegramChann
 import { buildChannelMcpServers, buildChannelArgv, channelMcpConfigPath } from './channel-mcp.js';
 import { mergeTarget, isMultiTarget, targetKinds } from './channel-targets.js';
 import { randomUUID } from 'node:crypto';
-import { execFileSync } from 'node:child_process';
+import { execFile, execFileSync } from 'node:child_process';
 import { buildRcChildEnv, reapplyAdminLevers } from './rc-daemon.js';
+import { runConnectorAuthLogin } from './connector-auth.js';
 import { isEffortLevel, isNewSessionEffortLevel, isPermissionMode, SONNET_MODEL } from '../../../lib/models/dist/index.js';
 import { spawnClaudeSession, stopSession, writeInterruptToPty, isLive, onPtyExit, livePtyCount, liveSessionIds, getPtyTrackerForTests, livePidForSession, classifyLiveness, priorExitedCountForSession, PERMISSION_MODES, openFdCount, registerRcSpawnPty, } from './pty-spawner.js';
 import { writeScopeRecord, removeScopeRecord } from './scope-record.js';
@@ -155,17 +156,17 @@ function finitePositive(raw, fallback) {
     const n = Number(raw);
     return Number.isFinite(n) && n > 0 ? n : fallback;
 }
-/** Task 1090 Phase 2 — the post-interrupt transcript-integrity check. Reads a
- *  bounded tail of the session JSONL and reports whether a `tool_use` block in
- *  that window has no matching `tool_result` after it — the signature of an
- *  interrupt that landed mid-tool-call, which would corrupt a later `--resume`.
- *  Bounded (last 64KB) so a large transcript never blocks the post-check; the
- *  window only needs the last turn's tool pairing. Returns false on any read
- *  error (no file yet, gone) — absence of evidence is not a dangling use. */
-function tailHasDanglingToolUse(jsonlPath) {
+/** Task 1090 Phase 2 + Task 1184 — the `tool_use` ids in the bounded tail with
+ *  no matching `tool_result` after them: the signature of an interrupt or death
+ *  that landed mid-tool-call, which would corrupt a later `--resume` (the API
+ *  rejects a tool_use with no following tool_result). Bounded (last 64KB) so a
+ *  large transcript never blocks the check; the window only needs the last
+ *  turn's tool pairing. Returns [] on any read error (no file yet, gone) —
+ *  absence of evidence is not a dangling use. Order-preserving. */
+export function danglingToolUseIds(jsonlPath) {
     try {
         if (!existsSync(jsonlPath))
-            return false;
+            return [];
         const size = statSync(jsonlPath).size;
         const window = 64 * 1024;
         const fd = openSync(jsonlPath, 'r');
@@ -175,7 +176,7 @@ function tailHasDanglingToolUse(jsonlPath) {
             const buf = Buffer.alloc(len);
             readSync(fd, buf, 0, len, start);
             const lines = buf.toString('utf8').split('\n');
-            const used = new Set();
+            const used = [];
             const resulted = new Set();
             for (const line of lines) {
                 if (!line)
@@ -193,15 +194,116 @@ function tailHasDanglingToolUse(jsonlPath) {
                     continue;
                 for (const c of content) {
                     if (c.type === 'tool_use' && typeof c.id === 'string')
-                        used.add(c.id);
+                        used.push(c.id);
                     if (c.type === 'tool_result' && typeof c.tool_use_id === 'string')
                         resulted.add(c.tool_use_id);
                 }
             }
-            for (const id of used)
-                if (!resulted.has(id))
-                    return true;
+            return used.filter((id) => !resulted.has(id));
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    catch {
+        return [];
+    }
+}
+function tailHasDanglingToolUse(jsonlPath) {
+    return danglingToolUseIds(jsonlPath).length > 0;
+}
+/** Task 1184 — append one synthetic user record supplying an is_error
+ *  tool_result for each dangling tool_use, so a `--resume` of a session whose
+ *  child died mid-tool-call has no unmatched tool_use. Envelope fields
+ *  (cwd/version/gitBranch/parentUuid) are copied forward from the last on-disk
+ *  record so the synthetic record matches claude's own shape; uuid and
+ *  timestamp are minted. Idempotent: returns false when nothing dangles or on
+ *  any error. */
+export function appendTurnAbortTerminator(jsonlPath, sessionId) {
+    try {
+        const ids = danglingToolUseIds(jsonlPath);
+        if (ids.length === 0)
             return false;
+        const raw = readFileSync(jsonlPath, 'utf8').trimEnd().split('\n');
+        let envelope = {};
+        for (let i = raw.length - 1; i >= 0; i--) {
+            try {
+                envelope = JSON.parse(raw[i]);
+                break;
+            }
+            catch { /* skip non-JSON */ }
+        }
+        const record = {
+            parentUuid: typeof envelope.uuid === 'string' ? envelope.uuid : null,
+            isSidechain: false,
+            userType: 'external',
+            cwd: typeof envelope.cwd === 'string' ? envelope.cwd : undefined,
+            sessionId,
+            version: typeof envelope.version === 'string' ? envelope.version : undefined,
+            gitBranch: typeof envelope.gitBranch === 'string' ? envelope.gitBranch : undefined,
+            type: 'user',
+            uuid: randomUUID(),
+            timestamp: new Date().toISOString(),
+            message: {
+                role: 'user',
+                content: ids.map((id) => ({
+                    tool_use_id: id,
+                    type: 'tool_result',
+                    content: 'Turn aborted: the agent process exited before this tool finished.',
+                    is_error: true,
+                })),
+            },
+        };
+        appendFileSync(jsonlPath, JSON.stringify(record) + '\n');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const TERMINAL_STOP_REASONS = new Set(['end_turn', 'stop_sequence', 'max_tokens']);
+/** Task 1184 — the open-turn signature of a dead-child phantom. Reads the
+ *  bounded tail (last 64KB) and reports whether the last assistant record
+ *  carries no terminal `stop_reason` — the turn was streaming when the child
+ *  died (no end_turn was ever written). A terminal stop (end_turn /
+ *  stop_sequence / max_tokens) is a completed turn → false. No assistant
+ *  record in the window, or any read error → false (absence of evidence is
+ *  not an open turn). */
+export function tailIsOpenTurn(jsonlPath) {
+    try {
+        if (!existsSync(jsonlPath))
+            return false;
+        const size = statSync(jsonlPath).size;
+        const window = 64 * 1024;
+        const fd = openSync(jsonlPath, 'r');
+        try {
+            const start = size > window ? size - window : 0;
+            const len = size - start;
+            const buf = Buffer.alloc(len);
+            readSync(fd, buf, 0, len, start);
+            const lines = buf.toString('utf8').split('\n');
+            let lastAssistantStop = null;
+            let sawAssistant = false;
+            for (const line of lines) {
+                if (!line)
+                    continue;
+                let o;
+                try {
+                    o = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                const rec = o;
+                if (rec.type === 'assistant' || rec.message?.role === 'assistant') {
+                    sawAssistant = true;
+                    const sr = rec.message?.stop_reason;
+                    lastAssistantStop = typeof sr === 'string' ? sr : null;
+                }
+            }
+            if (!sawAssistant)
+                return false;
+            return !(lastAssistantStop !== null && TERMINAL_STOP_REASONS.has(lastAssistantStop));
         }
         finally {
             closeSync(fd);
@@ -502,6 +604,22 @@ function detectCliVersion(claudeBin) {
     }
     return cachedCliVersion;
 }
+// Task 1153 — connectors resumed once this manager lifetime, keyed
+// `${sessionId}::${name}`. A second authenticate-needed for the same pair after a
+// resume is the unexpected case, surfaced via `outcome=still-needs-auth-after-resume`.
+const connectorResumedOnce = new Set();
+// Task 1153 — run `claude mcp login "<name>"` headless under the brand config dir.
+// A claude.ai connector login prints the sdk-cli consent URL and exits 0 with no
+// TTY. Never throws; returns combined stdout+stderr and the exit code.
+function execMcpLogin(claudeBin, claudeConfigDir, name) {
+    return new Promise((resolve) => {
+        execFile(claudeBin, ['mcp', 'login', name], { env: { ...process.env, CLAUDE_CONFIG_DIR: claudeConfigDir }, timeout: 20_000, encoding: 'utf8' }, (err, stdout, stderr) => {
+            const output = `${stdout ?? ''}\n${stderr ?? ''}`;
+            const code = err ? (typeof err.code === 'number' ? err.code : 1) : 0;
+            resolve({ output, code });
+        });
+    });
+}
 export function buildHttpApp(deps) {
     const app = new Hono();
     // Task 702 — the dir holding pid files and rc-spawn scope records.
@@ -745,6 +863,22 @@ export function buildHttpApp(deps) {
         // post-Task-260 rows surface their specialist even if the JSONL
         // doesn't include an agent-setting record.
         const specialist = row.agent ?? row.cachedAgentSetting ?? row.sidecarSpecialist;
+        // Task 1184 — read-time activity reconcile. A busy stamp can outlive its
+        // child: an OOM SIGKILL leaves the PID file on disk, so the watcher row
+        // stays `busy` with no live PTY to ever flip it. Reconcile here so the
+        // pointer poll stops reporting an in-flight turn for a dead child — and,
+        // when the transcript tail is an open turn, mark it `aborted` so the UI
+        // shows the resume notice. This cannot persist past one read.
+        let activity = row.status;
+        let turnAborted;
+        if (row.status === 'busy' && !isLive(row.sessionId)) {
+            if (hasJsonl && tailIsOpenTurn(jsonlPath)) {
+                activity = 'aborted';
+                turnAborted = true;
+            }
+            else
+                activity = 'idle';
+        }
         return {
             sessionId: row.sessionId,
             pid: row.pid,
@@ -767,7 +901,8 @@ export function buildHttpApp(deps) {
             model,
             permissionMode: row.permissionMode,
             effectivePermissionMode: row.effectivePermissionMode,
-            activity: row.status,
+            activity,
+            turnAborted,
         };
     }
     app.post('/public-spawn', async (c) => {
@@ -1395,6 +1530,39 @@ export function buildHttpApp(deps) {
         return c.json({ ok: true, sessionId, titleSource: 'user', renamedAt: entry.renamedAt }, 200);
     });
     // SIGTERM-only stop. Idempotent on already-dead PTYs. JSONL untouched.
+    // Task 1153 — TUI-free claude.ai connector authentication for the admin webchat.
+    // The webchat-channel `connector_authenticate` tool reaches here via the UI
+    // gateway. `completed:false` runs `claude mcp login` and returns the consent URL;
+    // `completed:true` recycles the session so the operator's next inbound re-spawns
+    // with --resume and reads the new grant. Decision logic lives in connector-auth.ts.
+    app.post('/connector-auth-login', async (c) => {
+        const start = Date.now();
+        const body = await c.req.json().catch(() => null);
+        const sessionId = body?.sessionId;
+        const name = body?.name;
+        const completed = body?.completed === true;
+        if (typeof sessionId !== 'string' || !SESSION_ID_PATTERN.test(sessionId) || typeof name !== 'string' || !name.trim()) {
+            timed(deps.logger, 'POST', '/connector-auth-login', 400, Date.now() - start);
+            return c.json({ error: 'sessionId and name required' }, 400);
+        }
+        const result = await runConnectorAuthLogin({
+            logger: deps.logger,
+            runMcpLogin: (n) => execMcpLogin(deps.claudeBin, deps.claudeConfigDir, n),
+            recycleSession: async (sid) => {
+                const row = resolveRow(deps.watcher, sid);
+                await stopSession({
+                    killGraceMs: deps.killGraceMs,
+                    logger: deps.logger,
+                    runSystemctl: deps.runSystemctl,
+                    rowScopeUnitToken: row?.scopeUnitToken ?? null,
+                    rowPid: row?.pid ?? null,
+                }, sid);
+            },
+            resumedOnce: connectorResumedOnce,
+        }, { sessionId, name, completed });
+        timed(deps.logger, 'POST', '/connector-auth-login', 200, Date.now() - start);
+        return c.json(result, 200);
+    });
     app.post('/:sessionId/stop', async (c) => {
         const start = Date.now();
         const id = c.req.param('sessionId');
@@ -1581,6 +1749,19 @@ export function buildHttpApp(deps) {
         deps.logger(`[webchat-interrupt] op=interrupt-requested intId=${intId} sessionId=${sessionId.slice(0, 8)} trigger=${trigger}`);
         const result = writeInterruptToPty(sessionId, byte, deps.logger);
         if (!result.ok) {
+            if (result.error === 'not-found' || result.error === 'exited') {
+                const jsonlPath = jsonlPathForSessionId(deps.spawnCwd, sessionId);
+                // Task 1184 — a dead-child phantom: no live PTY and the transcript tail
+                // is an open turn. Recover instead of bare-404 so the operator's stop
+                // press clears the phantom and a later --resume is clean.
+                if (!isLive(sessionId) && tailIsOpenTurn(jsonlPath)) {
+                    appendTurnAbortTerminator(jsonlPath, sessionId);
+                    const tailTurnClosed = !tailIsOpenTurn(jsonlPath);
+                    deps.logger(`[webchat-interrupt] op=dead-child-recovered intId=${intId} sessionId=${sessionId.slice(0, 8)} tailTurnClosed=${tailTurnClosed}`);
+                    timed(deps.logger, 'POST', `/${id}/interrupt`, 200, Date.now() - start);
+                    return c.json({ ok: true, deadChild: true, resumable: true }, 200);
+                }
+            }
             if (result.error === 'not-found') {
                 timed(deps.logger, 'POST', `/${id}/interrupt`, 404, Date.now() - start);
                 return c.json({ error: 'session-not-found' }, 404);
@@ -2741,6 +2922,22 @@ export function buildHttpApp(deps) {
             // 500 ms idle deadline before the child exited.
             if (!outputEmitted)
                 emitChildOutput();
+            // Task 1184 — self-heal a dead-child phantom. If the child exits while
+            // its transcript tail is an open turn, emit the abort event and write
+            // the terminator so a later --resume is clean. Only a known (resumed)
+            // session has a JSONL to reconcile; a fresh spawn that dies before
+            // binding has no id and no transcript. The visible turnActive flip
+            // happens via the read-time activity reconcile on the next poll.
+            if (sessionId) {
+                try {
+                    const jsonlPath = jsonlPathForSessionId(deps.spawnCwd, sessionId);
+                    if (tailIsOpenTurn(jsonlPath)) {
+                        deps.logger(`[rc-life] op=turn-aborted sessionId=${sessionId.slice(0, 8)} reason=child-exit-mid-turn`);
+                        appendTurnAbortTerminator(jsonlPath, sessionId);
+                    }
+                }
+                catch { /* exit path must never throw */ }
+            }
             // Task 977 — close the per-session child log on exit.
             childLog.close();
         });