codiedev 0.9.4 → 0.9.6-beta.0

package/dist/backup/run.d.ts

@@ -3,6 +3,7 @@ export interface SelectDeps {
     readFile: (rel: string) => string;
     sha256: (content: string) => string;
 }
+export declare function unionPaths(a: string[], b: string[]): string[];
 export declare function selectBackupFiles(input: {
     repoKey: string;
     statusPaths: string[];
@@ -14,6 +15,7 @@ export declare function selectBackupFiles(input: {
 };
 import { readConfig } from "../utils";
 import { loadCache, saveCache } from "./cache";
+export declare function gitCandidatePaths(root: string): string[];
 export declare function runBackup(cwd: string, hookScriptPath: string): void;
 export interface BackupUploadDeps {
     readConfig: typeof readConfig;

package/dist/backup/run.js

@@ -33,11 +33,29 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.unionPaths = unionPaths;
 exports.selectBackupFiles = selectBackupFiles;
+exports.gitCandidatePaths = gitCandidatePaths;
 exports.runBackup = runBackup;
 exports.runBackupUpload = runBackupUpload;
 const match_1 = require("./match");
 const cache_1 = require("./cache");
+// Pure: merge two path lists into one, deduped, preserving first-seen order.
+function unionPaths(a, b) {
+    const seen = new Set();
+    const out = [];
+    for (const p of a)
+        if (!seen.has(p)) {
+            seen.add(p);
+            out.push(p);
+        }
+    for (const p of b)
+        if (!seen.has(p)) {
+            seen.add(p);
+            out.push(p);
+        }
+    return out;
+}
 // Pure: from this turn's git-status paths, keep artifact files whose content
 // hash changed since the cache. Returns the changed candidates + next cache.
 function selectBackupFiles(input) {
@@ -95,6 +113,27 @@ function gitStatusPaths(root) {
         return [];
     }
 }
+// All git-tracked files (committed, regardless of dirty state). `git ls-files`
+// emits bare NUL-separated paths — no "XY " status prefix — so we don't slice.
+function gitTrackedPaths(root) {
+    try {
+        const out = (0, child_process_1.execFileSync)("git", ["-C", root, "ls-files", "-z"], {
+            encoding: "utf8",
+        });
+        return out.split("\0").filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+// The hook's candidate set: dirty/untracked files ∪ all tracked files. Feeding
+// tracked files in is what lets a COMMITTED artifact (clean status) still get
+// backed up — the hash cache in selectBackupFiles dedups so already-backed-up
+// files don't re-upload. selectBackupFiles rejects non-artifact paths cheaply
+// (by regex, no content read), so the full tracked list is fine to pass.
+function gitCandidatePaths(root) {
+    return unionPaths(gitStatusPaths(root), gitTrackedPaths(root));
+}
 const sha256 = (s) => crypto.createHash("sha256").update(s, "utf8").digest("hex");
 // Stop/sessionEnd hook entry. Best-effort, never throws.
 function runBackup(cwd, hookScriptPath) {
@@ -108,7 +147,9 @@ function runBackup(cwd, hookScriptPath) {
         if (!root)
             return;
         const repoKey = (0, utils_1.getGitRemoteUrl)(root) ?? root;
-        const statusPaths = gitStatusPaths(root);
+        // Dirty files ∪ tracked files — so committed-but-unbacked artifacts are
+        // caught too, not just unsaved drafts. Hash cache dedups the rest.
+        const statusPaths = gitCandidatePaths(root);
         if (statusPaths.length === 0)
             return;
         const prevCache = (0, cache_2.loadCache)();

package/dist/hook.js

@@ -236,31 +236,33 @@ async function main() {
     if (!remoteUrl) {
         remoteUrl = (0, utils_1.getGitRemoteUrl)(workspaceRoot);
     }
-    if (!remoteUrl) {
-        process.exit(0);
-    }
-    // Best-effort local match — backend re-resolves from `remoteUrl` against
-    // the company's current repo list, so a stale or empty local cache
-    // doesn't drop the session. (Pre-0.7.7 we exited 0 here, which silently
-    // dropped sessions for repos added after the user's last `connect`.)
-    const matchedRepo = (0, utils_1.matchRepo)(remoteUrl, config.repos);
+    // Capture-first: the transcript is the asset; the repo is just a tag. We do
+    // NOT bail when `remoteUrl` is null — that previously dropped EVERY session
+    // for users whose workspace couldn't resolve a remote (no git binary on lean
+    // Alpine images, no `origin`, or a submodule whose parent .git isn't mounted),
+    // with no error and a green `doctor`. Upload regardless; the backend accepts
+    // an unmatched capture (repoId null) and surfaces it for triage.
+    //
+    // 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"
         ? (0, utils_1.parseCodexStats)(transcriptContent)
         : mode === "cursor"
             ? { messageCount: 0, toolCallCount: 0 }
             : (0, utils_1.parseClaudeCodeStats)(transcriptContent);
     const transcriptBase64 = Buffer.from(transcriptContent, "utf8").toString("base64");
-    const payload = {
+    const payload = (0, utils_1.buildCapturePayload)({
         sessionId: session_id,
-        repoUrl: remoteUrl,
-        repoId: matchedRepo?.repoId,
+        transcriptBase64,
+        remoteUrl,
+        matchedRepoId: matchedRepo?.repoId,
         companyId: config.companyId,
-        transcript: transcriptBase64,
         messageCount: stats.messageCount,
         toolCallCount: stats.toolCallCount,
         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

package/dist/repoResolver.d.ts

@@ -6,7 +6,7 @@ export interface RepoLite {
     gitProvider?: "github" | "gitlab";
 }
 export interface ResolveInput {
-    remoteUrl: string;
+    remoteUrl: string | null | undefined;
     providedRepoId: string | null;
     companyRepos: ReadonlyArray<RepoLite>;
 }

package/dist/repoResolver.js

@@ -30,7 +30,7 @@ function resolveRepoForCapture(input) {
         if (hit)
             return { repoId: hit._id, source: "provided" };
     }
-    const parsed = parseRemoteUrl(remoteUrl);
+    const parsed = remoteUrl ? parseRemoteUrl(remoteUrl) : null;
     if (!parsed) {
         return { repoId: null, source: "unmatched" };
     }

package/dist/utils.d.ts

@@ -14,6 +14,8 @@ export interface CodiedevConfig {
 }
 export declare function readConfig(): CodiedevConfig | null;
 export declare function writeConfig(config: CodiedevConfig): 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;
 export declare function normalizeRepoUrl(url: string): string;
 export declare function matchRepo(remoteUrl: string, repos: Array<{
@@ -25,6 +27,18 @@ export declare function matchRepo(remoteUrl: string, repos: Array<{
     url: string;
     fullName: string;
 } | null;
+export interface CapturePayloadInput {
+    sessionId?: string;
+    transcriptBase64: string;
+    remoteUrl: string | null;
+    matchedRepoId?: string;
+    companyId: string;
+    messageCount: number;
+    toolCallCount: number;
+    capturedAt: number;
+    source: string;
+}
+export declare function buildCapturePayload(input: CapturePayloadInput): Record<string, unknown>;
 export declare function hashToken(token: string): string;
 export declare function claudeCodeInstalled(): boolean;
 export declare function codexInstalled(): boolean;

package/dist/utils.js

@@ -35,9 +35,12 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readConfig = readConfig;
 exports.writeConfig = writeConfig;
+exports.parseGitRemoteFromConfig = parseGitRemoteFromConfig;
+exports.readGitRemoteFromConfig = readGitRemoteFromConfig;
 exports.getGitRemoteUrl = getGitRemoteUrl;
 exports.normalizeRepoUrl = normalizeRepoUrl;
 exports.matchRepo = matchRepo;
+exports.buildCapturePayload = buildCapturePayload;
 exports.hashToken = hashToken;
 exports.claudeCodeInstalled = claudeCodeInstalled;
 exports.codexInstalled = codexInstalled;
@@ -89,7 +92,115 @@ function writeConfig(config) {
     }
     fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), "utf8");
 }
+// Parse a remote URL out of git-config INI text WITHOUT invoking git. Prefers
+// the "origin" remote; falls back to the first remote found. Returns null if
+// there are no remote sections.
+function parseGitRemoteFromConfig(configText) {
+    const remotes = {};
+    let current = null;
+    for (const raw of configText.split(/\r?\n/)) {
+        const line = raw.trim();
+        const remoteHeader = line.match(/^\[\s*remote\s+"([^"]+)"\s*\]$/);
+        if (remoteHeader) {
+            current = remoteHeader[1];
+            continue;
+        }
+        if (line.startsWith("[")) {
+            // Any other section header ends the current remote context, so a
+            // `url =` under e.g. [core] or [some-section] is never mistaken for one.
+            current = null;
+            continue;
+        }
+        if (current) {
+            const kv = line.match(/^url\s*=\s*(.+)$/);
+            if (kv && remotes[current] === undefined) {
+                remotes[current] = kv[1].trim();
+            }
+        }
+    }
+    if (remotes.origin)
+        return remotes.origin;
+    const first = Object.values(remotes)[0];
+    return first ?? null;
+}
+// Locate the git directory for `startDir`, walking up parent directories.
+// Handles a `.git` directory (normal repo), a `.git` FILE containing
+// `gitdir: <path>` (submodules, some devcontainer/worktree layouts), and stops
+// at the filesystem root. Returns the resolved git dir path, or null.
+function resolveGitDir(startDir) {
+    let dir = path.resolve(startDir);
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const dotGit = path.join(dir, ".git");
+        try {
+            const stat = fs.statSync(dotGit);
+            if (stat.isDirectory())
+                return dotGit;
+            if (stat.isFile()) {
+                const m = fs.readFileSync(dotGit, "utf8").match(/^gitdir:\s*(.+)\s*$/m);
+                if (m) {
+                    const target = m[1].trim();
+                    return path.isAbsolute(target) ? target : path.resolve(dir, target);
+                }
+            }
+        }
+        catch {
+            // No .git here — keep walking up.
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+// Ordered list of config files that may hold the remotes for a git dir. Linked
+// worktrees keep their remotes in the COMMON (main) git dir, pointed at by a
+// `commondir` file, so we check that first, then the git dir's own config.
+function gitConfigCandidates(gitDir) {
+    const candidates = [];
+    try {
+        const commondirFile = path.join(gitDir, "commondir");
+        if (fs.existsSync(commondirFile)) {
+            const rel = fs.readFileSync(commondirFile, "utf8").trim();
+            const commonDir = path.isAbsolute(rel) ? rel : path.resolve(gitDir, rel);
+            candidates.push(path.join(commonDir, "config"));
+        }
+    }
+    catch {
+        // ignore — fall through to the plain config below
+    }
+    candidates.push(path.join(gitDir, "config"));
+    return candidates;
+}
+// Resolve a repo's remote URL by reading .git/config directly — no `git`
+// binary required. This is the primary path so lean container images (Alpine
+// devcontainers without git) still capture sessions instead of silently
+// dropping them.
+function readGitRemoteFromConfig(startDir) {
+    const gitDir = resolveGitDir(startDir);
+    if (!gitDir)
+        return null;
+    for (const cfg of gitConfigCandidates(gitDir)) {
+        try {
+            const url = parseGitRemoteFromConfig(fs.readFileSync(cfg, "utf8"));
+            if (url)
+                return url;
+        }
+        catch {
+            // try the next candidate
+        }
+    }
+    return null;
+}
 function getGitRemoteUrl(cwd) {
+    // Primary: read .git/config directly. Works even when the `git` binary is
+    // absent (lean Alpine/devcontainer images), which previously made the
+    // SessionEnd hook silently drop every session.
+    const fromConfig = readGitRemoteFromConfig(cwd);
+    if (fromConfig)
+        return fromConfig;
+    // Fallback: ask git itself, for setups the direct read doesn't cover
+    // (insteadOf rewrites, includeIf'd remotes, unusual gitdir indirection).
     try {
         const url = (0, child_process_1.execSync)("git remote get-url origin", {
             cwd,
@@ -136,6 +247,19 @@ function matchRepo(remoteUrl, repos) {
     }
     return null;
 }
+function buildCapturePayload(input) {
+    return {
+        sessionId: input.sessionId,
+        repoUrl: input.remoteUrl ?? "",
+        repoId: input.matchedRepoId,
+        companyId: input.companyId,
+        transcript: input.transcriptBase64,
+        messageCount: input.messageCount,
+        toolCallCount: input.toolCallCount,
+        capturedAt: input.capturedAt,
+        source: input.source,
+    };
+}
 function hashToken(token) {
     let hash = 0;
     for (let i = 0; i < token.length; i++) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codiedev",
-  "version": "0.9.4",
+  "version": "0.9.6-beta.0",
   "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",