codiedev 0.9.26 → 0.9.28

package/dist/utils.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DIRECT_UPLOAD_THRESHOLD_CHARS = exports.SWEEP_MIN_AGE_MS = exports.CAPTURE_THROTTLE_MS = exports.FINISH_ORPHAN_AGE_MS = exports.CLAIM_STALE_MS = exports.UPLOAD_TTL_MS = exports.MAX_UPLOAD_ATTEMPTS = void 0;
+exports.DIRECT_UPLOAD_THRESHOLD_CHARS = exports.SWEEP_MIN_AGE_MS = exports.CAPTURE_THROTTLE_MS = exports.FINISH_ORPHAN_AGE_MS = exports.CLAIM_STALE_MS = exports.UPLOAD_TTL_MS = exports.MAX_UPLOAD_ATTEMPTS = exports.CONFIG_PATH = exports.codiedevStateDir = void 0;
 exports.readConfig = readConfig;
 exports.writeConfig = writeConfig;
 exports.writeConfigAtPath = writeConfigAtPath;
@@ -58,6 +58,8 @@ exports.resetStableNodeCacheForTests = resetStableNodeCacheForTests;
 exports.claudeCodeInstalled = claudeCodeInstalled;
 exports.codexInstalled = codexInstalled;
 exports.cursorInstalled = cursorInstalled;
+exports.openCodeInstalled = openCodeInstalled;
+exports.installOpenCodeCapturePlugin = installOpenCodeCapturePlugin;
 exports.vscodeCopilotInstalled = vscodeCopilotInstalled;
 exports.upsertCodiedevHook = upsertCodiedevHook;
 exports.installHook = installHook;
@@ -85,6 +87,7 @@ exports.parseSteering = parseSteering;
 exports.parseUsage = parseUsage;
 exports.parseSessionStart = parseSessionStart;
 exports.parseClaudeCodeStats = parseClaudeCodeStats;
+exports.normalizeOpenCodeTranscript = normalizeOpenCodeTranscript;
 exports.parseCodexStats = parseCodexStats;
 exports.extractCodexRepoUrl = extractCodexRepoUrl;
 exports.dispatchCaptureFinish = dispatchCaptureFinish;
@@ -109,13 +112,15 @@ const os = __importStar(require("os"));
 const child_process_1 = require("child_process");
 const detection_1 = require("./detection");
 const captureLog_1 = require("./captureLog");
-const CONFIG_DIR = path.join(os.homedir(), ".codiedev");
-const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+const configDir_1 = require("./configDir");
+Object.defineProperty(exports, "codiedevStateDir", { enumerable: true, get: function () { return configDir_1.codiedevStateDir; } });
+const CONFIG_DIR = (0, configDir_1.codiedevStateDir)();
+exports.CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
 function readConfig() {
     try {
-        if (!fs.existsSync(CONFIG_PATH))
+        if (!fs.existsSync(exports.CONFIG_PATH))
             return null;
-        const raw = fs.readFileSync(CONFIG_PATH, "utf8");
+        const raw = fs.readFileSync(exports.CONFIG_PATH, "utf8");
         return JSON.parse(raw);
     }
     catch {
@@ -123,7 +128,7 @@ function readConfig() {
     }
 }
 function writeConfig(config) {
-    writeConfigAtPath(config, CONFIG_DIR, CONFIG_PATH);
+    writeConfigAtPath(config, CONFIG_DIR, exports.CONFIG_PATH);
 }
 /** Exported for permission-focused tests; normal callers use writeConfig. */
 function writeConfigAtPath(config, configDir, configPath) {
@@ -695,12 +700,15 @@ function buildCapturePayload(input) {
         inputTokens: input.inputTokens,
         outputTokens: input.outputTokens,
         cacheTokens: input.cacheTokens,
+        cacheReadTokens: input.cacheReadTokens,
+        cacheCreationTokens: input.cacheCreationTokens,
         model: input.model ?? undefined,
         sessionStartedAt: input.sessionStartedAt ?? undefined,
         interruptCount: input.interruptCount,
         rejectionCount: input.rejectionCount,
         // final is only emitted when explicitly set (not for Codex/Cursor).
         final: input.final,
+        costUsd: input.costUsd,
     };
 }
 function hashToken(token) {
@@ -717,6 +725,9 @@ const CLAUDE_DIR = path.join(os.homedir(), ".claude");
 const CODEX_HOOKS_PATH = path.join(os.homedir(), ".codex", "hooks.json");
 const CODEX_DIR = path.join(os.homedir(), ".codex");
 const CURSOR_DIR = path.join(os.homedir(), ".cursor");
+const OPENCODE_DIR = path.join(os.homedir(), ".config", "opencode");
+const OPENCODE_PLUGIN_DIR = path.join(OPENCODE_DIR, "plugins");
+const OPENCODE_PLUGIN_PATH = path.join(OPENCODE_PLUGIN_DIR, "codiedev.js");
 const CURSOR_HOOKS_PATH = path.join(CURSOR_DIR, "hooks.json");
 const CURSOR_MCP_PATH = path.join(CURSOR_DIR, "mcp.json");
 const CURSOR_RULES_DIR = path.join(CURSOR_DIR, "rules");
@@ -832,7 +843,7 @@ function resolveHookNodePath(preferredNodePath) {
     //    still an absolute path a GUI-launched agent can execute without PATH.
     return process.execPath;
 }
-function resolveHookCommand(subcommand, preferredNodePath) {
+function resolveHookInvocation(subcommand, preferredNodePath) {
     try {
         const cliEntry = process.argv[1];
         if (cliEntry) {
@@ -841,14 +852,22 @@ function resolveHookCommand(subcommand, preferredNodePath) {
             const hookScript = path.join(distDir, "hook.js");
             if (fs.existsSync(hookScript)) {
                 const nodePath = resolveHookNodePath(preferredNodePath);
-                return `${shellQuote(nodePath)} ${shellQuote(hookScript)} ${subcommand}`;
+                return { command: nodePath, args: [hookScript, subcommand] };
             }
         }
     }
     catch {
         // Fall through to npx fallback.
     }
-    return `npx codiedev-hook ${subcommand}`;
+    return {
+        command: process.platform === "win32" ? "npx.cmd" : "npx",
+        args: ["codiedev-hook", subcommand],
+    };
+}
+function resolveHookCommand(subcommand, preferredNodePath) {
+    const invocation = resolveHookInvocation(subcommand, preferredNodePath);
+    const argsBeforeSubcommand = invocation.args.slice(0, -1).map(shellQuote);
+    return [shellQuote(invocation.command), ...argsBeforeSubcommand, subcommand].join(" ");
 }
 // `isCodiedevHookCommand` is defined in `./detection` so it's testable
 // without mocking fs/path. Re-imported below; do not re-define here.
@@ -873,6 +892,95 @@ function codexInstalled() {
 function cursorInstalled() {
     return fs.existsSync(CURSOR_DIR);
 }
+function openCodeInstalled() {
+    if (fs.existsSync(OPENCODE_DIR))
+        return true;
+    try {
+        (0, child_process_1.execSync)("command -v opencode", { stdio: ["pipe", "pipe", "pipe"] });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Install a dormant global OpenCode adapter. Installing it unconditionally
+ * keeps `codiedev connect` as the only setup step even when Codie/OpenCode is
+ * installed later. OpenCode loads this file from its documented plugin dir. */
+function installOpenCodeCapturePlugin() {
+    const start = resolveHookInvocation("session-start-opencode");
+    const capture = resolveHookInvocation("capture-opencode");
+    const finish = resolveHookInvocation("capture-opencode-final");
+    const source = `// Managed by codiedev connect. Safe to remove and reinstall.\n` +
+        `import { spawn, spawnSync } from "node:child_process";\n` +
+        `import { mkdir, writeFile } from "node:fs/promises";\n` +
+        `import os from "node:os";\n` +
+        `import path from "node:path";\n\n` +
+        `const START = ${JSON.stringify(start)};\n` +
+        `const CAPTURE = ${JSON.stringify(capture)};\n` +
+        `const FINISH = ${JSON.stringify(finish)};\n` +
+        `const fingerprints = new Map();\n\n` +
+        `const transcriptPaths = new Map();\n\n` +
+        `function sessionId(event) {\n` +
+        `  return event?.properties?.sessionID ?? event?.properties?.sessionId ?? event?.properties?.info?.id ?? null;\n` +
+        `}\n\n` +
+        `function dispatch(invocation, payload) {\n` +
+        `  try {\n` +
+        `    const child = spawn(invocation.command, invocation.args, { detached: true, stdio: ["pipe", "ignore", "ignore"] });\n` +
+        `    child.stdin.end(JSON.stringify(payload));\n` +
+        `    child.unref();\n` +
+        `  } catch {}\n` +
+        `}\n\n` +
+        `function dispatchSync(invocation, payload) {\n` +
+        `  try { spawnSync(invocation.command, invocation.args, { input: JSON.stringify(payload), stdio: ["pipe", "ignore", "ignore"], timeout: 1500 }); } catch {}\n` +
+        `}\n\n` +
+        `export const CodiedevCapture = async ({ client, directory, worktree }) => {\n` +
+        `  const finalizeAll = () => {\n` +
+        `    for (const [id, transcriptPath] of transcriptPaths) {\n` +
+        `      const cwd = worktree || directory || process.cwd();\n` +
+        `      dispatchSync(FINISH, { session_id: id, transcript_path: transcriptPath, cwd, workspace_roots: [cwd] });\n` +
+        `    }\n` +
+        `  };\n` +
+        `  process.once("exit", finalizeAll);\n` +
+        `  return ({\n` +
+        `  event: async ({ event }) => {\n` +
+        `    const id = sessionId(event);\n` +
+        `    if (!id) return;\n` +
+        `    const cwd = worktree || directory || process.cwd();\n` +
+        `    if (event.type === "session.created") {\n` +
+        `      dispatch(START, { session_id: id, cwd, workspace_roots: [cwd] });\n` +
+        `      return;\n` +
+        `    }\n` +
+        `    if (event.type === "session.deleted") {\n` +
+        `      const transcriptPath = transcriptPaths.get(id);\n` +
+        `      if (transcriptPath) dispatch(FINISH, { session_id: id, transcript_path: transcriptPath, cwd, workspace_roots: [cwd] });\n` +
+        `      transcriptPaths.delete(id);\n` +
+        `      fingerprints.delete(id);\n` +
+        `      return;\n` +
+        `    }\n` +
+        `    if (event.type !== "session.idle") return;\n` +
+        `    try {\n` +
+        `      const response = await client.session.messages({ path: { id } });\n` +
+        `      const messages = response?.data ?? response ?? [];\n` +
+        `      const list = Array.isArray(messages) ? messages : [];\n` +
+        `      const last = list.at(-1);\n` +
+        `      const fingerprint = String(list.length) + ":" + String(last?.info?.id ?? last?.info?.time?.completed ?? "");\n` +
+        `      if (fingerprints.get(id) === fingerprint) return;\n` +
+        `      fingerprints.set(id, fingerprint);\n` +
+        `      const captureDir = path.join(os.homedir(), ".codiedev", "opencode-captures");\n` +
+        `      await mkdir(captureDir, { recursive: true, mode: 0o700 });\n` +
+        `      const safeId = String(id).replace(/[^a-zA-Z0-9._-]/g, "_");\n` +
+        `      const transcriptPath = path.join(captureDir, safeId + ".json");\n` +
+        `      await writeFile(transcriptPath, JSON.stringify(list), { mode: 0o600 });\n` +
+        `      transcriptPaths.set(id, transcriptPath);\n` +
+        `      dispatch(CAPTURE, { session_id: id, transcript_path: transcriptPath, cwd, workspace_roots: [cwd] });\n` +
+        `    } catch {}\n` +
+        `  },\n` +
+        `  });\n` +
+        `};\n`;
+    fs.mkdirSync(OPENCODE_PLUGIN_DIR, { recursive: true, mode: 0o700 });
+    fs.writeFileSync(OPENCODE_PLUGIN_PATH, source, { encoding: "utf8", mode: 0o600 });
+    fs.chmodSync(OPENCODE_PLUGIN_PATH, 0o600);
+}
 /**
  * VS Code with the GitHub Copilot Chat extension installed. The extension
  * directory pattern is `~/.vscode/extensions/github.copilot-chat-*`. We treat
@@ -1643,7 +1751,8 @@ function parseClaudeUsage(content) {
     // already fresh (cache read/creation are reported separately).
     let inputTokens = 0;
     let outputTokens = 0;
-    let cacheTokens = 0;
+    let cacheReadTokens = 0;
+    let cacheCreationTokens = 0;
     let model = null;
     for (const line of content.split("\n")) {
         if (!line.trim())
@@ -1655,7 +1764,8 @@ function parseClaudeUsage(content) {
             if (u) {
                 inputTokens += u.input_tokens ?? 0;
                 outputTokens += u.output_tokens ?? 0;
-                cacheTokens += (u.cache_creation_input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0);
+                cacheReadTokens += u.cache_read_input_tokens ?? 0;
+                cacheCreationTokens += u.cache_creation_input_tokens ?? 0;
             }
             if (typeof m?.model === "string" && m.model)
                 model = m.model;
@@ -1664,7 +1774,14 @@ function parseClaudeUsage(content) {
             // skip malformed
         }
     }
-    return { inputTokens, outputTokens, cacheTokens, model };
+    return {
+        inputTokens,
+        outputTokens,
+        cacheTokens: cacheReadTokens + cacheCreationTokens,
+        cacheReadTokens,
+        cacheCreationTokens,
+        model,
+    };
 }
 function parseCodexUsage(content) {
     // Codex reports a CUMULATIVE token_count per turn — the last one is the
@@ -1689,18 +1806,87 @@ function parseCodexUsage(content) {
             // skip malformed
         }
     }
-    if (!last)
-        return { inputTokens: 0, outputTokens: 0, cacheTokens: 0, model };
+    if (!last) {
+        return { inputTokens: 0, outputTokens: 0, cacheTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0, model };
+    }
     const cached = last.cached_input_tokens ?? 0;
     const input = last.input_tokens ?? 0;
     return {
         inputTokens: Math.max(0, input - cached),
         outputTokens: (last.output_tokens ?? 0) + (last.reasoning_output_tokens ?? 0),
+        // Codex only reports cached reads; creation is structurally zero.
         cacheTokens: cached,
+        cacheReadTokens: cached,
+        cacheCreationTokens: 0,
         model,
     };
 }
+// opencode SDK transcripts (the plugin's client.session.messages dump) are a
+// single JSON ARRAY of {info, parts} — not Claude Code's JSONL. Sum assistant
+// token/cost metadata; model = providerID/modelID (matches modelPricing slugs
+// like "openrouter/…" never resolving — stored cost is authoritative here).
+function parseOpencodeUsage(content) {
+    let inputTokens = 0, outputTokens = 0, cacheReadTokens = 0, cacheCreationTokens = 0, costUsd = 0;
+    // A session can switch models (user picks another, or a provider falls back).
+    // Attribute it to the model that did the most work rather than whichever
+    // spoke last, since this label drives pricing and the model-mix card.
+    const outputByModel = new Map();
+    let lastModel = null;
+    try {
+        const parsed = JSON.parse(content);
+        // Accept both shapes the SDK can produce: a bare array, or the
+        // {data: [...]} envelope normalizeOpenCodeTranscript already unwraps.
+        // Disagreeing with that parser would silently zero out a session's usage.
+        const list = Array.isArray(parsed)
+            ? parsed
+            : (parsed && typeof parsed === "object" && Array.isArray(parsed.data)
+                ? parsed.data
+                : null);
+        if (Array.isArray(list)) {
+            for (const msg of list) {
+                const info = msg?.info;
+                if (!info || info.role !== "assistant")
+                    continue;
+                const t = info.tokens;
+                if (t) {
+                    inputTokens += t.input ?? 0;
+                    outputTokens += t.output ?? 0;
+                    cacheReadTokens += t.cache?.read ?? 0;
+                    cacheCreationTokens += t.cache?.write ?? 0;
+                }
+                if (typeof info.cost === "number" && Number.isFinite(info.cost) && info.cost > 0) {
+                    costUsd += info.cost;
+                }
+                if (typeof info.modelID === "string" && info.modelID) {
+                    const id = typeof info.providerID === "string" && info.providerID
+                        ? `${info.providerID}/${info.modelID}` : info.modelID;
+                    lastModel = id;
+                    outputByModel.set(id, (outputByModel.get(id) ?? 0) + (t?.output ?? 0));
+                }
+            }
+        }
+    }
+    catch { /* malformed transcript — zero-safe */ }
+    // Ties (e.g. every turn reporting zero output) fall back to the last model
+    // seen, preserving the previous behaviour for single-model sessions.
+    let model = lastModel;
+    let best = -1;
+    for (const [id, out] of outputByModel) {
+        // >= so the later model wins a tie, matching the previous last-wins
+        // behaviour when no turn reports output tokens.
+        if (out >= best) {
+            best = out;
+            model = id;
+        }
+    }
+    return { inputTokens, outputTokens,
+        cacheTokens: cacheReadTokens + cacheCreationTokens,
+        cacheReadTokens, cacheCreationTokens, model,
+        costUsd: costUsd > 0 ? costUsd : undefined };
+}
 function parseUsage(content, mode) {
+    if (mode === "desktop")
+        return parseOpencodeUsage(content);
     return mode === "codex" ? parseCodexUsage(content) : parseClaudeUsage(content);
 }
 // Lead-time start proxy: the earliest top-level `timestamp` in the transcript.
@@ -1751,6 +1937,81 @@ function parseClaudeCodeStats(content) {
     }
     return { messageCount, toolCallCount };
 }
+/** Convert OpenCode's SDK message array (`{info, parts}[]`) into the same
+ * newline-delimited shape used by Claude Code. The rest of capture—privacy
+ * exclusions, git keys, token parsing, scrubbing, storage, and merge joins—can
+ * therefore stay one shared pipeline instead of becoming a parallel product. */
+function normalizeOpenCodeTranscript(content) {
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        return content;
+    }
+    const candidate = parsed && typeof parsed === "object" && "data" in parsed
+        ? parsed.data
+        : parsed;
+    if (!Array.isArray(candidate))
+        return content;
+    const lines = [];
+    for (const item of candidate) {
+        if (!item || typeof item !== "object")
+            continue;
+        const record = item;
+        const info = record.info && typeof record.info === "object" ? record.info : {};
+        const role = info.role === "user" ? "user" : "assistant";
+        const parts = Array.isArray(record.parts) ? record.parts : [];
+        const normalizedParts = [];
+        for (const part of parts) {
+            if (!part || typeof part !== "object")
+                continue;
+            if (part.type === "text" && typeof part.text === "string") {
+                normalizedParts.push({ type: "text", text: part.text });
+            }
+            else if (part.type === "reasoning" && typeof part.text === "string") {
+                normalizedParts.push({ type: "thinking", thinking: part.text });
+            }
+            else if (part.type === "tool") {
+                normalizedParts.push({
+                    type: "tool_use",
+                    id: part.callID ?? part.id ?? "tool",
+                    name: part.tool ?? "tool",
+                    input: part.state?.input ?? {},
+                });
+                if (part.state?.output != null || part.state?.error != null) {
+                    normalizedParts.push({
+                        type: "tool_result",
+                        tool_use_id: part.callID ?? part.id ?? "tool",
+                        content: part.state?.output ?? part.state?.error,
+                        is_error: part.state?.status === "error" || part.state?.error != null,
+                    });
+                }
+            }
+        }
+        const tokens = info.tokens && typeof info.tokens === "object" ? info.tokens : {};
+        const created = Number(info.time?.created);
+        const timestamp = Number.isFinite(created)
+            ? new Date(created).toISOString()
+            : new Date(0).toISOString();
+        lines.push(JSON.stringify({
+            type: role,
+            timestamp,
+            message: {
+                role,
+                model: typeof info.modelID === "string" ? info.modelID : undefined,
+                usage: role === "assistant" ? {
+                    input_tokens: Number(tokens.input) || 0,
+                    output_tokens: (Number(tokens.output) || 0) + (Number(tokens.reasoning) || 0),
+                    cache_creation_input_tokens: Number(tokens.cache?.write) || 0,
+                    cache_read_input_tokens: Number(tokens.cache?.read) || 0,
+                } : undefined,
+                content: normalizedParts,
+            },
+        }));
+    }
+    return lines.join("\n") + (lines.length ? "\n" : "");
+}
 // Codex session JSONL format (rollout-*.jsonl):
 //   {type:"session_meta", payload:{id, cwd, git:{repository_url,...}, ...}}
 //   {type:"response_item", payload:{type:"message", role, content:[{type:"input_text",text}|{type:"output_text",text}]}}
@@ -2052,13 +2313,20 @@ exports.CAPTURE_THROTTLE_MS = 10 * 60 * 1000;
 exports.SWEEP_MIN_AGE_MS = exports.CAPTURE_THROTTLE_MS + 2 * 60 * 1000;
 // Map the hook's capture argv to the payload's `final` flag. EXPLICIT
 // ALLOWLIST: only claude-code's SessionEnd entrypoints ("capture", or the bare
-// hook with no subcommand) are a true final signal. Everything else —
-// capture-codex (Codex's Stop fires per-turn; final:true would close the
-// server-side session lease every turn), capture-cursor, and any FUTURE mode
-// (e.g. a capture-windsurf added to resolveMode but not audited here) — gets
-// undefined, i.e. legacy server behaviour. Defaulting unknowns to true would
-// silently re-introduce the per-turn lease-close bug for every new agent.
+// hook with no subcommand) are a true final signal. capture-opencode/
+// capture-desktop (per-turn snapshot) and capture-opencode-final/
+// capture-desktop-final (real session end) get an explicit false/true.
+// Everything else — capture-codex (Codex's Stop fires per-turn; final:true
+// would close the server-side session lease every turn), capture-cursor, and
+// any FUTURE mode (e.g. a capture-windsurf added to resolveMode but not
+// audited here) — gets undefined, i.e. legacy server behaviour. Defaulting
+// unknowns to true would silently re-introduce the per-turn lease-close bug
+// for every new agent.
 function resolveCaptureFinal(argv2) {
+    if (argv2 === "capture-opencode" || argv2 === "capture-desktop")
+        return false;
+    if (argv2 === "capture-opencode-final" || argv2 === "capture-desktop-final")
+        return true;
     return argv2 === "capture" || argv2 === undefined ? true : undefined;
 }
 // Build a UNIQUE finish-input tmpFile name per dispatch. Both the Stop hook and

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "codiedev",
-  "version": "0.9.26",
-  "description": "Connect Claude Code, Codex, Cursor, or VS Code Copilot to Codiedev for org-wide session capture and artifact collaboration",
+  "version": "0.9.28",
+  "description": "Connect Claude Code, Codex, Cursor, OpenCode, or VS Code Copilot to Codiedev for team session capture and artifact collaboration — and run the governed Codie harness",
   "bin": {
     "codiedev": "dist/cli.js",
-    "codiedev-hook": "dist/hook.js"
+    "codiedev-hook": "dist/hook.js",
+    "codie": "dist/codie.js"
   },
   "scripts": {
     "build": "tsc",
@@ -15,6 +16,7 @@
   },
   "files": [
     "dist",
+    "assets",
     "README.md"
   ],
   "keywords": [
@@ -24,6 +26,7 @@
     "codex",
     "openai",
     "cursor",
+    "opencode",
     "copilot",
     "github-copilot",
     "vscode",
@@ -42,9 +45,14 @@
   "devDependencies": {
     "@types/node": "^20.0.0",
     "typescript": "^5.4.0",
-    "vitest": "^3.2.4"
+    "vitest": "^3.2.6"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.29.0"
+    "@modelcontextprotocol/sdk": "^1.30.0"
+  },
+  "overrides": {
+    "@hono/node-server": "^2.0.12",
+    "ip-address": "^10.4.0",
+    "esbuild": "^0.28.1"
   }
 }