@tumnel/codex 0.1.3 → 0.1.5

package/README.md

@@ -10,13 +10,13 @@ with the same experience as the OpenCode connector: sessions, streaming turns, t
 The standard setup command prepares the host identity and starts the connector:
 
 ```sh
-npx @tumnel/codex@0.1.3 install
+npx @tumnel/codex@0.1.5 install
 ```
 
 `connect` remains available as an explicit alias:
 
 ```sh
-npx @tumnel/codex@0.1.3 connect
+npx @tumnel/codex@0.1.5 connect
 ```
 
 The connector starts the Codex agent bridge and keeps it connected to the Tumnel relay until
@@ -26,6 +26,9 @@ interrupted:
 npx @tumnel/codex --model gpt-5-mini --sandbox workspace-write --approval-policy on-request
 ```
 
+If `--model` (or `CODEX_MODEL`) is omitted, the web model picker still exposes a
+`Codex default` option and the SDK resolves the model from the local Codex configuration.
+
 It binds a pairing-only endpoint to `127.0.0.1:43817` (use `--port` to override). It accepts
 approved OpenBridge origins, returns short-lived signed proofs, and never exposes Codex API keys
 or model credentials over localhost.
@@ -58,8 +61,10 @@ Legacy Codex identities are migrated automatically when no shared or OpenCode id
 - A turn (`session.prompt`) runs `thread.runStreamed(input, { signal })`; every thread event is
   relayed as a `session.status` / `message.updated` / `message.part.updated` / `session.idle`
   bridge event, and the observed messages are served back through `session.messages`.
-- Threads are discovered from `~/.codex/sessions/**/rollout-*.jsonl`, so sessions started in the
-  Codex CLI or app appear in the web UI and can be resumed.
+- Projects and threads are discovered from the Codex desktop catalog (`~/.codex/.codex-global-state.json`
+  and `~/.codex/session_index.jsonl`) plus the persisted rollout files under
+  `~/.codex/sessions/**/rollout-*.jsonl`. This keeps project names/order and session titles aligned
+  with the local Codex app while still allowing older rollouts to be reconstructed and resumed.
 
 ## Known limitations
 

package/dist/cli.js

@@ -10,7 +10,7 @@ import { z as z2 } from "zod";
 import { createHash, randomBytes } from "crypto";
 import { createReadStream } from "fs";
 import { homedir } from "os";
-import { join } from "path";
+import { dirname, join } from "path";
 import { readFile, readdir, stat } from "fs/promises";
 import { z } from "zod";
 var sessionMetaSchema = z.object({
@@ -24,8 +24,10 @@ var sessionMetaSchema = z.object({
   }).passthrough()
 });
 function defaultSessionsDir(environment = process.env) {
-  const root = environment.CODEX_HOME ?? join(homedir(), ".codex");
-  return join(root, "sessions");
+  return join(defaultCodexHome(environment), "sessions");
+}
+function defaultCodexHome(environment = process.env) {
+  return environment.CODEX_HOME ?? join(homedir(), ".codex");
 }
 function projectId(directory) {
   const hash = createHash("sha256").update(directory.toLowerCase()).digest("base64url").slice(0, 12);
@@ -80,6 +82,87 @@ async function readRolloutTitle(path, fallback) {
   }
   return title;
 }
+async function readSessionIndex(path) {
+  const result = /* @__PURE__ */ new Map();
+  let source;
+  try {
+    source = await readFile(path, "utf8");
+  } catch {
+    return result;
+  }
+  for (const line of source.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try {
+      const value = JSON.parse(line);
+      const id = stringValue(value.id);
+      if (!id) continue;
+      result.set(id, {
+        thread_name: stringValue(value.thread_name) ?? void 0,
+        updated_at: stringValue(value.updated_at) ?? void 0
+      });
+    } catch {
+    }
+  }
+  return result;
+}
+async function readGlobalProjects(path) {
+  let source;
+  try {
+    source = await readFile(path, "utf8");
+  } catch {
+    return [];
+  }
+  try {
+    const root = asRecord(JSON.parse(source));
+    const projects = asRecord(root?.["local-projects"]);
+    const order = Array.isArray(root?.["project-order"]) ? root?.["project-order"].filter((value) => typeof value === "string") : [];
+    const orderById = new Map(order.map((id, index) => [id, index]));
+    const result = [];
+    for (const [id, value] of Object.entries(projects ?? {})) {
+      const project = asRecord(value);
+      const name = stringValue(project?.name) ?? void 0;
+      const roots = Array.isArray(project?.rootPaths) ? project.rootPaths.filter((path2) => typeof path2 === "string" && path2.length > 0) : [];
+      if (!roots.length) continue;
+      const created = timestampValue(project?.createdAt, 0);
+      const updated = timestampValue(project?.updatedAt, created);
+      for (const directory of roots) {
+        result.push({
+          id,
+          name,
+          directory,
+          created,
+          updated,
+          order: orderById.get(id) ?? Number.MAX_SAFE_INTEGER
+        });
+      }
+    }
+    return result.sort((left, right) => left.order - right.order || left.created - right.created);
+  } catch {
+    return [];
+  }
+}
+async function readGlobalSessionAssignments(path) {
+  let source;
+  try {
+    source = await readFile(path, "utf8");
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+  try {
+    const root = asRecord(JSON.parse(source));
+    const assignments = asRecord(root?.["thread-project-assignments"]);
+    const result = /* @__PURE__ */ new Map();
+    for (const [threadId, value] of Object.entries(assignments ?? {})) {
+      const assignment = asRecord(value);
+      const projectId2 = stringValue(assignment?.projectId);
+      const projectKind = stringValue(assignment?.projectKind);
+      if (projectId2 && (!projectKind || projectKind === "local")) result.set(threadId, projectId2);
+    }
+    return result;
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+}
 async function walkRollouts(dir) {
   let entries;
   try {
@@ -289,8 +372,9 @@ async function readRolloutHistory(path, sessionId) {
   }
   return { messages, title, updated };
 }
-async function discoverSessions(sessionsDir) {
+async function discoverSessions(sessionsDir, sessionIndexPath = join(dirname(sessionsDir), "session_index.jsonl"), projectRootsById = /* @__PURE__ */ new Map(), projectAssignments = /* @__PURE__ */ new Map()) {
   const rollouts = await walkRollouts(sessionsDir);
+  const index = await readSessionIndex(sessionIndexPath);
   const sessions = [];
   for (const path of rollouts) {
     const line = await readFirstLine(path);
@@ -305,7 +389,11 @@ async function discoverSessions(sessionsDir) {
     if (!result.success) continue;
     const meta = result.data.payload;
     const id = meta.session_id ?? meta.id;
-    if (!id || !meta.cwd) continue;
+    if (!id) continue;
+    const workingDirectory = meta.cwd;
+    const assignedProjectId = projectAssignments.get(id);
+    const directory = (assignedProjectId ? projectRootsById.get(assignedProjectId) : void 0) ?? workingDirectory;
+    if (!directory) continue;
     const created = meta.timestamp ? Date.parse(meta.timestamp) : NaN;
     let mtime = created;
     try {
@@ -314,13 +402,16 @@ async function discoverSessions(sessionsDir) {
     } catch {
       mtime = Number.isFinite(created) ? created : 0;
     }
+    const indexed = index.get(id);
+    const indexedUpdated = indexed?.updated_at ? Date.parse(indexed.updated_at) : NaN;
     sessions.push({
       id,
-      directory: meta.cwd,
+      directory,
+      ...workingDirectory && workingDirectory !== directory ? { workingDirectory } : {},
       version: meta.cli_version ?? "unknown",
       created: Number.isFinite(created) ? created : mtime,
-      updated: mtime,
-      title: await readRolloutTitle(path, "(untitled session)"),
+      updated: Number.isFinite(indexedUpdated) ? Math.max(mtime, indexedUpdated) : mtime,
+      title: await readRolloutTitle(path, indexed?.thread_name ?? "(untitled session)"),
       rolloutPath: path
     });
   }
@@ -336,12 +427,19 @@ var CodexSessionStore = class {
     at: 0,
     byDirectory: /* @__PURE__ */ new Map()
   };
+  projectCache = {
+    at: 0,
+    projects: [],
+    rootsById: /* @__PURE__ */ new Map(),
+    assignments: /* @__PURE__ */ new Map()
+  };
   create(input) {
     const now = Date.now();
     const record = {
       id: input.id,
       projectID: projectId(input.directory),
       directory: input.directory,
+      workingDirectory: input.workingDirectory,
       title: input.title ?? "(untitled session)",
       version: input.version,
       created: now,
@@ -377,7 +475,13 @@ var CodexSessionStore = class {
   async refreshDiscovery() {
     const now = Date.now();
     if (this.discoveryCache.at !== 0 && now - this.discoveryCache.at <= 3e4) return;
-    const discovered = await discoverSessions(this.sessionsDir);
+    await this.refreshProjectCatalog(now);
+    const discovered = await discoverSessions(
+      this.sessionsDir,
+      join(dirname(this.sessionsDir), "session_index.jsonl"),
+      this.projectCache.rootsById,
+      this.projectCache.assignments
+    );
     const byDirectory = /* @__PURE__ */ new Map();
     for (const session of discovered) {
       const list = byDirectory.get(session.directory) ?? [];
@@ -391,6 +495,24 @@ var CodexSessionStore = class {
     await this.refreshDiscovery();
     return directory ? [...this.discoveryCache.byDirectory.entries()].filter(([dir]) => samePath(dir, directory)).flatMap(([, sessions]) => sessions) : [...this.discoveryCache.byDirectory.values()].flat();
   }
+  async discoverProjects(directory) {
+    const now = Date.now();
+    await this.refreshProjectCatalog(now);
+    return directory ? this.projectCache.projects.filter((project) => samePath(project.directory, directory)) : [...this.projectCache.projects];
+  }
+  async refreshProjectCatalog(now = Date.now()) {
+    if (this.projectCache.at !== 0 && now - this.projectCache.at <= 3e4) return;
+    const globalStatePath = join(dirname(this.sessionsDir), ".codex-global-state.json");
+    const projects = await readGlobalProjects(globalStatePath);
+    const rootsById = /* @__PURE__ */ new Map();
+    for (const project of projects) {
+      if (!rootsById.has(project.id)) rootsById.set(project.id, project.directory);
+    }
+    this.projectCache.projects = projects;
+    this.projectCache.rootsById = rootsById;
+    this.projectCache.assignments = await readGlobalSessionAssignments(globalStatePath);
+    this.projectCache.at = now;
+  }
   async discover(directory) {
     const matching = await this.discoverAll(directory);
     const liveThreadIds = new Set(
@@ -538,6 +660,11 @@ var questionRejectSchema = z2.object({
   requestId: z2.string().min(1).max(256),
   directory: directorySchema
 }).strict();
+var CODEX_DEFAULT_MODEL_ID = "__codex_default__";
+var CODEX_DEFAULT_MODEL_NAME = "Codex default";
+function normalizeModelId(model) {
+  return model === CODEX_DEFAULT_MODEL_ID ? void 0 : model;
+}
 var EventBus = class {
   queue = [];
   wake = null;
@@ -760,13 +887,14 @@ function ensureThread(codex, record, config, model) {
   const selectedModel = model ?? record.model ?? config.model;
   if (record.thread && record.model === selectedModel) return record.thread;
   record.model = selectedModel;
+  const workingDirectory = record.workingDirectory ?? record.directory;
   if (record.codexThreadId) {
     record.thread = codex.resumeThread(
       record.codexThreadId,
-      threadOptions(config, record.directory, selectedModel)
+      threadOptions(config, workingDirectory, selectedModel)
     );
   } else {
-    record.thread = codex.startThread(threadOptions(config, record.directory, selectedModel));
+    record.thread = codex.startThread(threadOptions(config, workingDirectory, selectedModel));
   }
   return record.thread;
 }
@@ -876,25 +1004,42 @@ function createCodexAdapter(options) {
         case "project.list": {
           const params = projectListSchema.parse(rawParams);
           const directory = params.directory || void 0;
+          const catalogProjects = await sessions.discoverProjects(directory);
           const records = sessions.list(directory);
           const discovered = await sessions.discoverAll(directory);
           const directories = /* @__PURE__ */ new Map();
+          for (const project of catalogProjects) {
+            directories.set(project.directory, {
+              created: project.created,
+              name: project.name,
+              order: project.order
+            });
+          }
           for (const record of records) {
             const existing = directories.get(record.directory);
-            if (existing === void 0 || record.created < existing) {
-              directories.set(record.directory, record.created);
+            if (existing === void 0 || record.created < existing.created) {
+              directories.set(record.directory, {
+                created: record.created,
+                name: existing?.name,
+                order: existing?.order ?? Number.MAX_SAFE_INTEGER
+              });
             }
           }
           for (const session of discovered) {
             const existing = directories.get(session.directory);
-            if (existing === void 0 || session.created < existing) {
-              directories.set(session.directory, session.created);
+            if (existing === void 0 || session.created < existing.created) {
+              directories.set(session.directory, {
+                created: session.created,
+                name: existing?.name,
+                order: existing?.order ?? Number.MAX_SAFE_INTEGER
+              });
             }
           }
-          return [...directories.entries()].map(([worktree, created]) => ({
+          return [...directories.entries()].sort(([, left], [, right]) => left.order - right.order || left.created - right.created).map(([worktree, project]) => ({
             id: projectId(worktree),
+            ...project.name ? { name: project.name } : {},
             worktree,
-            time: { created }
+            time: { created: project.created }
           }));
         }
         case "session.list": {
@@ -953,7 +1098,7 @@ function createCodexAdapter(options) {
         }
         case "session.prompt": {
           const params = sessionPromptSchema.parse(rawParams);
-          const selectedModel = params.model ? params.model.providerID === "codex" ? params.model.modelID : (() => {
+          const selectedModel = params.model ? params.model.providerID === "codex" ? normalizeModelId(params.model.modelID) : (() => {
             throw new Error(`Codex does not support provider ${params.model?.providerID}`);
           })() : void 0;
           let record = sessions.get(params.sessionId);
@@ -965,6 +1110,7 @@ function createCodexAdapter(options) {
             record = sessions.create({
               id: params.sessionId,
               directory: session.directory,
+              workingDirectory: session.workingDirectory,
               title: history?.title ?? session.title,
               version: session.version,
               codexThreadId: session.id,
@@ -987,17 +1133,18 @@ function createCodexAdapter(options) {
         }
         case "provider.list": {
           providerListSchema.parse(rawParams);
-          if (!config.model) return toSafeJson({ default: {}, providers: [] });
+          const modelID = config.model ?? CODEX_DEFAULT_MODEL_ID;
+          const modelName = config.model ?? CODEX_DEFAULT_MODEL_NAME;
           return toSafeJson({
-            default: { codex: config.model },
+            default: { codex: modelID },
             providers: [
               {
                 id: "codex",
                 name: "Codex",
                 models: [
                   {
-                    id: config.model,
-                    name: config.model,
+                    id: modelID,
+                    name: modelName,
                     attachment: false,
                     reasoning: true,
                     toolCall: true,
@@ -1247,7 +1394,7 @@ import {
   verify
 } from "crypto";
 import { homedir as homedir2 } from "os";
-import { dirname, join as join2 } from "path";
+import { dirname as dirname2, join as join2 } from "path";
 import { mkdir, open, readFile as readFile2 } from "fs/promises";
 import { z as z4 } from "zod";
 var DEVICE_PROOF_PREFIX = "tumnel-device-proof-v1";
@@ -1307,7 +1454,7 @@ async function readIdentity(path) {
   return validateKeyPair(identitySchema.parse(JSON.parse(contents)));
 }
 async function persistNewIdentity(path, identity) {
-  await mkdir(dirname(path), { recursive: true, mode: 448 });
+  await mkdir(dirname2(path), { recursive: true, mode: 448 });
   const handle = await open(path, "wx", 384);
   try {
     await handle.writeFile(`${JSON.stringify(identity, null, 2)}