codiedev 0.9.23 → 0.9.24

package/dist/hook.js

@@ -241,6 +241,84 @@ timeoutMs) {
         req.end();
     });
 }
+// postJson variant that returns the parsed response body — the upload-URL
+// handshake needs the { uploadUrl } the server hands back. No timeout: runs
+// only in detached uploader children, never on the shutdown clock.
+function postJsonForResponse(url, body, bearerToken) {
+    return new Promise((resolve, reject) => {
+        const parsed = new URL(url);
+        const data = JSON.stringify(body);
+        const lib = parsed.protocol === "https:" ? https : http;
+        const req = lib.request({
+            hostname: parsed.hostname,
+            port: parsed.port || (parsed.protocol === "https:" ? 443 : 80),
+            path: parsed.pathname + parsed.search,
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Content-Length": Buffer.byteLength(data),
+                Authorization: `Bearer ${bearerToken}`,
+                "X-Codiedev-Cli-Version": version_1.CLI_VERSION,
+            },
+        }, (res) => {
+            let responseData = "";
+            res.on("data", (chunk) => (responseData += chunk));
+            res.on("end", () => {
+                if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                    try {
+                        resolve(JSON.parse(responseData));
+                    }
+                    catch {
+                        reject(new Error(`HTTP ${res.statusCode}: unparseable response`));
+                    }
+                }
+                else {
+                    reject(new Error(`HTTP ${res.statusCode}: ${responseData}`));
+                }
+            });
+        });
+        req.on("error", reject);
+        req.write(data);
+        req.end();
+    });
+}
+// Raw-bytes POST to a Convex storage upload URL (no auth header — the URL
+// itself is the one-time credential). Returns the parsed { storageId }.
+function postBytes(url, bytes, contentType) {
+    return new Promise((resolve, reject) => {
+        const parsed = new URL(url);
+        const lib = parsed.protocol === "https:" ? https : http;
+        const req = lib.request({
+            hostname: parsed.hostname,
+            port: parsed.port || (parsed.protocol === "https:" ? 443 : 80),
+            path: parsed.pathname + parsed.search,
+            method: "POST",
+            headers: {
+                "Content-Type": contentType,
+                "Content-Length": bytes.length,
+            },
+        }, (res) => {
+            let responseData = "";
+            res.on("data", (chunk) => (responseData += chunk));
+            res.on("end", () => {
+                if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+                    try {
+                        resolve(JSON.parse(responseData));
+                    }
+                    catch {
+                        reject(new Error(`HTTP ${res.statusCode}: unparseable response`));
+                    }
+                }
+                else {
+                    reject(new Error(`HTTP ${res.statusCode}: ${responseData}`));
+                }
+            });
+        });
+        req.on("error", reject);
+        req.write(bytes);
+        req.end();
+    });
+}
 // Short leash for the tiny coverage pings (sessionStart / sessionSkip): they
 // carry a few bytes and must never stall a hook. 3s is generous for a ping
 // and a hard bound for the shutdown clock.
@@ -270,6 +348,12 @@ async function main() {
     function makeUploadDeps() {
         return {
             post: postJson,
+            // Direct-to-storage flow for big transcripts (see utils.ts
+            // DIRECT_UPLOAD_THRESHOLD_CHARS): fetch a one-time upload URL, then
+            // POST the raw bytes to it. Keeps ~7MB+ transcripts out of the
+            // backend's 64MB captureSession isolate.
+            requestJson: postJsonForResponse,
+            uploadBytes: postBytes,
             readFileSync: fs.readFileSync,
             unlinkSync: fs.unlinkSync,
             // Persist a bumped attempt count on failure so a later sweep retries
@@ -508,17 +592,18 @@ async function runCaptureFinishInner(input, config, session_id, transcript_path,
     try {
         transcriptContent = fs.readFileSync(transcript_path, "utf8");
     }
-    catch {
-        // Previously the one fully-silent gap in the detached child: no log, no
-        // server signal. Diagnose it — deleted/rotated transcript, permissions,
-        // unmounted path.
+    catch (err) {
+        // ENOENT → "no-transcript" (phantom desktop-app helper session, excluded
+        // from coverage server-side); anything else → "transcript-unreadable:<code>"
+        // (real transcript, read failed — a genuine, diagnosable loss).
+        const reason = (0, utils_1.transcriptReadSkipReason)(err);
         (0, captureLog_1.appendCaptureLog)({
             stage: "capture-finish",
             sessionId: session_id,
             outcome: "skip",
-            detail: "transcript-unreadable",
+            detail: reason,
         });
-        await postSessionSkip(config, session_id, "transcript-unreadable");
+        await postSessionSkip(config, session_id, reason);
         return;
     }
     // Resolve repo URL. Codex embeds it in session_meta; CC and Cursor both

package/dist/utils.d.ts

@@ -248,8 +248,11 @@ export declare function pruneCaptureStateDir(deps?: {
     };
     unlinkSync: (p: string) => void;
 }, dir?: string, now?: number): void;
+export declare const DIRECT_UPLOAD_THRESHOLD_CHARS = 2000000;
 interface UploadDeps {
     post: (url: string, body: Record<string, unknown>, token: string) => Promise<void>;
+    requestJson?: (url: string, body: Record<string, unknown>, token: string) => Promise<any>;
+    uploadBytes?: (url: string, bytes: Buffer, contentType: string) => Promise<any>;
     readFileSync: typeof fs.readFileSync;
     unlinkSync: typeof fs.unlinkSync;
     writeFileSync?: typeof fs.writeFileSync;
@@ -286,4 +289,5 @@ interface DeferredUploadDeps extends UploadDeps {
     sleep?: (ms: number) => Promise<void>;
 }
 export declare function runDeferredUpload(jobFile: string, delayMs: number, deps: DeferredUploadDeps): Promise<void>;
+export declare function transcriptReadSkipReason(err: unknown): string;
 export {};

package/dist/utils.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-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 = void 0;
 exports.readConfig = readConfig;
 exports.writeConfig = writeConfig;
 exports.parseGitRemoteFromConfig = parseGitRemoteFromConfig;
@@ -99,6 +99,7 @@ exports.writeLastCapture = writeLastCapture;
 exports.readLastCapture = readLastCapture;
 exports.runCaptureUpload = runCaptureUpload;
 exports.runDeferredUpload = runDeferredUpload;
+exports.transcriptReadSkipReason = transcriptReadSkipReason;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
@@ -2028,6 +2029,13 @@ function pruneCaptureStateDir(deps = fs, dir = CAPTURE_STATE_DIR, now = Date.now
         // dir missing/unreadable — nothing to prune
     }
 }
+// Base64 length above which the transcript goes straight to storage instead
+// of inline in the captureSession JSON body. The backend's HTTP-action
+// isolate has a 64MB cap and inline base64 amplifies ~8x in memory (request
+// text + parsed JSON + decode output all resident) — ~7MB transcripts OOM it
+// (observed live 2026-07-02). 2M base64 chars ≈ 1.5MB raw: far below the
+// cliff, while per-turn snapshots (typically KBs) skip the extra roundtrips.
+exports.DIRECT_UPLOAD_THRESHOLD_CHARS = 2_000_000;
 // "Last session captured" breadcrumb. Written next to config.json on a
 // successful capture upload; read by `codiedev doctor` so a user can confirm
 // their most recent session actually landed (the single hardest thing to
@@ -2086,7 +2094,22 @@ async function runCaptureUpload(jobFile, deps) {
     }
     const sessionId = job.body?.sessionId;
     try {
-        await deps.post(job.url, job.body, job.token);
+        // Big transcript + capable deps → direct-to-storage: fetch a one-time
+        // upload URL, PUT the raw bytes, send captureSession the storageId. Any
+        // step failing throws into the retry path below, same as a failed POST.
+        let body = job.body;
+        const transcript = body?.transcript;
+        if (transcript &&
+            transcript.length > exports.DIRECT_UPLOAD_THRESHOLD_CHARS &&
+            deps.requestJson &&
+            deps.uploadBytes) {
+            const uploadUrlEndpoint = job.url.replace(/\/api\/captureSession$/, "/api/captureUploadUrl");
+            const { uploadUrl } = await deps.requestJson(uploadUrlEndpoint, {}, job.token);
+            const { storageId } = await deps.uploadBytes(uploadUrl, Buffer.from(transcript, "base64"), "application/json");
+            body = { ...body, transcriptStorageId: storageId };
+            delete body.transcript;
+        }
+        await deps.post(job.url, body, job.token);
         // success — drop a "last session captured" breadcrumb (before removing the
         // job) so doctor can confirm the most recent session actually landed.
         if (deps.recordSuccess) {
@@ -2225,3 +2248,15 @@ async function runDeferredUpload(jobFile, delayMs, deps) {
     }
     await runCaptureUpload(claimed, deps);
 }
+// Classify a transcript read failure at capture time. ENOENT = the transcript
+// never existed: a desktop-app phantom helper session (SessionStart/End hooks
+// fire, no conversation ever happens), not lost work — the backend excludes
+// "no-transcript" from coverage. Anything else means a real transcript was
+// there but the read failed: a genuine loss, tagged with the errno so it stays
+// diagnosable from the server side.
+function transcriptReadSkipReason(err) {
+    const code = err?.code;
+    if (code === "ENOENT")
+        return "no-transcript";
+    return `transcript-unreadable:${code || "unknown"}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.23",
+  "version": "0.9.24",
   "description": "Connect Claude Code, Codex, Cursor, or VS Code Copilot to Codiedev for org-wide session capture and artifact collaboration",
   "bin": {
     "codiedev": "dist/cli.js",