0rrery 0.1.0 → 0.1.2

package/index.js

@@ -1,4 +1,6 @@
-#!/usr/bin/env bun
+#!/bin/sh
+':' //; command -v bun >/dev/null 2>&1 || { echo "0rrery runs on Bun (>= 1.1), and bun was not found on your PATH." >&2; echo "Install it from https://bun.sh then re-run this command." >&2; exit 1; }
+':' //; exec bun "$0" "$@"
 // @bun
 var __defProp = Object.defineProperty;
 var __returnValue = (v) => v;
@@ -16,9 +18,9 @@ var __export = (target, all) => {
 };
 
 // packages/cli/src/index.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7, openSync as openSync2, readSync as readSync2, closeSync as closeSync2 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join8, resolve as resolve2 } from "path";
+import { join as join9, resolve as resolve2 } from "path";
 
 // packages/server/src/server.ts
 import { appendFileSync, mkdirSync } from "fs";
@@ -4009,7 +4011,7 @@ var ts = exports_external.number().int().nonnegative();
 var SessionStartSchema = exports_external.object({
   op: exports_external.literal("session.start"),
   sessionId: exports_external.string().min(1),
-  source: exports_external.enum(["claude-code", "api"]),
+  source: exports_external.enum(["claude-code", "api", "codex"]),
   project: exports_external.string().optional(),
   cwd: exports_external.string().optional(),
   gitBranch: exports_external.string().optional(),
@@ -4291,7 +4293,15 @@ function spendSeries(db, f) {
     FROM spans sp JOIN sessions se ON se.id = sp.session_id
     WHERE ${where}
     GROUP BY day, model, project ORDER BY day, model`).all(...params);
-  return rows.map((r) => ({ ...r, est_cost: estCost(r.model, r.tokens_in, r.tokens_out) }));
+  return rows.map((r) => ({
+    day: r.day,
+    model: r.model,
+    project: r.project,
+    tokens_in: r.tokens_in,
+    tokens_out: r.tokens_out,
+    calls: r.calls,
+    est_cost: estCost(r.model, r.tokens_in, r.tokens_out)
+  }));
 }
 function toolHealth(db, f) {
   const { where, params } = spanWhere(f, "sp.kind IN ('tool', 'mcp')");
@@ -4350,10 +4360,11 @@ function searchSessions(db, f, opts) {
   const conds = ["1 = 1"];
   const params = [];
   if (f.q) {
-    conds.push(`(project LIKE '%' || ? || '%' OR EXISTS(
+    const q = f.q.replaceAll(/[%_\\]/g, (m) => "\\" + m);
+    conds.push(`(project LIKE '%' || ? || '%' ESCAPE '\\' OR EXISTS(
       SELECT 1 FROM events ev WHERE ev.session_id = sessions.id
-        AND ev.type = 'message.user' AND json_extract(ev.attrs, '$.preview') LIKE '%' || ? || '%'))`);
-    params.push(f.q, f.q);
+        AND ev.type = 'message.user' AND json_extract(ev.attrs, '$.preview') LIKE '%' || ? || '%' ESCAPE '\\'))`);
+    params.push(q, q);
   }
   if (f.project) {
     conds.push("project = ?");
@@ -4498,7 +4509,7 @@ function sessionSummary(db, id) {
       SUM(COALESCE(json_extract(attrs, '$.input_tokens'), 0)) tin,
       SUM(COALESCE(json_extract(attrs, '$.output_tokens'), 0)) tout
     FROM spans WHERE session_id = ? AND kind = 'llm'
-    GROUP BY name ORDER BY calls DESC, model`).all(id);
+    GROUP BY name ORDER BY calls DESC, model LIMIT 20`).all(id);
   const top_tools = db.query(`SELECT name, kind, COUNT(*) calls, SUM(status = 'error') errors
     FROM spans WHERE session_id = ? AND kind IN ('tool', 'mcp')
     GROUP BY name, kind ORDER BY calls DESC LIMIT 10`).all(id);
@@ -4625,7 +4636,7 @@ class LiveBus {
 // packages/server/src/server.ts
 var json = (data, status = 200) => new Response(JSON.stringify(data), { status, headers: { "Content-Type": "application/json" } });
 var numParam = (raw) => {
-  if (raw === null)
+  if (raw === null || raw === "")
     return;
   const n = Number(raw);
   return Number.isInteger(n) && n >= 0 ? n : undefined;
@@ -4685,9 +4696,9 @@ function startServer(config) {
           const bad = (name) => json({ error: `invalid ${name}` }, 400);
           const rawFrom = url.searchParams.get("from"), rawTo = url.searchParams.get("to");
           const from = numParam(rawFrom), to = numParam(rawTo);
-          if (rawFrom !== null && from === undefined)
+          if (rawFrom !== null && rawFrom !== "" && from === undefined)
             return bad("from");
-          if (rawTo !== null && to === undefined)
+          if (rawTo !== null && rawTo !== "" && to === undefined)
             return bad("to");
           const f = { project: url.searchParams.get("project") ?? undefined, from, to };
           switch (insightsMatch[1]) {
@@ -4708,9 +4719,9 @@ function startServer(config) {
         if (path === "/api/sessions" && req.method === "GET") {
           const rawFrom = url.searchParams.get("from"), rawTo = url.searchParams.get("to");
           const from = numParam(rawFrom), to = numParam(rawTo);
-          if (rawFrom !== null && from === undefined)
+          if (rawFrom !== null && rawFrom !== "" && from === undefined)
             return json({ error: "invalid from" }, 400);
-          if (rawTo !== null && to === undefined)
+          if (rawTo !== null && rawTo !== "" && to === undefined)
             return json({ error: "invalid to" }, 400);
           const q = url.searchParams.get("q") ?? undefined;
           const project = url.searchParams.get("project") ?? undefined;
@@ -5008,7 +5019,8 @@ function parseTranscriptLine(raw, state) {
 // packages/claude-code/src/importer.ts
 import { openSync, readSync, fstatSync, closeSync, readdirSync } from "fs";
 import { join as join3, dirname, basename } from "path";
-async function importTranscript(path, url, fromByte = 0, state = newTranscriptState(), finalize = false) {
+var claudeParser = { parse: parseTranscriptLine };
+async function importTranscript(path, url, fromByte = 0, state = newTranscriptState(), finalize = false, parser = claudeParser) {
   const fd = openSync(path, "r");
   let text;
   try {
@@ -5027,19 +5039,24 @@ async function importTranscript(path, url, fromByte = 0, state = newTranscriptSt
     return { ops: 0, emitted: true, bytesRead: fromByte };
   const complete = text.slice(0, lastNewline);
   const consumedBytes = Buffer.byteLength(text.slice(0, lastNewline + 1));
-  const snapshot = { ...state, agentToolUseIds: new Set(state.agentToolUseIds) };
+  const snapshot = { ...state };
+  for (const k of Object.keys(snapshot))
+    if (snapshot[k] instanceof Set)
+      snapshot[k] = new Set(snapshot[k]);
   const ops = complete.split(`
-`).filter(Boolean).flatMap((l) => parseTranscriptLine(l, state));
+`).filter(Boolean).flatMap((l) => parser.parse(l, state));
   if (ops.length > 0) {
     const maxTs = ops.reduce((max, o) => o.ts > max ? o.ts : max, 0);
-    if (state.agentId) {
+    if ("agentId" in state && state.agentId && ops.length) {
       ops.push({ op: "span.end", id: `agent:${state.agentId}`, ts: maxTs, status: "ok" });
     }
-    if (finalize && !state.agentId) {
+    if (finalize && !(("agentId" in state) && state.agentId)) {
       const sessionId = ops.find((o) => ("sessionId" in o))?.sessionId;
       if (sessionId)
         ops.push({ op: "session.end", sessionId, ts: maxTs });
     }
+    if (finalize && parser.finalize)
+      ops.push(...parser.finalize(state, maxTs));
   }
   const emitted = await emitOps(url, ops, 5000);
   if (!emitted) {
@@ -5049,23 +5066,27 @@ async function importTranscript(path, url, fromByte = 0, state = newTranscriptSt
   return { ops: ops.length, emitted, bytesRead: fromByte + consumedBytes };
 }
 async function importSession(path, url, opts = {}) {
+  const newState = opts.newState ?? newTranscriptState;
+  const parser = opts.parser ?? claudeParser;
   let files = 0, ops = 0, emitted = true;
-  const main = await importTranscript(path, url, 0, newTranscriptState(), opts.finalize ?? false);
+  const main = await importTranscript(path, url, 0, newState(), opts.finalize ?? false, parser);
   files++;
   ops += main.ops;
   emitted = emitted && main.emitted;
   if (!main.emitted)
     return { files, ops, emitted: false };
-  const subDir = join3(dirname(path), basename(path, ".jsonl"), "subagents");
-  let subs = [];
-  try {
-    subs = readdirSync(subDir).filter((f) => f.endsWith(".jsonl"));
-  } catch {}
-  for (const f of subs) {
-    const r = await importTranscript(join3(subDir, f), url, 0, newTranscriptState());
-    files++;
-    ops += r.ops;
-    emitted = emitted && r.emitted;
+  if (opts.parser === undefined) {
+    const subDir = join3(dirname(path), basename(path, ".jsonl"), "subagents");
+    let subs = [];
+    try {
+      subs = readdirSync(subDir).filter((f) => f.endsWith(".jsonl"));
+    } catch {}
+    for (const f of subs) {
+      const r = await importTranscript(join3(subDir, f), url, 0, newTranscriptState());
+      files++;
+      ops += r.ops;
+      emitted = emitted && r.emitted;
+    }
   }
   return { files, ops, emitted };
 }
@@ -5090,7 +5111,7 @@ function reviveState(json2) {
     agentToolUseIds: Array.isArray(j.agentToolUseIds) ? new Set(j.agentToolUseIds.filter((x) => typeof x === "string")) : fresh.agentToolUseIds
   };
 }
-function loadOffsets(path) {
+function loadOffsets(path, revive) {
   const out = new Map;
   let raw;
   try {
@@ -5106,7 +5127,7 @@ function loadOffsets(path) {
       if (!existsSync2(file))
         continue;
       const offset = Number.isInteger(entry?.offset) && entry.offset >= 0 ? entry.offset : 0;
-      out.set(file, { offset, state: reviveState(entry?.state) });
+      out.set(file, { offset, state: revive(entry?.state) });
     }
   } catch (e) {
     console.error("0rrery: tailer offsets snapshot corrupt, starting fresh", e);
@@ -5118,7 +5139,11 @@ function saveOffsets(path, files) {
   try {
     const filesJson = {};
     for (const [file, { offset, state }] of files) {
-      filesJson[file] = { offset, state: { ...state, agentToolUseIds: [...state.agentToolUseIds] } };
+      const serialized = { ...state };
+      for (const k of Object.keys(serialized))
+        if (serialized[k] instanceof Set)
+          serialized[k] = [...serialized[k]];
+      filesJson[file] = { offset, state: serialized };
     }
     writeFileSync(path + ".tmp", JSON.stringify({ version: VERSION, files: filesJson }));
     renameSync(path + ".tmp", path);
@@ -5129,7 +5154,7 @@ function saveOffsets(path, files) {
 
 // packages/claude-code/src/tailer.ts
 function startTailer(projectsDir, url, pollMs = 2000, offsetsPath) {
-  const files = offsetsPath ? loadOffsets(offsetsPath) : new Map;
+  const files = offsetsPath ? loadOffsets(offsetsPath, reviveState) : new Map;
   let stopped = false;
   let dirty = false;
   async function scanFile(path) {
@@ -5200,14 +5225,246 @@ function startTailer(projectsDir, url, pollMs = 2000, offsetsPath) {
     stopped = true;
   } };
 }
+// packages/codex/src/codex.ts
+function newCodexState() {
+  return { sessionId: null, project: null, model: null, openTurnId: null, turnIn: 0, turnOut: 0, threadId: null };
+}
+function reviveCodexState(json2) {
+  const fresh = newCodexState();
+  if (typeof json2 !== "object" || json2 === null)
+    return fresh;
+  const j = json2;
+  const str = (v) => typeof v === "string" ? v : null;
+  const num = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+  if (j.sessionId !== null && typeof j.sessionId !== "string")
+    return fresh;
+  return {
+    sessionId: str(j.sessionId),
+    project: str(j.project),
+    model: str(j.model),
+    openTurnId: str(j.openTurnId),
+    turnIn: num(j.turnIn),
+    turnOut: num(j.turnOut),
+    threadId: str(j.threadId)
+  };
+}
+function idSalt(state) {
+  return state.threadId !== null && state.threadId !== state.sessionId ? `:${state.threadId}` : "";
+}
+var preview = (s) => s.slice(0, 200);
+function messageText(content) {
+  if (!Array.isArray(content))
+    return "";
+  return content.map((c) => c?.text ?? "").join("").trim();
+}
+function parseCodexLine(raw, state) {
+  let line;
+  try {
+    line = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (typeof line !== "object" || line === null)
+    return [];
+  const parsed = Date.parse(line.timestamp);
+  const ts2 = Number.isNaN(parsed) ? Date.now() : parsed;
+  const p = line.payload;
+  if (typeof p !== "object" || p === null)
+    return [];
+  if (line.type === "session_meta") {
+    state.sessionId = typeof p.session_id === "string" ? p.session_id : typeof p.id === "string" ? p.id : null;
+    if (!state.sessionId)
+      return [];
+    state.threadId = typeof p.id === "string" ? p.id : state.sessionId;
+    state.project = typeof p.cwd === "string" ? p.cwd.split("/").pop() ?? null : null;
+    state.model = typeof p.model_provider === "string" ? p.model_provider : null;
+    return [{
+      op: "session.start",
+      sessionId: state.sessionId,
+      source: "codex",
+      ts: ts2,
+      project: state.project ?? undefined,
+      cwd: typeof p.cwd === "string" ? p.cwd : undefined,
+      meta: { model_provider: p.model_provider, cli_version: p.cli_version, originator: p.originator }
+    }];
+  }
+  const sid = state.sessionId;
+  if (!sid)
+    return [];
+  const ops = [];
+  const closeTurn = (endTs) => {
+    if (!state.openTurnId)
+      return;
+    ops.push({ op: "span.end", id: `llm:${state.openTurnId}`, ts: endTs, status: "ok" });
+    state.openTurnId = null;
+    state.turnIn = 0;
+    state.turnOut = 0;
+  };
+  if (line.type === "turn_context") {
+    closeTurn(ts2);
+    const turnId = typeof p.turn_id === "string" ? p.turn_id : null;
+    if (typeof p.model === "string")
+      state.model = p.model;
+    if (turnId) {
+      state.openTurnId = turnId;
+      ops.push({
+        op: "span.start",
+        id: `llm:${turnId}`,
+        sessionId: sid,
+        parentId: null,
+        kind: "llm",
+        name: state.model ?? "(model)",
+        ts: ts2,
+        attrs: {}
+      });
+      ops.push({ op: "event", id: `evt:turn:${turnId}`, sessionId: sid, type: "turn.context", ts: ts2, attrs: {} });
+    }
+    return ops;
+  }
+  if (line.type === "event_msg") {
+    if (p.type === "task_complete") {
+      closeTurn(ts2);
+      ops.push({ op: "event", id: `evt:stop:${sid}${idSalt(state)}:${ts2}`, sessionId: sid, type: "turn.stop", ts: ts2, attrs: {} });
+      return ops;
+    }
+    if (p.type === "token_count" && p.info && typeof p.info === "object" && state.openTurnId) {
+      const u = p.info.last_token_usage;
+      if (u && typeof u === "object") {
+        state.turnIn += u.input_tokens ?? 0;
+        state.turnOut += u.output_tokens ?? 0;
+        ops.push({
+          op: "span.start",
+          id: `llm:${state.openTurnId}`,
+          sessionId: sid,
+          parentId: null,
+          kind: "llm",
+          name: state.model ?? "(model)",
+          ts: ts2,
+          attrs: { input_tokens: state.turnIn, output_tokens: state.turnOut }
+        });
+      }
+      return ops;
+    }
+    return [];
+  }
+  if (line.type === "response_item") {
+    if (p.type === "function_call" && typeof p.call_id === "string") {
+      let input = p.arguments;
+      try {
+        input = JSON.parse(p.arguments);
+      } catch {}
+      const name = typeof p.name === "string" ? p.name : "(tool)";
+      return [{
+        op: "span.start",
+        id: `tool:${p.call_id}`,
+        sessionId: sid,
+        parentId: state.openTurnId ? `llm:${state.openTurnId}` : null,
+        kind: isMcpTool(name) ? "mcp" : "tool",
+        name,
+        ts: ts2,
+        attrs: { input }
+      }];
+    }
+    if (p.type === "function_call_output" && typeof p.call_id === "string") {
+      const out = typeof p.output === "string" ? p.output : "";
+      const status = /exited with code [1-9]/.test(out) ? "error" : "ok";
+      return [{ op: "span.end", id: `tool:${p.call_id}`, ts: ts2, status, attrs: {} }];
+    }
+    if (p.type === "web_search_call" && typeof p.id === "string") {
+      return [
+        {
+          op: "span.start",
+          id: `tool:${p.id}`,
+          sessionId: sid,
+          parentId: state.openTurnId ? `llm:${state.openTurnId}` : null,
+          kind: "tool",
+          name: "web_search",
+          ts: ts2,
+          attrs: { input: { query: p.action?.query ?? "" } }
+        },
+        { op: "span.end", id: `tool:${p.id}`, ts: ts2, status: "ok", attrs: {} }
+      ];
+    }
+    if (p.type === "message" && (p.role === "user" || p.role === "assistant")) {
+      const text = messageText(p.content);
+      if (!text)
+        return [];
+      return [{
+        op: "event",
+        id: `evt:msg:${sid}${idSalt(state)}:${ts2}:${p.role}`,
+        sessionId: sid,
+        type: p.role === "user" ? "message.user" : "message.assistant",
+        ts: ts2,
+        attrs: { preview: preview(text) }
+      }];
+    }
+    return [];
+  }
+  return [];
+}
+var codexParser = {
+  parse: parseCodexLine,
+  finalize: (state, maxTs) => state.openTurnId ? [{ op: "span.end", id: `llm:${state.openTurnId}`, ts: maxTs, status: "ok" }] : []
+};
+// packages/codex/src/tailer.ts
+import { readdirSync as readdirSync3, statSync as statSync2 } from "fs";
+import { join as join5 } from "path";
+function startCodexTailer(rootDir, url, pollMs = 2000, offsetsPath) {
+  const files = offsetsPath ? loadOffsets(offsetsPath, reviveCodexState) : new Map;
+  let stopped = false;
+  const pass = async () => {
+    let dirty = false;
+    let entries = [];
+    try {
+      entries = readdirSync3(rootDir, { recursive: true }).filter((e) => e.endsWith(".jsonl"));
+    } catch {
+      return;
+    }
+    for (const rel of entries) {
+      const path = join5(rootDir, String(rel));
+      try {
+        let fs = files.get(path);
+        if (!fs) {
+          fs = { offset: 0, state: newCodexState() };
+          files.set(path, fs);
+        }
+        const size = statSync2(path).size;
+        if (size < fs.offset) {
+          fs.offset = 0;
+          fs.state = newCodexState();
+          dirty = true;
+        }
+        if (size > fs.offset) {
+          const r = await importTranscript(path, url, fs.offset, fs.state, false, codexParser);
+          if (r.bytesRead !== fs.offset) {
+            fs.offset = r.bytesRead;
+            dirty = true;
+          }
+        }
+      } catch {}
+    }
+    if (dirty && offsetsPath)
+      saveOffsets(offsetsPath, files);
+  };
+  const loop = async () => {
+    while (!stopped) {
+      await pass();
+      await Bun.sleep(pollMs);
+    }
+  };
+  loop();
+  return { stop() {
+    stopped = true;
+  } };
+}
 // packages/cli/src/install.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 var HOOK_EVENTS = ["SessionStart", "SessionEnd", "PreToolUse", "PostToolUse", "Notification", "Stop", "SubagentStop", "PermissionRequest", "PermissionDenied"];
 var NEEDS_MATCHER = new Set(["PreToolUse", "PostToolUse"]);
 function installHooks(claudeDir, hookCommand) {
   mkdirSync2(claudeDir, { recursive: true });
-  const settingsPath = join5(claudeDir, "settings.json");
+  const settingsPath = join6(claudeDir, "settings.json");
   let settings = {};
   if (existsSync3(settingsPath)) {
     try {
@@ -5239,34 +5496,58 @@ function installHooks(claudeDir, hookCommand) {
 }
 
 // packages/cli/src/sweep.ts
-async function importAll(projectsDir, url) {
-  const files = Array.from(new Bun.Glob("*/*.jsonl").scanSync({ cwd: projectsDir, absolute: true })).sort();
+import { existsSync as existsSync4 } from "fs";
+async function importOne(path, url, opts, label) {
+  try {
+    const r = await importSession(path, url, opts);
+    if (r.emitted) {
+      console.log(`  ${label}: ${r.ops} ops`);
+      return "ok";
+    }
+    console.error(`  ${label}: server unreachable at ${url} \u2014 aborting sweep`);
+    return "unreachable";
+  } catch (err) {
+    console.error(`  ${label}: ${err instanceof Error ? err.message : String(err)}`);
+    return "failed";
+  }
+}
+async function importAll(projectsDir, url, codexRoot) {
+  const claudeFiles = existsSync4(projectsDir) ? Array.from(new Bun.Glob("*/*.jsonl").scanSync({ cwd: projectsDir, absolute: true })).sort() : [];
   let ok = 0;
   let failed = 0;
-  for (const f of files) {
+  let aborted = false;
+  for (const f of claudeFiles) {
     const name = f.split("/").slice(-2).join("/");
-    try {
-      const r = await importSession(f, url, { finalize: true });
-      if (r.emitted) {
-        ok++;
-        console.log(`  ${name}: ${r.ops} ops`);
-      } else {
-        failed++;
-        console.error(`  ${name}: server unreachable at ${url} \u2014 aborting sweep`);
+    const result = await importOne(f, url, { finalize: true }, name);
+    if (result === "ok") {
+      ok++;
+    } else {
+      failed++;
+      if (result === "unreachable") {
+        aborted = true;
         break;
       }
-    } catch (err) {
+    }
+  }
+  const codexFiles = !aborted && codexRoot && existsSync4(codexRoot) ? Array.from(new Bun.Glob("**/*.jsonl").scanSync({ cwd: codexRoot, absolute: true })).sort() : [];
+  for (const f of codexFiles) {
+    const name = f.split("/").slice(-2).join("/");
+    const result = await importOne(f, url, { finalize: true, parser: codexParser, newState: newCodexState }, name);
+    if (result === "ok") {
+      ok++;
+    } else {
       failed++;
-      console.error(`  ${name}: ${err instanceof Error ? err.message : String(err)}`);
+      if (result === "unreachable")
+        break;
     }
   }
-  return { ok, failed, total: files.length };
+  return { ok, failed, total: claudeFiles.length + codexFiles.length };
 }
 
 // packages/cli/src/service.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, realpathSync, rmSync, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, realpathSync, rmSync, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir2 } from "os";
-import { dirname as dirname2, join as join6 } from "path";
+import { dirname as dirname2, join as join7 } from "path";
 function systemdUnit(execStart) {
   return `[Unit]
 Description=0rrery - trace-first observability for AI agent workflows
@@ -5300,9 +5581,9 @@ ${items}
 }
 function servicePath(platform = process.platform) {
   if (platform === "linux")
-    return join6(homedir2(), ".config/systemd/user/0rrery.service");
+    return join7(homedir2(), ".config/systemd/user/0rrery.service");
   if (platform === "darwin")
-    return join6(homedir2(), "Library/LaunchAgents/com.0pon.0rrery.plist");
+    return join7(homedir2(), "Library/LaunchAgents/com.0pon.0rrery.plist");
   return null;
 }
 function resolveBin() {
@@ -5322,7 +5603,7 @@ function runService(sub, platform = process.platform, exec = run, file = service
   const linux = platform === "linux";
   if (sub === "install") {
     const bin = resolveBin();
-    if (!linux && existsSync4(file))
+    if (!linux && existsSync5(file))
       exec(["launchctl", "unload", "-w", file]);
     mkdirSync3(dirname2(file), { recursive: true });
     writeFileSync3(file, linux ? systemdUnit([...bin, "serve"].join(" ")) : launchdPlist([...bin, "serve"]));
@@ -5331,11 +5612,12 @@ function runService(sub, platform = process.platform, exec = run, file = service
     return ok;
   }
   if (sub === "uninstall") {
-    if (!existsSync4(file)) {
+    const existed = existsSync5(file);
+    const ok = linux ? exec(["systemctl", "--user", "disable", "--now", "0rrery"]) : exec(["launchctl", "unload", "-w", file]);
+    if (!existed) {
       console.log("no service installed");
       return true;
     }
-    const ok = linux ? exec(["systemctl", "--user", "disable", "--now", "0rrery"]) : exec(["launchctl", "unload", "-w", file]);
     rmSync(file, { force: true });
     if (linux)
       exec(["systemctl", "--user", "daemon-reload"]);
@@ -5343,21 +5625,23 @@ function runService(sub, platform = process.platform, exec = run, file = service
     return ok;
   }
   if (sub === "status") {
-    return linux ? exec(["systemctl", "--user", "status", "0rrery", "--no-pager"]) : exec(["launchctl", "list", "com.0pon.0rrery"]);
+    const ok = linux ? exec(["systemctl", "--user", "status", "0rrery", "--no-pager"]) : exec(["launchctl", "list", "com.0pon.0rrery"]);
+    console.log(`dashboard: http://localhost:${process.env.ORRERY_PORT ?? 7317}`);
+    return ok;
   }
   console.error("usage: 0rrery service <install|uninstall|status>");
   return false;
 }
 
 // packages/cli/src/skill.ts
-import { cpSync, existsSync as existsSync5, mkdirSync as mkdirSync4 } from "fs";
-import { join as join7 } from "path";
+import { cpSync, existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
+import { join as join8 } from "path";
 function skillSourceDir() {
-  const candidates = [join7(import.meta.dir, "skill"), join7(import.meta.dir, "../skill")];
-  return candidates.find(existsSync5) ?? null;
+  const candidates = [join8(import.meta.dir, "skill"), join8(import.meta.dir, "../skill")];
+  return candidates.find(existsSync6) ?? null;
 }
 function installSkill(claudeDir, srcDir) {
-  const dest = join7(claudeDir, "skills", "0rrery");
+  const dest = join8(claudeDir, "skills", "0rrery");
   mkdirSync4(dest, { recursive: true });
   cpSync(srcDir, dest, { recursive: true });
   return dest;
@@ -5366,9 +5650,20 @@ function installSkill(claudeDir, srcDir) {
 // packages/cli/src/index.ts
 var [cmd, arg] = process.argv.slice(2);
 var url = process.env.ORRERY_URL ?? "http://localhost:7317";
-var claudeDir = () => process.env.ORRERY_CLAUDE_DIR ?? join8(homedir3(), ".claude");
+var claudeDir = () => process.env.ORRERY_CLAUDE_DIR ?? join9(homedir3(), ".claude");
+var codexDir = () => process.env.ORRERY_CODEX_DIR ?? join9(homedir3(), ".codex", "sessions");
+function sniffHead(path) {
+  const fd = openSync2(path, "r");
+  try {
+    const buf = Buffer.alloc(400);
+    const n = readSync2(fd, buf, 0, buf.length, 0);
+    return buf.subarray(0, n).toString("utf8");
+  } finally {
+    closeSync2(fd);
+  }
+}
 function runInstall() {
-  if (!existsSync6(claudeDir())) {
+  if (!existsSync7(claudeDir())) {
     console.warn(`${claudeDir()} not found \u2014 Claude Code not present, skipping hooks`);
     return false;
   }
@@ -5385,12 +5680,16 @@ switch (cmd) {
   case "serve": {
     const config = loadConfig();
     const srv = startServer(config);
-    const projectsDir = join8(claudeDir(), "projects");
-    const tailer = startTailer(projectsDir, srv.url, 2000, join8(config.dataDir, "tailer-offsets.json"));
+    const projectsDir = join9(claudeDir(), "projects");
+    const tailer = startTailer(projectsDir, srv.url, 2000, join9(config.dataDir, "tailer-offsets.json"));
+    const cx = existsSync7(codexDir()) ? startCodexTailer(codexDir(), srv.url, 2000, join9(config.dataDir, "codex-offsets.json")) : null;
     console.log(`0rrery serving on ${srv.url} (db: ${config.dbPath})`);
     console.log(`tailing ${projectsDir}`);
+    if (cx)
+      console.log(`tailing ${codexDir()} (codex)`);
     process.on("SIGINT", () => {
       tailer.stop();
+      cx?.stop();
       srv.stop();
       process.exit(0);
     });
@@ -5419,15 +5718,18 @@ switch (cmd) {
       process.exit(1);
     }
     if (arg === "--all") {
-      const projectsDir = join8(claudeDir(), "projects");
-      const r2 = await importAll(projectsDir, url);
+      const projectsDir = join9(claudeDir(), "projects");
+      const cxRoot = existsSync7(codexDir()) ? codexDir() : undefined;
+      const r2 = await importAll(projectsDir, url, cxRoot);
       console.log(r2.total ? `imported ${r2.ok}/${r2.total} transcript(s)` : `no transcripts found under ${projectsDir}`);
       process.exit(r2.failed && !r2.ok ? 1 : 0);
       break;
     }
     let r;
     try {
-      r = await importSession(resolve2(arg), url, { finalize: true });
+      const path = resolve2(arg);
+      const isCodex = /"type"\s*:\s*"session_meta"/.test(sniffHead(path));
+      r = isCodex ? await importSession(path, url, { finalize: true, parser: codexParser, newState: newCodexState }) : await importSession(path, url, { finalize: true });
     } catch (err) {
       console.error(`0rrery import: cannot read ${arg}: ${err instanceof Error ? err.message : String(err)}`);
       process.exit(1);
@@ -5441,7 +5743,12 @@ switch (cmd) {
     break;
   }
   case "init": {
-    const flags = new Set(process.argv.slice(3));
+    const KNOWN_INIT_FLAGS = new Set(["--no-hooks", "--no-service", "--no-import", "--no-skill"]);
+    const argv = process.argv.slice(3);
+    const flags = new Set(argv);
+    for (const f of argv)
+      if (!KNOWN_INIT_FLAGS.has(f))
+        console.warn(`unknown flag: ${f}`);
     let failed = false;
     if (!flags.has("--no-hooks")) {
       console.log("\u203A hooks");
@@ -5455,7 +5762,7 @@ switch (cmd) {
     if (!flags.has("--no-skill")) {
       console.log("\u203A skill");
       const src = skillSourceDir();
-      if (!existsSync6(claudeDir()))
+      if (!existsSync7(claudeDir()))
         console.log(`  ${claudeDir()} not found \u2014 skipping skill`);
       else if (!src)
         console.log("  skill assets not found \u2014 skipping");
@@ -5469,14 +5776,15 @@ switch (cmd) {
     }
     if (!flags.has("--no-import")) {
       console.log("\u203A importing history");
-      const projectsDir = join8(claudeDir(), "projects");
-      if (existsSync6(projectsDir)) {
+      const projectsDir = join9(claudeDir(), "projects");
+      const cxRoot = existsSync7(codexDir()) ? codexDir() : undefined;
+      if (existsSync7(projectsDir) || cxRoot) {
         for (let i = 0;i < 30; i++) {
           if (await fetch(`${url}/api/sessions`).then((x) => x.ok).catch(() => false))
             break;
           await Bun.sleep(200);
         }
-        const r = await importAll(projectsDir, url);
+        const r = await importAll(projectsDir, url, cxRoot);
         console.log(r.total ? `  imported ${r.ok}/${r.total} transcript(s)` : "  no transcripts found");
       } else {
         console.log(`  ${projectsDir} not found \u2014 nothing to import`);