codiedev 0.9.26 → 0.9.28

package/dist/configDir.js

@@ -0,0 +1,54 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codiedevStateDir = codiedevStateDir;
+// Single source of truth for where the CLI's config/state lives on disk.
+//
+// Defaults to ~/.codiedev. The desktop app sets CODIEDEV_CONFIG_DIR to
+// ~/.codiedev-desktop so a desktop session never touches the user's real
+// prod config — env-based (not a flag) so detached capture-finish/upload
+// children inherit the override automatically.
+//
+// Deliberately dependency-free (only node:path/os) so it can be imported
+// by both utils.ts and modules utils.ts itself imports (e.g. captureLog.ts)
+// without creating a circular import.
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const CONFIG_DIR = process.env.CODIEDEV_CONFIG_DIR?.trim()
+    ? path.resolve(process.env.CODIEDEV_CONFIG_DIR.trim())
+    : path.join(os.homedir(), ".codiedev");
+function codiedevStateDir() {
+    return CONFIG_DIR;
+}

package/dist/connect.js

@@ -270,9 +270,11 @@ async function runConnect(args = []) {
     const hasClaude = (0, utils_1.claudeCodeInstalled)();
     const hasCodex = (0, utils_1.codexInstalled)();
     const hasCursor = (0, utils_1.cursorInstalled)();
+    const hasOpenCode = (0, utils_1.openCodeInstalled)();
     (0, shared_1.recordInstallEvent)(config, { step: "detect", target: "claude-code", ok: hasClaude });
     (0, shared_1.recordInstallEvent)(config, { step: "detect", target: "codex", ok: hasCodex });
     (0, shared_1.recordInstallEvent)(config, { step: "detect", target: "cursor", ok: hasCursor });
+    (0, shared_1.recordInstallEvent)(config, { step: "detect", target: "opencode", ok: hasOpenCode });
     const installed = [];
     // Machine-readable target keys reported back to the backend via
     // /api/cli/markInstalled so the portal's "Connected" state reflects
@@ -311,6 +313,10 @@ async function runConnect(args = []) {
         runInstall("cursor-hook", utils_1.installCursorHook, "Cursor sessionEnd (capture + auto-backup) hooks (~/.cursor/hooks.json)", "cursor-hook");
         runInstall("cursor-instructions", utils_1.installCursorInstructions, "Cursor agent instructions (~/.cursor/rules/codiedev.mdc)", "cursor-instructions");
     }
+    // Always stage the adapter. It is dormant until OpenCode starts, which lets
+    // a user connect Claude Code today and install the Codie harness tomorrow
+    // without needing a second setup ritual.
+    runInstall("opencode-capture-adapter", utils_1.installOpenCodeCapturePlugin, "OpenCode session capture adapter (~/.config/opencode/plugins/codiedev.js)", "opencode-capture");
     // Tell the backend which targets we wired up so the portal's onboarding
     // card flips to "Connected" only when something actually installed —
     // not on bare token validation. Best-effort: a network failure here
@@ -333,8 +339,8 @@ async function runConnect(args = []) {
             });
         }
     }
-    if (!hasClaude && !hasCodex && !hasCursor) {
-        console.warn("\nNo Claude Code, Codex, or Cursor install detected.");
+    if (!hasClaude && !hasCodex && !hasCursor && !hasOpenCode) {
+        console.warn("\nNo existing AI client detected; the Codie/OpenCode adapter is ready for a later install.");
         console.warn("If you just installed Claude Code, launch it once (so ~/.claude is created),");
         console.warn("then re-run `npx codiedev connect` to wire up the capture hook.");
     }

package/dist/hook.js

@@ -46,36 +46,6 @@ const limitEvent_1 = require("./limitEvent");
 const version_1 = require("./version");
 const captureLog_1 = require("./captureLog");
 const captureExclusions_1 = require("./captureExclusions");
-function getJson(url, bearerToken) {
-    return new Promise((resolve, reject) => {
-        const parsed = new URL(url);
-        const options = {
-            hostname: parsed.hostname,
-            port: parsed.port || (parsed.protocol === "https:" ? 443 : 80),
-            path: parsed.pathname + parsed.search,
-            method: "GET",
-            headers: {
-                Authorization: `Bearer ${bearerToken}`,
-                "X-Codiedev-Cli-Version": version_1.CLI_VERSION,
-            },
-        };
-        const lib = parsed.protocol === "https:" ? https : http;
-        const req = lib.request(options, (res) => {
-            let body = "";
-            res.on("data", (c) => (body += c));
-            res.on("end", () => {
-                try {
-                    resolve(JSON.parse(body));
-                }
-                catch {
-                    reject(new Error("bad json"));
-                }
-            });
-        });
-        req.on("error", reject);
-        req.end();
-    });
-}
 // Pure builder for the discovery additionalContext. Returns null when there are
 // no matches. The suggested `codiedev pull` command carries the EXACT top key
 // (e.g. "pr-push.md") rather than a "<key>" placeholder — otherwise agents
@@ -106,7 +76,10 @@ async function runDiscover(prompt) {
     if (!config)
         process.exit(0);
     try {
-        const res = await getJson(`${config.backendUrl}/api/cli/skill-discovery?q=${encodeURIComponent(prompt)}`, config.token);
+        // POST body, never a query param: raw prompts in GET query strings land
+        // in server/proxy access logs (SIG-16). The server keeps accepting legacy
+        // GETs from older CLIs during the transition.
+        const res = await postJsonForResponse(`${config.backendUrl}/api/cli/skill-discovery`, { q: prompt }, config.token);
         const skills = res?.skills ?? [];
         const additionalContext = buildDiscoveryContext(skills);
         if (additionalContext) {
@@ -177,7 +150,7 @@ async function postSessionSkip(config, sessionId, reason) {
 // so the backend can later compute captured ÷ started. Deliberately tiny — no
 // transcript read, no git — so it never slows session startup. Best-effort +
 // silent (SessionStart hook output is ignored by Claude Code).
-async function runSessionStart(hookInput) {
+async function runSessionStart(hookInput, source = "claude-code") {
     const config = (0, utils_1.readConfig)();
     if (!config)
         process.exit(0);
@@ -186,7 +159,7 @@ async function runSessionStart(hookInput) {
             await postJson(`${config.backendUrl}/api/cli/sessionStart`, {
                 sessionId: hookInput.session_id,
                 startedAt: Date.now(),
-                source: "claude-code",
+                source,
             }, config.token, PING_TIMEOUT_MS);
         }
         catch {
@@ -340,6 +313,10 @@ function resolveMode(arg) {
         return "codex";
     if (arg === "capture-cursor")
         return "cursor";
+    if (arg === "capture-opencode" || arg === "capture-opencode-final")
+        return "opencode";
+    if (arg === "capture-desktop" || arg === "capture-desktop-final")
+        return "desktop";
     return "claude-code";
 }
 async function main() {
@@ -466,8 +443,8 @@ async function main() {
         return;
     }
     // SessionStart: post the capture-coverage denominator ping. Tiny + fast.
-    if (process.argv[2] === "session-start") {
-        await runSessionStart(hookInput);
+    if (process.argv[2] === "session-start" || process.argv[2] === "session-start-opencode") {
+        await runSessionStart(hookInput, process.argv[2] === "session-start-opencode" ? "opencode" : "claude-code");
         return;
     }
     // Self-heal: a user who upgraded the CLI but hasn't re-run `connect` gets
@@ -610,6 +587,11 @@ async function runCaptureFinish(input) {
 }
 async function runCaptureFinishInner(input, config, session_id, transcript_path, cwd, workspace_roots) {
     const mode = resolveMode(input.mode);
+    // Desktop transcripts (opencode SDK {info,parts}[] dumps) are byte-identical
+    // to opencode's, so every parser below EXCEPT parseUsage treats desktop
+    // exactly as opencode via this mapping. parseUsage is the one exception —
+    // see the rawTranscriptContent note below.
+    const parserMode = mode === "desktop" ? "opencode" : mode;
     const workspaceRoot = workspace_roots && workspace_roots.length > 0
         ? workspace_roots[0]
         : cwd || process.cwd();
@@ -632,10 +614,19 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
         await postSessionSkip(config, session_id, reason);
         return;
     }
+    // Snapshot the RAW transcript before normalization below flattens it to
+    // Claude Code's newline-JSONL shape — that flattening drops info.cost /
+    // info.providerID, which desktop's parseUsage (below) needs and opencode's
+    // doesn't. Every other mode leaves transcriptContent untouched here, so this
+    // is a no-op for them.
+    const rawTranscriptContent = transcriptContent;
+    if (parserMode === "opencode") {
+        transcriptContent = (0, utils_1.normalizeOpenCodeTranscript)(transcriptContent);
+    }
     // Resolve repo URL. Codex embeds it in session_meta; CC and Cursor both
     // need the git remote of the workspace.
     let remoteUrl = null;
-    if (mode === "codex") {
+    if (parserMode === "codex") {
         remoteUrl = (0, utils_1.extractCodexRepoUrl)(transcriptContent);
     }
     // The worktrees the session actually wrote to — resolved up front because
@@ -656,9 +647,9 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
     // Best-effort local match — backend re-resolves from `remoteUrl` against the
     // company's current repo list, so a stale/empty local cache doesn't matter.
     const matchedRepo = remoteUrl ? (0, utils_1.matchRepo)(remoteUrl, config.repos) : null;
-    const stats = mode === "codex"
+    const stats = parserMode === "codex"
         ? (0, utils_1.parseCodexStats)(transcriptContent)
-        : mode === "cursor"
+        : parserMode === "cursor"
             ? { messageCount: 0, toolCallCount: 0 }
             : (0, utils_1.parseClaudeCodeStats)(transcriptContent);
     const transcriptBase64 = Buffer.from(transcriptContent, "utf8").toString("base64");
@@ -688,10 +679,13 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
     const headShas = [...new Set([...keys.headShas, ...authoredShas])];
     const headSha = keys.headSha ?? headShas[0] ?? null;
     // Cost/velocity/steering signals parsed straight from the transcript we're
-    // already holding — no extra hooks, no extra git/process calls.
-    const usage = (0, utils_1.parseUsage)(transcriptContent, mode);
+    // already holding — no extra hooks, no extra git/process calls. parseUsage
+    // keeps the literal mode (it has its own desktop parser) and reads the RAW
+    // pre-normalization content for desktop; parseSteering routes through
+    // parserMode like the parsers above.
+    const usage = (0, utils_1.parseUsage)(mode === "desktop" ? rawTranscriptContent : transcriptContent, mode);
     const sessionStartedAt = (0, utils_1.parseSessionStart)(transcriptContent);
-    const steering = (0, utils_1.parseSteering)(transcriptContent, mode);
+    const steering = (0, utils_1.parseSteering)(transcriptContent, parserMode);
     const payload = (0, utils_1.buildCapturePayload)({
         sessionId: session_id,
         transcriptBase64,
@@ -709,6 +703,8 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
         inputTokens: usage.inputTokens,
         outputTokens: usage.outputTokens,
         cacheTokens: usage.cacheTokens,
+        cacheReadTokens: usage.cacheReadTokens,
+        cacheCreationTokens: usage.cacheCreationTokens,
         model: usage.model,
         sessionStartedAt,
         interruptCount: steering.interrupts,
@@ -716,6 +712,8 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
         // Carry the final flag into the HTTP body — the server uses it to decide
         // whether to close the session lease (true) or renew it (false/absent).
         final: input.final,
+        // Desktop-only measured spend (undefined for every other source).
+        costUsd: usage.costUsd,
     });
     // Throttle decision: final captures go immediately; non-final (per-turn Stop)
     // are deferred if we uploaded this session recently, to avoid per-turn churn.

package/dist/upgradeNudge.js

@@ -4,9 +4,10 @@
 // __tests__/versionCheck.test.ts; this module does the IO (registry fetch +
 // disk cache) and is exercised by manual smoke.
 //
-// Cache lives at ~/.codiedev/.update-cache.json. 24h TTL — long enough that
-// the registry isn't hit on every command, short enough that newly-published
-// versions surface the day after release.
+// Cache lives at <codiedevStateDir()>/.update-cache.json (~/.codiedev by
+// default; ~/.codiedev-desktop under CODIEDEV_CONFIG_DIR). 24h TTL — long
+// enough that the registry isn't hit on every command, short enough that
+// newly-published versions surface the day after release.
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -44,10 +45,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.maybePrintUpgradeNudge = maybePrintUpgradeNudge;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const os = __importStar(require("os"));
 const version_1 = require("./version");
 const versionCheck_1 = require("./versionCheck");
-const CACHE_PATH = path.join(os.homedir(), ".codiedev", ".update-cache.json");
+const configDir_1 = require("./configDir");
+const CACHE_PATH = path.join((0, configDir_1.codiedevStateDir)(), ".update-cache.json");
 const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
 const REGISTRY_URL = "https://registry.npmjs.org/codiedev/latest";
 const FETCH_TIMEOUT_MS = 1500;

package/dist/utils.d.ts

@@ -1,6 +1,8 @@
 import * as fs from "fs";
 import { spawn as nodeSpawn } from "child_process";
 import type { CaptureLogEntry } from "./captureLog";
+import { codiedevStateDir } from "./configDir";
+export { codiedevStateDir };
 export interface CodiedevConfig {
     token: string;
     companyId: string;
@@ -16,6 +18,7 @@ export interface CodiedevConfig {
     deviceName?: string;
     captureIgnoredPaths?: string[];
 }
+export declare const CONFIG_PATH: string;
 export declare function readConfig(): CodiedevConfig | null;
 export declare function writeConfig(config: CodiedevConfig): void;
 /** Exported for permission-focused tests; normal callers use writeConfig. */
@@ -64,11 +67,14 @@ export interface CapturePayloadInput {
     inputTokens?: number;
     outputTokens?: number;
     cacheTokens?: number;
+    cacheReadTokens?: number;
+    cacheCreationTokens?: number;
     model?: string | null;
     sessionStartedAt?: number | null;
     interruptCount?: number;
     rejectionCount?: number;
     final?: boolean;
+    costUsd?: number;
 }
 export declare function buildCapturePayload(input: CapturePayloadInput): Record<string, unknown>;
 export declare function hashToken(token: string): string;
@@ -77,6 +83,11 @@ export declare function resetStableNodeCacheForTests(): void;
 export declare function claudeCodeInstalled(): boolean;
 export declare function codexInstalled(): boolean;
 export declare function cursorInstalled(): boolean;
+export declare function openCodeInstalled(): boolean;
+/** 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. */
+export declare function installOpenCodeCapturePlugin(): void;
 /**
  * VS Code with the GitHub Copilot Chat extension installed. The extension
  * directory pattern is `~/.vscode/extensions/github.copilot-chat-*`. We treat
@@ -158,16 +169,26 @@ export interface SteeringStats {
 }
 export declare function parseClaudeSteering(content: string): SteeringStats;
 export declare function parseCodexSteering(content: string): SteeringStats;
-export declare function parseSteering(content: string, mode: "claude-code" | "codex" | "cursor"): SteeringStats;
+export declare function parseSteering(content: string, mode: "claude-code" | "codex" | "cursor" | "opencode"): SteeringStats;
 export interface UsageStats {
     inputTokens: number;
     outputTokens: number;
+    /** Legacy fold of read + creation — kept for older servers. */
     cacheTokens: number;
+    cacheReadTokens: number;
+    cacheCreationTokens: number;
     model: string | null;
+    /** Engine-reported spend (opencode SDK `info.cost`). Desktop mode only. */
+    costUsd?: number;
 }
-export declare function parseUsage(content: string, mode: "claude-code" | "codex" | "cursor"): UsageStats;
+export declare function parseUsage(content: string, mode: "claude-code" | "codex" | "cursor" | "opencode" | "desktop"): UsageStats;
 export declare function parseSessionStart(content: string): number | null;
 export declare function parseClaudeCodeStats(content: string): ParsedStats;
+/** 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. */
+export declare function normalizeOpenCodeTranscript(content: string): string;
 export declare function parseCodexStats(content: string): ParsedStats;
 export declare function extractCodexRepoUrl(content: string): string | null;
 export interface CaptureUploadJob {
@@ -299,4 +320,3 @@ interface DeferredUploadDeps extends UploadDeps {
 }
 export declare function runDeferredUpload(jobFile: string, delayMs: number, deps: DeferredUploadDeps): Promise<void>;
 export declare function transcriptReadSkipReason(err: unknown): string;
-export {};