codiedev 0.9.25 → 0.9.28

package/dist/hook.js

@@ -45,36 +45,7 @@ const utils_1 = require("./utils");
 const limitEvent_1 = require("./limitEvent");
 const version_1 = require("./version");
 const captureLog_1 = require("./captureLog");
-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();
-    });
-}
+const captureExclusions_1 = require("./captureExclusions");
 // 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
@@ -105,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) {
@@ -176,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);
@@ -185,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 {
@@ -339,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() {
@@ -368,6 +346,12 @@ async function main() {
             // Write per-session upload state so the throttle can defer later
             // non-final uploads within the same window.
             writeSessionState: utils_1.writeSessionUploadState,
+            // Re-read local config in the uploader so adding an exclusion after a
+            // job was queued still prevents its transcript from leaving the device.
+            shouldSkipJob: (job) => {
+                const config = (0, utils_1.readConfig)();
+                return (0, captureExclusions_1.shouldSkipCaptureUploadJob)(job, config);
+            },
         };
     }
     // Detached uploader child (spawned by the capture path below). The job —
@@ -441,6 +425,13 @@ async function main() {
     catch {
         process.exit(0);
     }
+    // Local privacy boundary: every stdin-driven hook mode passes through this
+    // check BEFORE prompt discovery, limit-event tails, SessionStart pings,
+    // backup, self-heal, transcript reads, or detached dispatch. Ignored means
+    // no Codiedev request at all for this session.
+    if ((0, captureExclusions_1.shouldIgnoreCaptureInput)((0, utils_1.readConfig)(), hookInput)) {
+        process.exit(0);
+    }
     // UserPromptSubmit discovery path — separate from session capture.
     if (process.argv[2] === "discover") {
         await runDiscover(hookInput.prompt);
@@ -452,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
@@ -563,6 +554,17 @@ async function runCaptureFinish(input) {
     const config = (0, utils_1.readConfig)();
     if (!config)
         return;
+    // Re-check in the detached child: the user may have added an exclusion
+    // after the parent hook dispatched this job but before it started.
+    if ((0, captureExclusions_1.shouldIgnoreCaptureInput)(config, input)) {
+        (0, captureLog_1.appendCaptureLog)({
+            stage: "capture-finish",
+            sessionId: input.session_id,
+            outcome: "skip",
+            detail: "ignored-path",
+        });
+        return;
+    }
     const { session_id, transcript_path, cwd, workspace_roots } = input;
     if (!transcript_path) {
         await postSessionSkip(config, session_id, "no-transcript-path");
@@ -585,9 +587,15 @@ 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();
+    const scopePaths = (0, captureExclusions_1.captureScopePaths)({ cwd, workspace_roots }, workspaceRoot);
     let transcriptContent;
     try {
         transcriptContent = fs.readFileSync(transcript_path, "utf8");
@@ -606,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
@@ -630,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");
@@ -662,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,
@@ -683,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,
@@ -690,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.
@@ -718,7 +742,12 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
         const hookScriptPath = process.argv[1];
         const tmpFile = path.join(os.tmpdir(), `codiedev-capture-${session_id ?? process.pid}.json`);
         if (decision.mode === "immediate") {
-            (0, utils_1.dispatchCaptureDetached)({ url: `${config.backendUrl}/api/captureSession`, token: config.token, body: payload }, hookScriptPath, { spawn: child_process_1.spawn, writeFileSync: fs.writeFileSync, tmpFile, openSync: fs.openSync, closeSync: fs.closeSync });
+            (0, utils_1.dispatchCaptureDetached)({
+                url: `${config.backendUrl}/api/captureSession`,
+                token: config.token,
+                body: payload,
+                scopePaths,
+            }, hookScriptPath, { spawn: child_process_1.spawn, writeFileSync: fs.writeFileSync, tmpFile, openSync: fs.openSync, closeSync: fs.closeSync });
             // Retry any earlier capture jobs that failed to upload (transient network
             // blips), excluding the one we just dispatched. Best-effort, detached.
             // Skip the sweep on deferred path — the deferred child will handle uploading.
@@ -754,7 +783,12 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
             // Deferred: write the job file (newer turns overwrite = supersede), then
             // spawn the deferred-upload child which will sleep, claim, and upload.
             // Same stdio/fd-hygiene contract as dispatchCaptureDetached.
-            (0, utils_1.dispatchDeferredUpload)({ url: `${config.backendUrl}/api/captureSession`, token: config.token, body: payload }, hookScriptPath, { spawn: child_process_1.spawn, writeFileSync: fs.writeFileSync, tmpFile, openSync: fs.openSync, closeSync: fs.closeSync }, decision.delayMs);
+            (0, utils_1.dispatchDeferredUpload)({
+                url: `${config.backendUrl}/api/captureSession`,
+                token: config.token,
+                body: payload,
+                scopePaths,
+            }, hookScriptPath, { spawn: child_process_1.spawn, writeFileSync: fs.writeFileSync, tmpFile, openSync: fs.openSync, closeSync: fs.closeSync }, decision.delayMs);
         }
     }
     catch (err) {

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;
@@ -12,9 +14,15 @@ export interface CodiedevConfig {
     }>;
     lastSynced: string;
     backendUrl: string;
+    deviceId?: string;
+    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. */
+export declare function writeConfigAtPath(config: CodiedevConfig, configDir: string, configPath: string): void;
 export declare function parseGitRemoteFromConfig(configText: string): string | null;
 export declare function readGitRemoteFromConfig(startDir: string): string | null;
 export declare function getGitRemoteUrl(cwd: string): string | null;
@@ -59,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;
@@ -72,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
@@ -153,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 {
@@ -171,6 +197,7 @@ export interface CaptureUploadJob {
     body: Record<string, unknown>;
     attempts?: number;
     queuedAt?: number;
+    scopePaths?: string[];
 }
 export declare const MAX_UPLOAD_ATTEMPTS = 5;
 export declare const UPLOAD_TTL_MS: number;
@@ -262,6 +289,7 @@ interface UploadDeps {
     recordSuccess?: (job: CaptureUploadJob) => void;
     log?: (entry: CaptureLogEntry) => void;
     writeSessionState?: (sessionId: string, state: SessionUploadState) => void;
+    shouldSkipJob?: (job: CaptureUploadJob) => boolean;
 }
 export interface LastCaptureRecord {
     sessionId: string | undefined;
@@ -292,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 {};