chamba 0.5.0 → 0.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "chamba",
-    "version": "0.5.0",
+    "version": "0.5.1",
     "description": "Run AI coding agents in a container, from your browser",
     "type": "module",
     "bin": {

package/templates/webterm/conversation.js

@@ -35,11 +35,15 @@ const MAX_JSON_BYTES = 1024 * 1024;
 const MAX_STORE_DEPTH = 5;
 
 /**
- * Files under `dir` matching `pattern`, newest first, capped. Depth-limited; unreadable dirs contribute nothing.
- * Exported for resume.js, which reads the same stores to answer a different question.
+ * Every matching file under `dir`, in no particular order, each handed to `onFile`. Returning true from
+ * `onFile` stops the walk, which is what lets a caller that only needs to know whether there is one at all
+ * stop at the first instead of listing a whole store.
+ *
+ * Depth-limited, and unreadable dirs contribute nothing. Symlinks are skipped rather than followed: these
+ * stores are the agents' own, and a link in one of them would only ever lead somewhere this has no business
+ * reading - readdir reports one as neither a file nor a directory, which is what leaves it out.
  */
-export function filesNewestFirst(dir, pattern, depth = MAX_STORE_DEPTH) {
-    const found = [];
+function walkStore(dir, pattern, depth, onFile) {
     const queue = [{ dir, depth }];
     while (queue.length > 0) {
         const current = queue.shift();
@@ -51,25 +55,52 @@ export function filesNewestFirst(dir, pattern, depth = MAX_STORE_DEPTH) {
         }
         for (const entry of entries) {
             const full = join(current.dir, entry.name);
-            // Symlinks are skipped rather than followed: these stores are the agents' own, and a link in one
-            // of them would only ever lead somewhere this lookup has no business reading.
             if (entry.isDirectory() && current.depth > 0) {
                 queue.push({ dir: full, depth: current.depth - 1 });
-            } else if (entry.isFile() && pattern.test(entry.name)) {
-                try {
-                    found.push({ path: full, mtime: statSync(full).mtimeMs });
-                } catch {
-                    // Vanished between the listing and the stat.
-                }
+            } else if (entry.isFile() && pattern.test(entry.name) && onFile(full)) {
+                return;
             }
         }
     }
+}
+
+/**
+ * Files under `dir` matching `pattern`, newest first, capped.
+ * Exported for resume.js, which reads the same stores to answer a different question.
+ */
+export function filesNewestFirst(dir, pattern, depth = MAX_STORE_DEPTH) {
+    const found = [];
+    walkStore(dir, pattern, depth, (path) => {
+        try {
+            found.push({ path, mtime: statSync(path).mtimeMs });
+        } catch {
+            // Vanished between the listing and the stat.
+        }
+        return false;
+    });
     return found
         .sort((a, b) => b.mtime - a.mtime)
         .slice(0, MAX_CANDIDATES)
         .map((entry) => entry.path);
 }
 
+/**
+ * Whether the store holds anything matching at all, stopping at the first one it finds.
+ *
+ * The cheap half of the question above, and the only half resume.js asks of codex and opencode: they are
+ * reopened by their own flag rather than by id, so all that is wanted is whether there is a conversation
+ * there. Answering that by listing and stat-ing everything first is what would make a heavy opencode store -
+ * one file per message part - a pause on the way to a new session.
+ */
+export function hasAnyFile(dir, pattern, depth = MAX_STORE_DEPTH) {
+    let found = false;
+    walkStore(dir, pattern, depth, () => {
+        found = true;
+        return true;
+    });
+    return found;
+}
+
 /**
  * The head of a file as text, or "" when it cannot be read.
  *
@@ -196,6 +227,12 @@ export function claudeConversationId(session, stores) {
 // rollout-<timestamp>-<uuid>.jsonl - the uuid is the conversation id codex resumes by.
 export const CODEX_ROLLOUT = /^rollout-.*-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/;
 
+// The same rollout once codex has compressed it. Rollouts are compressed when they go cold, so a store whose
+// history has all gone cold holds nothing matching the pattern above - which is why resume.js asks with this
+// one instead. It is deliberately not what a live session is matched against below: compressing a rollout
+// rewrites it, and the fresh mtime that leaves behind looks exactly like a session writing to it.
+export const CODEX_ANY_ROLLOUT = /^rollout-.*-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl(\.zst)?$/;
+
 /** Codex's conversation id for a session: the newest rollout file that could be this session's. */
 export function codexConversationId(session, stores) {
     for (const path of filesNewestFirst(stores.codexSessions, CODEX_ROLLOUT)) {
@@ -208,13 +245,20 @@ export function codexConversationId(session, stores) {
 
 // --- OpenCode ----------------------------------------------------------------------------------------------------------------------------
 
+// How far under opencode's store a session record sits. It nests everything under
+// storage/session/{info,message,part}/, and only info/ holds one file per session - message/ and part/ hold
+// one per message and one per message part, deeper down and far newer. So the bound is not a cost saving
+// here but the whole of the answer: without it the newest .json in the store is a message part, and the pane
+// would file a conversation's pages under an id that changes with every message.
+const OPENCODE_SESSION_DEPTH = 1;
+
 /**
  * OpenCode's conversation id for a session: the newest session record in its local store that could be this
  * session's. The id comes from the record when it carries one and from the filename otherwise, which is the
  * same value - opencode names the file after the session.
  */
 export function opencodeConversationId(session, stores) {
-    for (const path of filesNewestFirst(stores.opencodeSessions, /\.json$/)) {
+    for (const path of filesNewestFirst(stores.opencodeSessions, /\.json$/, OPENCODE_SESSION_DEPTH)) {
         if (mtimeOf(path) < session.since) continue;
         const record = readJson(path);
         const recorded = firstPathField(record);

package/templates/webterm/resume.js

@@ -17,7 +17,15 @@
 
 import { readFileSync } from "node:fs";
 import { basename, dirname } from "node:path";
-import { CLAUDE_TRANSCRIPT, CODEX_ROLLOUT, filesNewestFirst } from "./conversation.js";
+import { CLAUDE_TRANSCRIPT, CODEX_ANY_ROLLOUT, filesNewestFirst, hasAnyFile } from "./conversation.js";
+
+// How far below a store's root a conversation can sit, per store, because the shapes are not alike and a walk
+// deep enough for the deepest is wasted on the others. codex files rollouts under a date tree
+// (sessions/2026/08/24/); opencode nests everything under storage/session/{info,message,part}/, where part/
+// holds one file per message part and is the reason a bound matters at all; claude's transcripts sit exactly
+// one level down, in a dir named after the directory the session ran in, and anything deeper there is a
+// session's own scratch rather than this workspace's history.
+const STORE_DEPTH = { claudeProjects: 1, codexSessions: 3, opencodeSessions: 2 };
 
 // --- Claude ------------------------------------------------------------------------------------------------------------------------------
 
@@ -42,7 +50,7 @@ export function claudeProjectKey(containerPath) {
  * 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 transcripts = filesNewestFirst(stores.claudeProjects, CLAUDE_TRANSCRIPT, STORE_DEPTH.claudeProjects);
     const byRecordedDir = firstResumable(transcripts, cwd);
     if (byRecordedDir !== null) return byRecordedDir;
     const key = claudeProjectKey(cwd);
@@ -113,10 +121,11 @@ function transcriptFacts(transcriptPath) {
 //
 // 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.
+// conversation is really resumable would tie chamba to two more internal layouts for no gain. codex is asked
+// with the pattern that also matches a compressed rollout, because a cold history is still a history.
 export const CONTINUE = {
     opencode: { argv: ["opencode", "--continue"], store: "opencodeSessions", pattern: /\.json$/ },
-    codex: { argv: ["codex", "resume", "--last"], store: "codexSessions", pattern: CODEX_ROLLOUT },
+    codex: { argv: ["codex", "resume", "--last"], store: "codexSessions", pattern: CODEX_ANY_ROLLOUT },
 };
 
 // --- The one entry point -----------------------------------------------------------------------------------------------------------------
@@ -136,7 +145,7 @@ export function resumeArgvFor(agent, cwd, stores) {
         }
         const known = CONTINUE[agent];
         if (!known) return null;
-        return filesNewestFirst(stores[known.store], known.pattern).length > 0 ? [...known.argv] : null;
+        return hasAnyFile(stores[known.store], known.pattern, STORE_DEPTH[known.store]) ? [...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.