codiedev 0.9.0 → 0.9.2

package/dist/commands/push.js

@@ -136,7 +136,13 @@ async function runPush(args) {
         const tagSummary = res.tags && res.tags.length > 0 ? ` tags=[${res.tags.join(", ")}]` : "";
         console.log(`✓ Pushed ${filename} (kind=${res.kind}${tagSummary}).`);
         console.log(`  Visible under: ${res.destination}`);
-        console.log(`  Pull with: codiedev pull ${filename}`);
+        // Echo the *resolved* key the server stored, not the local filename —
+        // skills are keyed by their frontmatter name (so two `SKILL.md` files
+        // don't collide), so the stored key can differ from what was pushed.
+        if (res.key && res.key !== filename) {
+            console.log(`  Stored as: ${res.key}`);
+        }
+        console.log(`  Pull with: codiedev pull ${res.key ?? filename}`);
     }
     catch (err) {
         (0, shared_1.recordAgentEvent)(config, {

package/dist/hook.js

@@ -35,8 +35,11 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
 const https = __importStar(require("https"));
 const http = __importStar(require("http"));
+const child_process_1 = require("child_process");
 const utils_1 = require("./utils");
 const version_1 = require("./version");
 function getJson(url, bearerToken) {
@@ -155,6 +158,20 @@ function resolveMode(arg) {
     return "claude-code";
 }
 async function main() {
+    // Detached uploader child (spawned by the capture path below). The job —
+    // including transcript and token — is on disk; no stdin is needed, so handle
+    // this before readStdin() to avoid blocking on the ignored stdin pipe.
+    if (process.argv[2] === "upload") {
+        const jobFile = process.argv[3];
+        if (jobFile) {
+            await (0, utils_1.runCaptureUpload)(jobFile, {
+                post: postJson,
+                readFileSync: fs.readFileSync,
+                unlinkSync: fs.unlinkSync,
+            });
+        }
+        process.exit(0);
+    }
     let hookInput = {};
     try {
         const raw = await readStdin();
@@ -226,11 +243,18 @@ async function main() {
         capturedAt: Date.now(),
         source: mode,
     };
+    // Fire the upload from a fully detached child and exit immediately. Awaiting
+    // it inline let Claude Code's SessionEnd shutdown window elapse and kill the
+    // still-running hook ("Hook cancelled") on large transcripts — even though
+    // the body had already reached the server. The detached child outlives this
+    // process and finishes the POST in the background.
     try {
-        await postJson(`${config.backendUrl}/api/captureSession`, payload, config.token);
+        const hookScriptPath = process.argv[1];
+        const tmpFile = path.join(os.tmpdir(), `codiedev-capture-${session_id ?? process.pid}.json`);
+        (0, utils_1.dispatchCaptureDetached)({ url: `${config.backendUrl}/api/captureSession`, token: config.token, body: payload }, hookScriptPath, { spawn: child_process_1.spawn, writeFileSync: fs.writeFileSync, tmpFile });
     }
     catch (err) {
-        process.stderr.write(`[codiedev-hook] Warning: Failed to capture session — ${err.message}\n`);
+        process.stderr.write(`[codiedev-hook] Warning: Failed to dispatch session capture — ${err.message}\n`);
     }
     process.exit(0);
 }

package/dist/utils.d.ts

@@ -1,3 +1,5 @@
+import * as fs from "fs";
+import { spawn as nodeSpawn } from "child_process";
 export interface CodiedevConfig {
     token: string;
     companyId: string;
@@ -101,3 +103,22 @@ export interface ParsedStats {
 export declare function parseClaudeCodeStats(content: string): ParsedStats;
 export declare function parseCodexStats(content: string): ParsedStats;
 export declare function extractCodexRepoUrl(content: string): string | null;
+export interface CaptureUploadJob {
+    url: string;
+    token: string;
+    body: Record<string, unknown>;
+}
+interface DispatchDeps {
+    spawn: typeof nodeSpawn;
+    writeFileSync: typeof fs.writeFileSync;
+    tmpFile: string;
+    nodePath?: string;
+}
+export declare function dispatchCaptureDetached(job: CaptureUploadJob, hookScriptPath: string, deps: DispatchDeps): void;
+interface UploadDeps {
+    post: (url: string, body: Record<string, unknown>, token: string) => Promise<void>;
+    readFileSync: typeof fs.readFileSync;
+    unlinkSync: typeof fs.unlinkSync;
+}
+export declare function runCaptureUpload(jobFile: string, deps: UploadDeps): Promise<void>;
+export {};

package/dist/utils.js

@@ -62,6 +62,8 @@ exports.installCursorHook = installCursorHook;
 exports.parseClaudeCodeStats = parseClaudeCodeStats;
 exports.parseCodexStats = parseCodexStats;
 exports.extractCodexRepoUrl = extractCodexRepoUrl;
+exports.dispatchCaptureDetached = dispatchCaptureDetached;
+exports.runCaptureUpload = runCaptureUpload;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
@@ -854,3 +856,34 @@ function extractCodexRepoUrl(content) {
     }
     return null;
 }
+// Fire-and-forget the session-capture upload from a fully detached child so the
+// SessionEnd hook can exit 0 immediately. Awaiting the upload inline let Claude
+// Code's shutdown window elapse and kill the hook ("Hook cancelled") on large
+// transcripts. The job (incl. bearer token) is written to a file rather than
+// passed via argv so it never shows up in the process list.
+function dispatchCaptureDetached(job, hookScriptPath, deps) {
+    deps.writeFileSync(deps.tmpFile, JSON.stringify(job), { mode: 0o600 });
+    const child = deps.spawn(deps.nodePath ?? process.execPath, [hookScriptPath, "upload", deps.tmpFile], { detached: true, stdio: "ignore" });
+    child.unref();
+}
+// Runs inside the detached child spawned by `dispatchCaptureDetached`: read the
+// persisted job, POST it, and ALWAYS delete the temp file afterwards (even on
+// failure) so we don't litter the tmp dir. Never throws — capture is
+// best-effort.
+async function runCaptureUpload(jobFile, deps) {
+    try {
+        const job = JSON.parse(deps.readFileSync(jobFile, "utf8"));
+        await deps.post(job.url, job.body, job.token);
+    }
+    catch {
+        // best-effort — the parent already exited; nothing to report to.
+    }
+    finally {
+        try {
+            deps.unlinkSync(jobFile);
+        }
+        catch {
+            // temp file already gone — fine.
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "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",