@tumnel/codex 0.1.2 → 0.1.4

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.2 install
+npx @tumnel/codex@0.1.4 install
 ```
 
 `connect` remains available as an explicit alias:
 
 ```sh
-npx @tumnel/codex@0.1.2 connect
+npx @tumnel/codex@0.1.4 connect
 ```
 
 The connector starts the Codex agent bridge and keeps it connected to the Tumnel relay until
@@ -58,8 +58,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(
@@ -760,13 +882,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 +999,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": {
@@ -965,6 +1105,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,
@@ -1247,7 +1388,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 +1448,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)}
@@ -1504,7 +1645,7 @@ var TumnelBridgeClient = class {
           version: BRIDGE_PROTOCOL_VERSION,
           type: "device.hello",
           clientId: this.identity.deviceId,
-          agentVersion: "0.1.1",
+          agentVersion: "0.1.3",
           connectorId: "codex"
         };
         socket.send(encodeBridgeMessage(hello));
@@ -1812,6 +1953,13 @@ async function createCodexConnector(options = {}) {
 }
 
 // src/cli.ts
+var waitForTumnelConnector = async (bridge, timeoutMs = 15e3) => {
+  const deadline = Date.now() + timeoutMs;
+  while (bridge.state !== "connected" && Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  return bridge.state === "connected";
+};
 var printHelp = () => {
   console.log(`Tumnel connector for Codex
 
@@ -1892,14 +2040,23 @@ var run = async () => {
   flag("--relay-url");
   flag("--sandbox");
   flag("--approval-policy");
-  if (command === "install") {
-    console.log("Tumnel Codex connector is installed and ready.");
-  }
+  const packageJson = JSON.parse(
+    await import("fs/promises").then(
+      ({ readFile: readFile3 }) => readFile3(new URL("../package.json", import.meta.url), "utf8")
+    )
+  );
+  if (command === "install") console.log(`Installed @tumnel/codex@${packageJson.version}`);
   const connector = await createCodexConnector({ config });
   const port = connector.pairingServer?.port;
-  console.log("Tumnel Codex connector started");
+  console.log("Starting Tumnel Codex connector...");
   console.log(`  Device ID:    ${connector.bridge.deviceId}`);
   if (port) console.log(`  Pairing port: http://127.0.0.1:${port}`);
+  console.log("Waiting for the Tumnel connector...");
+  if (await waitForTumnelConnector(connector.bridge)) {
+    console.log("Tumnel connected.");
+  } else {
+    console.log("Tumnel connector started; waiting for the relay in background.");
+  }
   console.log("Press Ctrl+C to stop.\n");
   let stopping = false;
   const stop = async () => {