codiedev 0.9.9 → 0.9.11

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);
@@ -256,9 +259,19 @@ async function main() {
     // server-side against a merged MR/PR's source_branch / commits for AI attribution.
     // 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.
-    const captureDir = (0, utils_1.resolveCaptureDir)(transcriptContent, workspaceRoot);
-    const branch = (0, utils_1.getGitBranch)(captureDir);
-    const headSha = (0, utils_1.getGitHeadSha)(captureDir);
+    // 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 keys = (0, utils_1.collectCaptureKeys)(captureDirs);
+    const { branch, branches } = keys;
+    // Union the worktree HEAD shas with the SHAs the agent actually committed/
+    // pushed (parsed from the transcript's git output, resolved via the shared
+    // object store). The authored shas are independent of end-of-session
+    // filesystem state, so they rescue attribution when a worktree is stale/gone.
+    const authoredShas = (0, utils_1.parseAuthoredShas)(transcriptContent, workspaceRoot);
+    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);
@@ -276,6 +289,8 @@ async function main() {
         source: mode,
         branch,
         headSha,
+        branches,
+        headShas,
         inputTokens: usage.inputTokens,
         outputTokens: usage.outputTokens,
         cacheTokens: usage.cacheTokens,
@@ -293,6 +308,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

@@ -28,6 +28,15 @@ export declare function matchRepo(remoteUrl: string, repos: Array<{
     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 extractShaTokens(transcriptContent: string): string[];
+export declare function parseAuthoredShas(transcriptContent: string, repoRoot: string, resolveFull?: (sha: string) => string | null): string[];
 export declare function getGitBranch(cwd: string): string | null;
 export declare function getGitHeadSha(cwd: string): string | null;
 export interface CapturePayloadInput {
@@ -42,6 +51,8 @@ export interface CapturePayloadInput {
     source: string;
     branch?: string | null;
     headSha?: string | null;
+    branches?: string[];
+    headShas?: string[];
     inputTokens?: number;
     outputTokens?: number;
     cacheTokens?: number;
@@ -149,7 +160,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;
@@ -157,10 +172,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;
@@ -41,6 +42,10 @@ exports.getGitRemoteUrl = getGitRemoteUrl;
 exports.normalizeRepoUrl = normalizeRepoUrl;
 exports.matchRepo = matchRepo;
 exports.resolveCaptureDir = resolveCaptureDir;
+exports.resolveCaptureDirs = resolveCaptureDirs;
+exports.collectCaptureKeys = collectCaptureKeys;
+exports.extractShaTokens = extractShaTokens;
+exports.parseAuthoredShas = parseAuthoredShas;
 exports.getGitBranch = getGitBranch;
 exports.getGitHeadSha = getGitHeadSha;
 exports.buildCapturePayload = buildCapturePayload;
@@ -75,6 +80,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"));
@@ -270,28 +276,147 @@ function matchRepo(remoteUrl, repos) {
 // 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 = [];
+    // Collect EVERY filesystem path the session referenced, in order — not just
+    // the session cwd. An agent can touch a worktree without cd-ing into it:
+    //   - `git -C <path> ...`            (operate on a worktree by path)
+    //   - editing a file inside it       ("file_path": "<worktree>/src/x.ts")
+    // Catching all of these is what makes worktree detection robust.
+    const candidates = [];
+    const add = (p) => {
+        if (!p)
+            return;
+        candidates.push(path.isAbsolute(p) ? p : path.resolve(workspaceRoot, p));
+    };
+    const gitCRe = /git\s+(?:[^\s]+\s+)*?-C\s+(?:"([^"]+)"|'([^']+)'|(\S+))/g;
+    const filePathRe = /"file_path"\s*:\s*"((?:[^"\\]|\\.)+)"/g;
     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);
+                add(entry.cwd);
         }
         catch {
-            // non-JSON / partial line — skip
+            // non-JSON / partial line — still scan the raw text below
+        }
+        let m;
+        gitCRe.lastIndex = 0;
+        while ((m = gitCRe.exec(line)))
+            add(m[1] ?? m[2] ?? m[3]);
+        filePathRe.lastIndex = 0;
+        while ((m = filePathRe.exec(line))) {
+            try {
+                add(path.dirname(JSON.parse(`"${m[1]}"`)));
+            }
+            catch { /* skip */ }
+        }
+    }
+    // Walk most-recent first; 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). Normalize each to its canonical worktree
+    // root so a file path / subdir resolves to the worktree dir itself.
+    const out = [];
+    const seenGitDirs = new Set();
+    for (let i = candidates.length - 1; i >= 0; i--) {
+        const gitDir = resolveGitDir(candidates[i]);
+        if (!gitDir || (rootGitDir && gitDir === rootGitDir))
+            continue;
+        if (seenGitDirs.has(gitDir))
+            continue;
+        seenGitDirs.add(gitDir);
+        out.push(worktreeRootFromGitDir(gitDir) ?? candidates[i]);
+    }
+    return out.length > 0 ? out : [workspaceRoot];
+}
+// A linked worktree's gitdir (`.git/worktrees/<name>`) holds a `gitdir` file
+// pointing at the worktree's own `.git` file; its parent is the worktree root.
+function worktreeRootFromGitDir(gitDir) {
+    try {
+        const p = fs.readFileSync(path.join(gitDir, "gitdir"), "utf8").trim();
+        return p ? path.dirname(p) : null;
+    }
+    catch {
+        return null;
+    }
+}
+// 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 };
+}
+// Pull the commit SHAs the agent actually authored/pushed straight out of the
+// transcript's git command OUTPUT — independent of end-of-session filesystem
+// state. Catches: commit output "[branch 4c4e790]", push ranges
+// "abc1234..def5678", and bare 40-hex (rev-parse). This is the signal that
+// rescues attribution when the worktree's HEAD is stale or the worktree is gone
+// at SessionEnd (pruned worktree, submodule pointer bump).
+function extractShaTokens(transcriptContent) {
+    const out = new Set();
+    const commitRe = /\[[^\]\n]*?\b([0-9a-f]{7,40})\]/g; // [branch <sha>]
+    const rangeRe = /\b([0-9a-f]{7,40})\.\.([0-9a-f]{7,40})\b/g; // <sha>..<sha>
+    const fullRe = /\b([0-9a-f]{40})\b/g; // bare full sha (rev-parse)
+    let m;
+    while ((m = commitRe.exec(transcriptContent)))
+        out.add(m[1].toLowerCase());
+    while ((m = rangeRe.exec(transcriptContent))) {
+        out.add(m[1].toLowerCase());
+        out.add(m[2].toLowerCase());
+    }
+    while ((m = fullRe.exec(transcriptContent)))
+        out.add(m[1].toLowerCase());
+    return [...out];
+}
+// Resolve the extracted tokens to FULL 40-char SHAs via the repo's shared object
+// store (a worktree's commits live in the main repo's .git/objects, so they
+// resolve even after the worktree dir is removed). Full SHAs pass through; short
+// ones are resolved; unresolvable ones are dropped (a short sha can't exact-
+// match the worker's full commitShas). Keeps the server-side match exact.
+function parseAuthoredShas(transcriptContent, repoRoot, resolveFull = (sha) => defaultResolveFullSha(sha, repoRoot)) {
+    const out = new Set();
+    for (const tok of extractShaTokens(transcriptContent)) {
+        if (tok.length === 40) {
+            out.add(tok);
+            continue;
         }
+        const full = resolveFull(tok);
+        if (full && /^[0-9a-f]{40}$/.test(full))
+            out.add(full.toLowerCase());
     }
-    // Most-recent first: the last worktree touched is the one most likely to have
-    // produced the PR.
-    for (let i = cwds.length - 1; i >= 0; i--) {
-        const gitDir = resolveGitDir(cwds[i]);
-        if (gitDir && (!rootGitDir || gitDir !== rootGitDir))
-            return cwds[i];
+    return [...out];
+}
+function defaultResolveFullSha(sha, repoRoot) {
+    try {
+        const r = (0, child_process_1.execSync)(`git rev-parse ${sha}^{commit}`, {
+            cwd: repoRoot,
+            stdio: ["pipe", "pipe", "pipe"],
+        }).toString().trim();
+        return /^[0-9a-f]{40}$/.test(r) ? r : null;
+    }
+    catch {
+        return null;
     }
-    return workspaceRoot;
 }
 // Current branch via direct .git/HEAD read (no git binary required, same
 // robustness as getGitRemoteUrl). Returns null on detached HEAD or when
@@ -388,6 +513,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,
@@ -1297,6 +1426,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
@@ -1307,24 +1440,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.9",
+  "version": "0.9.11",
   "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",