codiedev 0.9.8 → 0.9.10

package/dist/hook.js

@@ -168,6 +168,9 @@ async function main() {
                 post: postJson,
                 readFileSync: fs.readFileSync,
                 unlinkSync: fs.unlinkSync,
+                // Persist a bumped attempt count on failure so a later sweep retries
+                // (instead of dropping a session on a transient network blip).
+                writeFileSync: fs.writeFileSync,
             });
         }
         process.exit(0);
@@ -254,8 +257,13 @@ async function main() {
     const transcriptBase64 = Buffer.from(transcriptContent, "utf8").toString("base64");
     // Session→merge join keys: the branch + HEAD sha the work happened on. Matched
     // server-side against a merged MR/PR's source_branch / commits for AI attribution.
-    const branch = (0, utils_1.getGitBranch)(workspaceRoot);
-    const headSha = (0, utils_1.getGitHeadSha)(workspaceRoot);
+    // Capture from the worktree the agent actually worked in (the launch dir stays
+    // on main/detached when work happens in a `git worktree`), not workspaceRoot.
+    // One session can touch several worktrees (→ several PRs); capture EVERY
+    // worktree's branch+sha so all the resulting PRs attribute. branch/headSha
+    // remain the primary (most-recent) values for back-compat.
+    const captureDirs = (0, utils_1.resolveCaptureDirs)(transcriptContent, workspaceRoot);
+    const { branch, headSha, branches, headShas } = (0, utils_1.collectCaptureKeys)(captureDirs);
     // 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);
@@ -273,6 +281,8 @@ async function main() {
         source: mode,
         branch,
         headSha,
+        branches,
+        headShas,
         inputTokens: usage.inputTokens,
         outputTokens: usage.outputTokens,
         cacheTokens: usage.cacheTokens,
@@ -290,6 +300,15 @@ async function main() {
         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 });
+        // Retry any earlier capture jobs that failed to upload (transient network
+        // blips), excluding the one we just dispatched. Best-effort, detached.
+        (0, utils_1.sweepPendingCaptures)({
+            dir: os.tmpdir(),
+            readdirSync: fs.readdirSync,
+            spawn: child_process_1.spawn,
+            hookScriptPath,
+            exclude: tmpFile,
+        });
     }
     catch (err) {
         process.stderr.write(`[codiedev-hook] Warning: Failed to dispatch session capture — ${err.message}\n`);

package/dist/utils.d.ts

@@ -27,6 +27,14 @@ export declare function matchRepo(remoteUrl: string, repos: Array<{
     url: string;
     fullName: string;
 } | null;
+export declare function resolveCaptureDir(transcriptContent: string, workspaceRoot: string): string;
+export declare function resolveCaptureDirs(transcriptContent: string, workspaceRoot: string): string[];
+export declare function collectCaptureKeys(dirs: string[], getBranch?: (d: string) => string | null, getSha?: (d: string) => string | null): {
+    branch: string | null;
+    headSha: string | null;
+    branches: string[];
+    headShas: string[];
+};
 export declare function getGitBranch(cwd: string): string | null;
 export declare function getGitHeadSha(cwd: string): string | null;
 export interface CapturePayloadInput {
@@ -41,6 +49,8 @@ export interface CapturePayloadInput {
     source: string;
     branch?: string | null;
     headSha?: string | null;
+    branches?: string[];
+    headShas?: string[];
     inputTokens?: number;
     outputTokens?: number;
     cacheTokens?: number;
@@ -148,7 +158,11 @@ export interface CaptureUploadJob {
     url: string;
     token: string;
     body: Record<string, unknown>;
+    attempts?: number;
+    queuedAt?: number;
 }
+export declare const MAX_UPLOAD_ATTEMPTS = 5;
+export declare const UPLOAD_TTL_MS: number;
 interface DispatchDeps {
     spawn: typeof nodeSpawn;
     writeFileSync: typeof fs.writeFileSync;
@@ -156,10 +170,22 @@ interface DispatchDeps {
     nodePath?: string;
 }
 export declare function dispatchCaptureDetached(job: CaptureUploadJob, hookScriptPath: string, deps: DispatchDeps): void;
+interface SweepDeps {
+    dir: string;
+    readdirSync: (dir: string) => string[];
+    spawn: typeof nodeSpawn;
+    hookScriptPath: string;
+    nodePath?: string;
+    exclude?: string;
+    max?: number;
+}
+export declare function sweepPendingCaptures(deps: SweepDeps): void;
 interface UploadDeps {
     post: (url: string, body: Record<string, unknown>, token: string) => Promise<void>;
     readFileSync: typeof fs.readFileSync;
     unlinkSync: typeof fs.unlinkSync;
+    writeFileSync?: typeof fs.writeFileSync;
+    now?: () => number;
 }
 export declare function runCaptureUpload(jobFile: string, deps: UploadDeps): Promise<void>;
 export {};

package/dist/utils.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.UPLOAD_TTL_MS = exports.MAX_UPLOAD_ATTEMPTS = void 0;
 exports.readConfig = readConfig;
 exports.writeConfig = writeConfig;
 exports.parseGitRemoteFromConfig = parseGitRemoteFromConfig;
@@ -40,6 +41,9 @@ exports.readGitRemoteFromConfig = readGitRemoteFromConfig;
 exports.getGitRemoteUrl = getGitRemoteUrl;
 exports.normalizeRepoUrl = normalizeRepoUrl;
 exports.matchRepo = matchRepo;
+exports.resolveCaptureDir = resolveCaptureDir;
+exports.resolveCaptureDirs = resolveCaptureDirs;
+exports.collectCaptureKeys = collectCaptureKeys;
 exports.getGitBranch = getGitBranch;
 exports.getGitHeadSha = getGitHeadSha;
 exports.buildCapturePayload = buildCapturePayload;
@@ -74,6 +78,7 @@ exports.parseClaudeCodeStats = parseClaudeCodeStats;
 exports.parseCodexStats = parseCodexStats;
 exports.extractCodexRepoUrl = extractCodexRepoUrl;
 exports.dispatchCaptureDetached = dispatchCaptureDetached;
+exports.sweepPendingCaptures = sweepPendingCaptures;
 exports.runCaptureUpload = runCaptureUpload;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -254,6 +259,76 @@ function matchRepo(remoteUrl, repos) {
     }
     return null;
 }
+// Resolve the directory to capture git branch/headSha from.
+//
+// The session→merge join keys must describe the work that becomes the PR. But
+// agents do that work in a `git worktree` (.claude/worktrees/<name> or a
+// sibling dir) on a feature branch, while the session's LAUNCH dir
+// (workspaceRoot) stays on main/detached — a feature branch checked out in a
+// worktree cannot also be checked out in the launch dir. Capturing from the
+// launch dir therefore recorded main/null, matching no PR (velocity starved).
+//
+// Fix: scan the transcript for the cwd the agent actually worked in — the
+// most-recent one that is a SEPARATE worktree (its resolved gitdir differs from
+// the launch root's; a worktree's gitdir is .git/worktrees/<name>, while the
+// root and its subdirs share .git). Fall back to the launch root when no
+// separate worktree was used (work done directly in the repo).
+function resolveCaptureDir(transcriptContent, workspaceRoot) {
+    return resolveCaptureDirs(transcriptContent, workspaceRoot)[0] ?? workspaceRoot;
+}
+// Plural: EVERY separate worktree the session touched, most-recent first. One
+// session can produce multiple PRs (work across several worktrees, each on its
+// own feature branch); capturing every worktree's branch+sha lets all of those
+// PRs attribute. Falls back to [workspaceRoot] when no separate worktree was
+// used (work done directly in the repo).
+function resolveCaptureDirs(transcriptContent, workspaceRoot) {
+    const rootGitDir = resolveGitDir(workspaceRoot);
+    const cwds = [];
+    for (const line of transcriptContent.split("\n")) {
+        if (!line.trim())
+            continue;
+        try {
+            const entry = JSON.parse(line);
+            if (typeof entry?.cwd === "string" && entry.cwd)
+                cwds.push(entry.cwd);
+        }
+        catch {
+            // non-JSON / partial line — skip
+        }
+    }
+    // Walk most-recent first; keep one entry per distinct worktree gitdir (a
+    // worktree's gitdir is .git/worktrees/<name>; the root and its subdirs share
+    // .git, so they're excluded as not-separate).
+    const out = [];
+    const seenGitDirs = new Set();
+    for (let i = cwds.length - 1; i >= 0; i--) {
+        const gitDir = resolveGitDir(cwds[i]);
+        if (!gitDir || (rootGitDir && gitDir === rootGitDir))
+            continue;
+        if (seenGitDirs.has(gitDir))
+            continue;
+        seenGitDirs.add(gitDir);
+        out.push(cwds[i]);
+    }
+    return out.length > 0 ? out : [workspaceRoot];
+}
+// Turn the worktrees a session touched into the upload join keys: dedup'd
+// branch + headSha arrays (so one session → many PRs all attribute), plus the
+// primary single values (first entry) for back-compat with servers that read
+// only branch/headSha. getBranch/getSha are injectable for testing.
+function collectCaptureKeys(dirs, getBranch = getGitBranch, getSha = getGitHeadSha) {
+    const branches = [];
+    const headShas = [];
+    for (const d of dirs) {
+        const b = getBranch(d);
+        if (b && !branches.includes(b))
+            branches.push(b);
+        const s = getSha(d);
+        if (s && !headShas.includes(s))
+            headShas.push(s);
+    }
+    return { branch: branches[0] ?? null, headSha: headShas[0] ?? null, branches, headShas };
+}
 // Current branch via direct .git/HEAD read (no git binary required, same
 // robustness as getGitRemoteUrl). Returns null on detached HEAD or when
 // unresolvable. This is the session→merge join key: a captured session's
@@ -349,6 +424,10 @@ function buildCapturePayload(input) {
         companyId: input.companyId,
         branch: input.branch ?? "",
         headSha: input.headSha ?? "",
+        // Arrays omitted when empty so older servers (which ignore unknown keys)
+        // see no change; newer servers index the session under every key.
+        branches: input.branches && input.branches.length ? input.branches : undefined,
+        headShas: input.headShas && input.headShas.length ? input.headShas : undefined,
         transcript: input.transcriptBase64,
         messageCount: input.messageCount,
         toolCallCount: input.toolCallCount,
@@ -1258,6 +1337,10 @@ function extractCodexRepoUrl(content) {
     }
     return null;
 }
+// Give up after this many failed uploads (across sessions) so a permanently
+// failing job never litters /tmp forever. Paired with UPLOAD_TTL_MS.
+exports.MAX_UPLOAD_ATTEMPTS = 5;
+exports.UPLOAD_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 // 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
@@ -1268,24 +1351,81 @@ function dispatchCaptureDetached(job, hookScriptPath, deps) {
     const child = deps.spawn(deps.nodePath ?? process.execPath, [hookScriptPath, "upload", deps.tmpFile], { detached: true, stdio: "ignore" });
     child.unref();
 }
+// Retry kept-on-failure capture jobs: re-dispatch each pending
+// `codiedev-capture-*.json` to the detached uploader (which bumps attempts /
+// gives up at the cap). Best-effort — never throws into the hook.
+function sweepPendingCaptures(deps) {
+    let files;
+    try {
+        files = deps.readdirSync(deps.dir);
+    }
+    catch {
+        return;
+    }
+    const jobs = files
+        .filter((f) => /^codiedev-capture-.*\.json$/.test(f))
+        .map((f) => path.join(deps.dir, f))
+        .filter((p) => p !== deps.exclude)
+        .slice(0, deps.max ?? 10);
+    for (const jobFile of jobs) {
+        try {
+            const child = deps.spawn(deps.nodePath ?? process.execPath, [deps.hookScriptPath, "upload", jobFile], { detached: true, stdio: "ignore" });
+            child.unref();
+        }
+        catch {
+            // ignore — best-effort retry
+        }
+    }
+}
 // 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) {
+    let job = null;
     try {
-        const job = JSON.parse(deps.readFileSync(jobFile, "utf8"));
-        await deps.post(job.url, job.body, job.token);
+        job = JSON.parse(deps.readFileSync(jobFile, "utf8"));
     }
     catch {
-        // best-effort — the parent already exited; nothing to report to.
+        // unreadable/corrupt job — delete it and stop.
+        try {
+            deps.unlinkSync(jobFile);
+        }
+        catch { /* gone */ }
+        return;
     }
-    finally {
+    try {
+        await deps.post(job.url, job.body, job.token);
+        // success — remove the job.
         try {
             deps.unlinkSync(jobFile);
         }
+        catch { /* gone */ }
+        return;
+    }
+    catch {
+        // Failure: keep the job for a later sweep to retry, UNLESS we've hit the
+        // attempt cap or TTL — then give up so /tmp doesn't accumulate forever.
+        const now = deps.now ? deps.now() : Date.now();
+        const attempts = (job.attempts ?? 0) + 1;
+        const queuedAt = job.queuedAt ?? now;
+        const expired = now - queuedAt > exports.UPLOAD_TTL_MS;
+        if (attempts >= exports.MAX_UPLOAD_ATTEMPTS || expired || !deps.writeFileSync) {
+            try {
+                deps.unlinkSync(jobFile);
+            }
+            catch { /* gone */ }
+            return;
+        }
+        try {
+            deps.writeFileSync(jobFile, JSON.stringify({ ...job, attempts, queuedAt }), { mode: 0o600 });
+        }
         catch {
-            // temp file already gone — fine.
+            // couldn't persist the bump — drop it rather than risk a stuck file.
+            try {
+                deps.unlinkSync(jobFile);
+            }
+            catch { /* gone */ }
         }
     }
 }

package/package.json

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