@ctrl-spc/cs 0.7.0 → 0.7.1

package/dist/panel3/session.js

@@ -0,0 +1,128 @@
+import { chmodSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { configDir } from '../config.js';
+export const OWNER_SESSION_GRACE_MS = 30_000;
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+export const validSessionUuid = (value) => typeof value === 'string' && UUID.test(value);
+export function ownerSessionsRoot() {
+    return join(configDir(), 'panel3-sessions');
+}
+export function ownerSessionPath(ownerId) {
+    if (!validSessionUuid(ownerId))
+        throw new Error('an owner session requires a valid run id');
+    return join(ownerSessionsRoot(), `${ownerId}.json`);
+}
+function validRecord(value, ownerId) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const row = value;
+    return row.ownerId === ownerId
+        && (row.harness === 'claude' || row.harness === 'codex')
+        && validSessionUuid(row.nativeSessionId)
+        && validSessionUuid(row.processToken)
+        && (row.state === 'pending' || row.state === 'established')
+        && typeof row.updatedAt === 'string'
+        && Number.isFinite(new Date(row.updatedAt).getTime());
+}
+/** Invalid local data is never handed to a harness as a resume selector. */
+export function readOwnerSession(ownerId) {
+    let path;
+    try {
+        path = ownerSessionPath(ownerId);
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        if (validRecord(parsed, ownerId))
+            return parsed;
+    }
+    catch {
+        // Missing and malformed are both absence to the caller. Malformed is removed below.
+        try {
+            path = ownerSessionPath(ownerId);
+        }
+        catch {
+            return null;
+        }
+    }
+    try {
+        rmSync(path, { force: true });
+    }
+    catch { /* reconciliation retries */ }
+    return null;
+}
+/** One file per owner prevents two daemons updating different owners from
+ * losing each other's mappings. Same-directory rename makes each record whole
+ * or absent across a crash. */
+export function writeOwnerSession(record) {
+    const stored = { ...record, updatedAt: record.updatedAt ?? new Date().toISOString() };
+    if (!validRecord(stored, stored.ownerId))
+        throw new Error('invalid owner session record');
+    const root = ownerSessionsRoot();
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    chmodSync(root, 0o700);
+    const path = ownerSessionPath(record.ownerId);
+    const temporary = join(root, `.${record.ownerId}.${randomUUID()}.tmp`);
+    try {
+        writeFileSync(temporary, `${JSON.stringify(stored)}\n`, { mode: 0o600 });
+        renameSync(temporary, path);
+    }
+    finally {
+        try {
+            rmSync(temporary, { force: true });
+        }
+        catch { /* a later reconciliation can remove it */ }
+    }
+}
+export function establishOwnerSession(ownerId, processToken) {
+    const record = readOwnerSession(ownerId);
+    if (!record || record.state !== 'pending' || record.processToken !== processToken)
+        return false;
+    writeOwnerSession({ ...record, state: 'established', updatedAt: new Date().toISOString() });
+    return true;
+}
+export function removeOwnerSession(ownerId) {
+    try {
+        rmSync(ownerSessionPath(ownerId), { force: true });
+    }
+    catch { /* reconciliation retries */ }
+}
+export function removeOwnerSessionIfToken(ownerId, processToken) {
+    const record = readOwnerSession(ownerId);
+    if (!record || record.processToken !== processToken)
+        return false;
+    removeOwnerSession(ownerId);
+    return true;
+}
+/** Names, not contents. Malformed names and temp remnants are removed here and
+ * never become database selectors. */
+export function listOwnerSessionIds(now = Date.now()) {
+    let entries;
+    try {
+        entries = readdirSync(ownerSessionsRoot());
+    }
+    catch {
+        return [];
+    }
+    const ids = [];
+    for (const entry of entries) {
+        const match = /^([0-9a-f-]+)\.json$/i.exec(entry);
+        if (match && validSessionUuid(match[1])) {
+            ids.push(match[1]);
+            continue;
+        }
+        const temporary = /^\.([0-9a-f-]+)\.([0-9a-f-]+)\.tmp$/i.exec(entry);
+        if (temporary && validSessionUuid(temporary[1]) && validSessionUuid(temporary[2])) {
+            try {
+                if (now - statSync(join(ownerSessionsRoot(), entry)).mtimeMs < OWNER_SESSION_GRACE_MS)
+                    continue;
+            }
+            catch {
+                continue;
+            }
+        }
+        try {
+            rmSync(join(ownerSessionsRoot(), entry), { recursive: true, force: true });
+        }
+        catch { /* retry later */ }
+    }
+    return ids;
+}

package/dist/panel3/show.js

@@ -61,7 +61,8 @@ export async function withAskContent(client, asks) {
     if (ids.length === 0)
         return asks;
     const decisions = await read(client.from('decisions')
-        .select('id, question, answer, category, context, answer_mode, options, selected_options, answer_note')
+        .select('id, question, answer, category, context, answer_mode, options, selected_options, '
+        + 'answer_note, related_artifact_id, related_artifact_revision')
         .in('id', ids), 'decisions');
     /* THE CONTENT ONLY. The decision's own `id` is dropped here rather than
        spread and overwritten: the ask row's id is what every caller answers,

package/dist/panel3/spawn.js

@@ -120,8 +120,9 @@
  * with exactly the authority that level has.
  */
 import { spawn as spawnChild } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
 import { agentPath } from '../agents.js';
-import { ensureCodexRunHome, removeCodexRunHome } from '../codex-home.js';
+import { ensureCodexRunHome, ensurePanel3CodexOwnerHome, removeCodexRunHome, } from '../codex-home.js';
 import { windowsSafeSpawn } from '../win-shell.js';
 const AGENT_VAR = 'CTRL_SPC_V3_AGENT';
 /**
@@ -168,9 +169,14 @@ const allowedTools = (level) => [`mcp__${SERVER}__*`, ...(level === 1 ? [] : COD
  * checked without starting a process — which is how the allowlist is proved,
  * and how it stays provable after this task.
  */
-export function agentArgs(level, toolsUrl, agent = harness(), platform = process.platform) {
+export function agentArgs(level, toolsUrl, agent = harness(), platform = process.platform, ownerSession) {
     if (agent === 'codex')
-        return codexArgs(level, toolsUrl, platform);
+        return codexArgs(level, toolsUrl, platform, ownerSession);
+    const session = ownerSession
+        ? ownerSession.resumeSessionId
+            ? ['--resume', ownerSession.resumeSessionId]
+            : ['--session-id', ownerSession.freshSessionId ?? randomUUID()]
+        : [];
     return [
         // `-p` with the prompt on stdin. See the header.
         '-p',
@@ -180,6 +186,7 @@ export function agentArgs(level, toolsUrl, agent = harness(), platform = process
         '--setting-sources', '',
         '--tools', builtIns(level),
         '--allowedTools', allowedTools(level),
+        ...session,
         /* STATED WHERE THERE IS SOMETHING TO STATE. `acceptEdits` grants file edits
            to a headless process with nobody at a prompt to approve them, and it is
            passed only to the levels that have a file tool to use it with: at level 1
@@ -214,16 +221,18 @@ export function agentArgs(level, toolsUrl, agent = harness(), platform = process
  * `--json` makes the answer an `agent_message` item read out of the stream
  * rather than whatever prose happened to reach stdout (see `codexAnswer`).
  */
-function codexArgs(level, toolsUrl, platform) {
+function codexArgs(level, toolsUrl, platform, ownerSession) {
+    const resume = ownerSession?.resumeSessionId;
     return [
         'exec',
+        ...(resume ? ['resume', resume, '-'] : []),
         // The prompt arrives on stdin, exactly as it does for claude: `codex exec`
         // reads it from there when no prompt argument is given.
         '--json',
         // The level 1 scratch directory is not a repository, and neither need a
         // working copy be.
         '--skip-git-repo-check',
-        '--ephemeral',
+        ...(ownerSession ? [] : ['--ephemeral']),
         '--ignore-rules',
         /* The current Windows Desktop runtime can define the run's one MCP server
            on argv. Keeping the machine's real CODEX_HOME lets its installed sandbox
@@ -245,7 +254,9 @@ function codexArgs(level, toolsUrl, platform) {
            `danger-full-access`. Level 1 has no file tool to use it with, so it gets
            the read-only sandbox instead — see the block comment above for what that
            does and does not buy. */
-        '-s', level === 1 ? 'read-only' : 'workspace-write',
+        ...(resume
+            ? ['-c', `sandbox_mode=${JSON.stringify(level === 1 ? 'read-only' : 'workspace-write')}`]
+            : ['-s', level === 1 ? 'read-only' : 'workspace-write']),
         /* The write sandbox sandboxes the NETWORK too, and an agent handed a
            credential that can then reach nothing is a dead end. Only where there is
            a write sandbox to say it about. */
@@ -363,9 +374,10 @@ function tail(text, chars = 500) {
  * process still alive" after the daemon that started it has been killed. So the
  * caller gets the pid immediately, writes it, and then waits.
  */
-export function startAgent(prompt, level, toolsUrl, cwd) {
+export function startAgent(prompt, level, toolsUrl, cwd, ownerSession) {
     const failed = (reason) => ({
         pid: null,
+        session: Promise.resolve(null),
         answered: Promise.resolve({ ok: false, reason }),
     });
     let agent;
@@ -377,7 +389,10 @@ export function startAgent(prompt, level, toolsUrl, cwd) {
         // `harness()`: running the other one instead is the lie, not the failure.
         return failed(err.message);
     }
-    const ARGS = agentArgs(level, toolsUrl, agent);
+    const launchedOwnerSession = ownerSession && !ownerSession.resumeSessionId
+        ? { ...ownerSession, freshSessionId: randomUUID() }
+        : ownerSession;
+    const ARGS = agentArgs(level, toolsUrl, agent, process.platform, launchedOwnerSession);
     const bin = agentPath(agent);
     if (!bin) {
         return failed(`${agent} is not installed on this machine`);
@@ -387,10 +402,12 @@ export function startAgent(prompt, level, toolsUrl, cwd) {
        isolates its configuration and grants this run's one server on argv. */
     const windowsCodex = agent === 'codex' && process.platform === 'win32';
     const home = agent === 'codex' && !windowsCodex
-        // `false`: v3 closes codex's own subagent tool, the same depth-stops-at-
-        // three rule `CODE_TOOLS` enforces for claude below. v2's callers never
-        // pass this and keep today's behaviour; see `codex-home.ts`.
-        ? ensureCodexRunHome({ url: toolsUrl }, null, runKey(toolsUrl), false)
+        ? ownerSession
+            ? ensurePanel3CodexOwnerHome({ url: toolsUrl }, ownerSession.ownerId)
+            // `false`: v3 closes codex's own subagent tool, the same depth-stops-at-
+            // three rule `CODE_TOOLS` enforces for claude below. v2's callers never
+            // pass this and keep today's behaviour; see `codex-home.ts`.
+            : ensureCodexRunHome({ url: toolsUrl }, null, runKey(toolsUrl), false)
         : null;
     if (agent === 'codex' && !windowsCodex && !home) {
         return failed('codex is not signed in on this machine, so a run cannot be given this product\'s tools '
@@ -419,10 +436,24 @@ export function startAgent(prompt, level, toolsUrl, cwd) {
     catch (err) {
         // NOT `err.message`, which names the binary's absolute path. See
         // `couldNotStart`.
-        if (home)
+        if (home && !ownerSession)
             removeCodexRunHome(home);
         return failed(couldNotStart(err, agent));
     }
+    let resolveSession;
+    let sessionSettled = false;
+    const session = new Promise((resolve) => { resolveSession = resolve; });
+    const observeSession = (value) => {
+        if (sessionSettled)
+            return;
+        sessionSettled = true;
+        resolveSession(value);
+    };
+    if (!ownerSession)
+        observeSession(null);
+    else if (agent === 'claude') {
+        observeSession(launchedOwnerSession?.resumeSessionId ?? launchedOwnerSession?.freshSessionId ?? null);
+    }
     const answered = new Promise((resolve) => {
         let stdout = '';
         let stderr = '';
@@ -447,11 +478,32 @@ export function startAgent(prompt, level, toolsUrl, cwd) {
             /* THE CREDENTIAL COPY GOES WHEN THE RUN DOES. `codex-home.ts` calls this
                the primary reclaim and the startup sweep the backstop; a home left
                behind holds a copy of the user's codex credential. */
-            if (home)
+            if (home && !ownerSession)
                 removeCodexRunHome(home);
+            if (!sessionSettled)
+                observeSession(null);
             resolve(answer);
         };
-        child.stdout?.on('data', (d) => { stdout = collect(stdout, String(d)); });
+        child.stdout?.on('data', (d) => {
+            stdout = collect(stdout, String(d));
+            if (ownerSession && agent === 'codex' && !sessionSettled) {
+                for (const line of stdout.split('\n')) {
+                    try {
+                        const event = JSON.parse(line);
+                        if (event.type === 'thread.started' && typeof event.thread_id === 'string') {
+                            const id = event.thread_id;
+                            if (/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(id)) {
+                                observeSession(id);
+                                break;
+                            }
+                        }
+                    }
+                    catch {
+                        // The final answer parser owns protocol validity. This observer only finds one event.
+                    }
+                }
+            }
+        });
         child.stderr?.on('data', (d) => { stderr = collect(stderr, String(d)); });
         /* ENOENT and friends. The process never ran, and that is what is reported —
            WITHOUT the message, which is where node puts the binary's absolute path.
@@ -459,14 +511,24 @@ export function startAgent(prompt, level, toolsUrl, cwd) {
         child.on('error', (err) => {
             finish({ ok: false, reason: couldNotStart(err, agent) });
         });
-        child.on('close', (code) => {
+        child.on('close', (code, signal) => {
             /* ═══ THREE OUTCOMES, AND ONLY ONE OF THEM IS AN ANSWER. ═══ A non-zero
                exit and an exit of zero that said nothing are both failures, and
                neither may be returned as an empty answer: the daemon would write a
                blank agent turn and the card would read as answered. That is the
                forbidden state ux.md is about, reached by treating silence as
                success. */
-            if (code !== 0) {
+            if (signal !== null) {
+                /* ═══ A SIGNALLED PROCESS HAS NO EXIT CODE, AND SAYING IT "EXITED NULL"
+                   IS NOT TRUE. ═══ `code` is null exactly when a signal ended the
+                   process, and this daemon is the only thing that signals one: the
+                   person's Stop (`killStopped`) and the person's correction
+                   (`redirectedProcess`). Both reach here, both are printed, and the
+                   second one can reach `failed_because` and a person's card if the
+                   respawn behind it is refused. Naming the signal is the whole fix. */
+                finish({ ok: false, reason: `${agent} was ended by ${signal}${tail(stderr) || tail(stdout)}` });
+            }
+            else if (code !== 0) {
                 /* STDOUT WHEN STDERR IS EMPTY, because `claude -p` prints its own
                    failure on stdout and exits non-zero having written nothing to
                    stderr. Reporting only "exited 1" would throw away the one sentence
@@ -499,5 +561,5 @@ export function startAgent(prompt, level, toolsUrl, cwd) {
         child.stdin?.on('error', () => { });
         child.stdin?.end(prompt);
     });
-    return { pid: child.pid ?? null, answered };
+    return { pid: child.pid ?? null, session, answered };
 }