chamba 0.3.1 → 0.5.0

package/templates/webterm/resume.js

@@ -0,0 +1,145 @@
+// resume.js - The command that reopens the conversation this workspace was last having.
+//
+// A container you come back to should open where you left off, so the first session of a container start
+// continues the newest conversation instead of beginning one. Working out which conversation that is means
+// reading the store the agent keeps it in, and this is the only place that can honestly do it: the stores
+// are the container's own paths, and the CLIs that write them are installed here and nowhere else.
+//
+// Deliberately next to conversation.js, and deliberately not the same question. That file asks which
+// conversation a live session is having, and answers it from the process tree and the session's start time.
+// This one asks whether there is anything here worth reopening at all, before any session exists, so the
+// directory is the only thing it has to go on.
+//
+// Null is the half that matters. Every one of these CLIs treats "resume, but there is nothing there" as an
+// error and exits, so a resume command with nothing behind it opens the browser onto a session that died on
+// arrival. Null means the session starts the agent fresh, which is the right answer for a workspace with no
+// history.
+
+import { readFileSync } from "node:fs";
+import { basename, dirname } from "node:path";
+import { CLAUDE_TRANSCRIPT, CODEX_ROLLOUT, filesNewestFirst } from "./conversation.js";
+
+// --- Claude ------------------------------------------------------------------------------------------------------------------------------
+
+/**
+ * Claude Code files its transcripts per directory, in a dir named after the directory it ran in with every
+ * character that is not a letter or a digit turned into "-": /workspace -> -workspace, /workspace/apps/api ->
+ * -workspace-apps-api. So a session in a sub-directory reads and writes a different dir from one at the root,
+ * and a resume command built from the wrong one names an id that claude cannot find.
+ * Only the fallback below relies on this naming; the main path reads what a transcript says about itself.
+ */
+export function claudeProjectKey(containerPath) {
+    return containerPath.replace(/[^a-zA-Z0-9]/g, "-");
+}
+
+/**
+ * The most recent claude conversation that can be reopened in `cwd`: the newest transcript with a real
+ * (non-sidechain) user message that ran in that directory. Returns null when nothing qualifies.
+ *
+ * The directory is matched on what the transcript records, not on which dir it sits in, so however claude
+ * names those dirs we never hand back a conversation from somewhere else - resuming it would either fail or
+ * drop the user into another directory's history. Transcripts old enough to record no directory at all are
+ * the fallback, and for those the dir name is the only evidence there is.
+ */
+function claudeResumeId(cwd, stores) {
+    const transcripts = filesNewestFirst(stores.claudeProjects, CLAUDE_TRANSCRIPT);
+    const byRecordedDir = firstResumable(transcripts, cwd);
+    if (byRecordedDir !== null) return byRecordedDir;
+    const key = claudeProjectKey(cwd);
+    return firstResumable(
+        transcripts.filter((path) => basename(dirname(path)) === key),
+        null,
+    );
+}
+
+// The first of these transcripts that can be reopened, in the order given. `requiredCwd` of null asks only
+// that the conversation has messages; a directory asks that it recorded that one too. Transcripts are read
+// in order and the walk stops at the first hit, so the usual case reads a single file.
+function firstResumable(transcriptPaths, requiredCwd) {
+    for (const path of transcriptPaths) {
+        const facts = transcriptFacts(path);
+        if (!facts.resumable) continue;
+        if (requiredCwd !== null && facts.cwd !== requiredCwd) continue;
+        return basename(path).slice(0, -".jsonl".length);
+    }
+    return null;
+}
+
+/**
+ * What a transcript says about itself, in one pass: whether it holds a real user message, and the directory
+ * that message was typed in. Sessions that only recorded UI state (mode changes, slash commands) have
+ * nothing to resume; sidechain records belong to subagents. isSidechain is a field we do not own, so only an
+ * explicit true excludes a record: a record that stopped carrying the field still counts as resumable, which
+ * fails on the safe side. `cwd` is null for transcripts written before claude recorded it.
+ *
+ * Read whole rather than by the head, unlike conversation.js: the first user message can sit behind any
+ * amount of session setup, and answering "resumable" wrongly costs a dead session rather than a retry. The
+ * walk stops at the first hit, and the caller stops at the first resumable file, so the usual cost is the
+ * first few kilobytes of one transcript.
+ */
+function transcriptFacts(transcriptPath) {
+    let content;
+    try {
+        content = readFileSync(transcriptPath, "utf8");
+    } catch {
+        return { resumable: false, cwd: null };
+    }
+    // Walked by index rather than split("\n") so a multi-MB transcript is not copied into an array of lines.
+    let start = 0;
+    while (start <= content.length) {
+        const end = content.indexOf("\n", start);
+        const line = content.slice(start, end === -1 ? content.length : end);
+        start = (end === -1 ? content.length : end) + 1;
+        // Cheap pre-filter so multi-MB transcripts are not JSON.parsed line by line.
+        if (!line.includes('"type":"user"')) continue;
+        try {
+            const record = JSON.parse(line);
+            if (record.type === "user" && record.isSidechain !== true) {
+                return { resumable: true, cwd: typeof record.cwd === "string" ? record.cwd : null };
+            }
+        } catch {
+            // Skip malformed lines.
+        }
+    }
+    return { resumable: false, cwd: null };
+}
+
+// --- Codex and opencode ------------------------------------------------------------------------------------------------------------------
+
+// What reopens a stored conversation, per agent, and where to look to know there is one. claude is not here:
+// it is resumed by id above, because `claude --continue` takes the newest transcript by mtime and silently
+// starts FRESH when that transcript holds no real messages, which makes auto-resume fail quietly whenever
+// such a session happens to be the newest.
+//
+// These two are asked a shallower question than claude - does the store hold a conversation file at all -
+// and their own flag picks which one. Reading each store's format to find out whether the newest
+// conversation is really resumable would tie chamba to two more internal layouts for no gain.
+export const CONTINUE = {
+    opencode: { argv: ["opencode", "--continue"], store: "opencodeSessions", pattern: /\.json$/ },
+    codex: { argv: ["codex", "resume", "--last"], store: "codexSessions", pattern: CODEX_ROLLOUT },
+};
+
+// --- The one entry point -----------------------------------------------------------------------------------------------------------------
+
+/**
+ * The argv that reopens this workspace's most recent conversation for `agent` in `cwd`, or null when there
+ * is nothing to reopen. `stores` is config.js's AGENT_STORES, passed in so this can be exercised against a
+ * fixture the way conversation.js is.
+ *
+ * An agent nobody wrote a reader for is a supported answer, not an error: it starts fresh.
+ */
+export function resumeArgvFor(agent, cwd, stores) {
+    try {
+        if (agent === "claude") {
+            const id = claudeResumeId(cwd, stores);
+            return id === null ? null : ["claude", "--resume", id];
+        }
+        const known = CONTINUE[agent];
+        if (!known) return null;
+        return filesNewestFirst(stores[known.store], known.pattern).length > 0 ? [...known.argv] : null;
+    } catch {
+        // A store that changed shape under us must never take the session down with it - starting fresh is
+        // a worse session than the user asked for, but it is a session.
+        return null;
+    }
+}