@tea-agent/loop-agent 0.44.0-next.4 → 0.44.0-next.6

package/dist/shared/git-workspace-status.js

@@ -0,0 +1,480 @@
+import { access, lstat } from "node:fs/promises";
+import path from "node:path";
+import { runResilientGitCommand } from "./resilient-git.js";
+const MAX_SUBMODULE_DEPTH = 4;
+export const DEFAULT_WORKSPACE_STATUS_DEPENDENCIES = {
+    runGit: (cwd, args) => runResilientGitCommand({ cwd, args, readOnly: true }).then((result) => ({
+        code: result.code,
+        stdout: result.stdout,
+        stderr: result.stderr,
+    })),
+    readSubmoduleStatus: async (cwd) => {
+        const result = await runResilientGitCommand({
+            cwd,
+            args: ["status", "--porcelain=v1", "--untracked-files=all"],
+            readOnly: true,
+        });
+        if (result.code !== 0) {
+            throw new Error(result.stderr.trim() ||
+                result.stdout.trim() ||
+                `git status exited ${result.code}`);
+        }
+        return result.stdout;
+    },
+};
+/** Parse porcelain v1 output into normalized path -> "XY" entries. */
+export function parsePorcelainEntries(porcelain) {
+    const entries = new Map();
+    for (const line of porcelain.split("\n")) {
+        const trimmed = line.trimEnd();
+        if (!trimmed)
+            continue;
+        const x = trimmed[0] ?? " ";
+        const y = trimmed[1] ?? " ";
+        const rawPath = trimmed.slice(3);
+        if (!rawPath)
+            continue;
+        const normalized = normalizeWorkspacePath(unquoteGitPath(renameTargetPath(rawPath)));
+        if (!normalized)
+            continue;
+        entries.set(normalized, `${x}${y}`);
+    }
+    return entries;
+}
+/**
+ * Return the destination path of a porcelain path field. Rename entries
+ * render as `ORIG -> DEST` where either side may independently be C-quoted;
+ * splitting on a quoted ` -> ` (or unquoting before splitting) corrupts the
+ * key with residual quotes or half-decoded octal. Scan for the last
+ * outside-quote separator instead, then return the still-quoted DEST for
+ * the caller to unquote.
+ */
+function renameTargetPath(rawPath) {
+    let inQuotes = false;
+    let separatorIndex = -1;
+    for (let i = 0; i < rawPath.length - 3; i += 1) {
+        const char = rawPath[i];
+        if (char === "\\") {
+            i += 1; // skip the escaped character; it cannot open/close quotes
+            continue;
+        }
+        if (char === '"')
+            inQuotes = !inQuotes;
+        if (!inQuotes && rawPath.startsWith(" -> ", i))
+            separatorIndex = i;
+    }
+    if (separatorIndex === -1)
+        return rawPath;
+    return rawPath.slice(separatorIndex + 4);
+}
+function normalizeWorkspacePath(value) {
+    const target = value.includes(" -> ")
+        ? (value.split(" -> ").at(-1) ?? value)
+        : value;
+    // Embedded-repo untracked entries render as `dir/`; strip the trailing
+    // slash so the key matches the registered submodule path form.
+    return target.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
+}
+/**
+ * Unquote a git C-quoted path (`"..."` with C-style escapes; non-ASCII bytes
+ * arrive as octal like \346\225\260). Returns the input unchanged when not
+ * quoted. This keeps Chinese/space paths (e.g. `source/需求.md`) comparable
+ * against writeSet patterns.
+ */
+export function unquoteGitPath(value) {
+    if (value.length < 2 || !value.startsWith('"') || !value.endsWith('"')) {
+        return value;
+    }
+    const inner = value.slice(1, -1);
+    let out = "";
+    for (let i = 0; i < inner.length; i += 1) {
+        const char = inner[i];
+        if (char !== "\\") {
+            out += char;
+            continue;
+        }
+        const next = inner[i + 1];
+        if (next === undefined)
+            break;
+        if (next === "n")
+            out += "\n";
+        else if (next === "t")
+            out += "\t";
+        else if (next === "r")
+            out += "\r";
+        else if (next === "\\")
+            out += "\\";
+        else if (next === '"')
+            out += '"';
+        else if (/[0-7]{3}/.test(inner.slice(i + 1, i + 4))) {
+            // Octal byte escape: collect consecutive escapes into one string
+            // and decode as UTF-8. `continue` skips the shared `i += 1` below
+            // (i already points past the consumed run).
+            const bytes = [];
+            let j = i;
+            while (j < inner.length && inner[j] === "\\" && /[0-7]{3}/.test(inner.slice(j + 1, j + 4))) {
+                bytes.push(Number.parseInt(inner.slice(j + 1, j + 4), 8));
+                j += 4;
+            }
+            out += Buffer.from(bytes).toString("utf8");
+            i = j - 1;
+            continue;
+        }
+        else {
+            out += next;
+        }
+        i += 1;
+    }
+    return out;
+}
+/**
+ * Read registered submodule directories from `.gitmodules` via
+ * `git config -f .gitmodules --get-regexp` (structured output; no
+ * shell-quoting hazards). Returns [] when the file is absent or empty.
+ */
+export async function readSubmoduleRegistrations(rootCwd, dependencies = DEFAULT_WORKSPACE_STATUS_DEPENDENCIES) {
+    const result = await dependencies.runGit(rootCwd, [
+        "config",
+        "-f",
+        ".gitmodules",
+        "--get-regexp",
+        "^submodule\\..*\\.path$",
+    ]);
+    // Exit 1 with no stderr = the file exists but has no matching keys.
+    // Any other non-zero exit (unreadable file, parse error) must fail closed:
+    // returning [] would silently drop every submodule from observation.
+    if (result.code === 1 && !result.stderr.trim())
+        return [];
+    if (result.code !== 0) {
+        throw new Error(`git config -f .gitmodules failed (exit ${result.code}): ${result.stderr.trim() || result.stdout.trim() || "no output"}`);
+    }
+    if (!result.stdout.trim())
+        return [];
+    const paths = [];
+    for (const line of result.stdout.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        // Line format: `submodule.<name>.path <value>`. The value may contain
+        // spaces; split on the first space after the key only.
+        const separator = trimmed.indexOf(" ");
+        if (separator <= 0)
+            continue;
+        const submodulePath = trimmed.slice(separator + 1).trim();
+        if (!submodulePath)
+            continue;
+        paths.push(normalizeWorkspacePath(submodulePath));
+    }
+    return paths;
+}
+/**
+ * Probe the gitlink state of one submodule against its parent repository.
+ * Porcelain codes cannot distinguish "dirty content inside the submodule"
+ * (covered by the child's file-level entries) from "the child HEAD actually
+ * moved" (a git mutation the child's own clean status cannot express), so
+ * the relevant SHAs are compared directly.
+ *
+ * Three facts are captured so staged gitlinks and repeated moves cannot
+ * hide a mutation:
+ * - `indexSha`: what the parent index records for the gitlink now.
+ * - `headTreeSha`: what the parent HEAD tree records (detects `git add sub`
+ *   staged after a commit — the working gitlink moved but index == HEAD is
+ *   not the full story; see gitlinkMutated).
+ * - `headSha`: the child's checked-out HEAD.
+ *
+ * `readFailed` maps to the caller's fail-closed incomplete path.
+ */
+async function readGitlinkState(parentRoot, submodulePath, dependencies) {
+    const ls = await dependencies.runGit(parentRoot, [
+        "ls-files",
+        "-s",
+        "--",
+        submodulePath,
+    ]);
+    const line = ls.code !== 0
+        ? undefined
+        : ls.stdout.split("\n").find((entry) => entry.trim());
+    // `160000 <sha> 0\t<path>` for a gitlink entry.
+    const indexSha = line?.split(/\s+/)[1];
+    const headTree = await dependencies.runGit(parentRoot, [
+        "rev-parse",
+        `HEAD:${submodulePath}`,
+    ]);
+    const headTreeSha = headTree.code === 0 ? headTree.stdout.trim() : undefined;
+    const rev = await dependencies.runGit(joinFsPath(parentRoot, submodulePath), ["rev-parse", "HEAD"]);
+    const headSha = rev.code === 0 ? rev.stdout.trim() : undefined;
+    if (ls.code !== 0 || rev.code !== 0) {
+        return {
+            indexSha,
+            headTreeSha,
+            headSha,
+            readFailed: true,
+            errorDetail: `ls-files exit ${ls.code}; rev-parse exit ${rev.code}: ${rev.stderr.trim() || ls.stderr.trim() || "no output"}`,
+        };
+    }
+    return { indexSha, headTreeSha, headSha, readFailed: false };
+}
+/**
+ * A gitlink mutation is any state where the working gitlink (child HEAD)
+ * disagrees with what the parent's committed or staged history expects, or
+ * where the parent index gitlink is itself dirty relative to HEAD:
+ * - child HEAD != index: writer moved the submodule HEAD (committed inside
+ *   the submodule, or checked out another commit).
+ * - index != HEAD tree: the gitlink change was staged (`git add sub`) but
+ *   not committed — still an unauthorized git mutation during a run.
+ * - child HEAD != HEAD tree (index clean): a moved HEAD not yet staged;
+ *   the classic in-submodule commit.
+ * When the parent has never committed the submodule (fresh `submodule add`,
+ *   no `HEAD:<path>`), only the index-vs-child comparison applies.
+ */
+function gitlinkMutated(state) {
+    const { indexSha, headTreeSha, headSha } = state;
+    if (indexSha !== undefined && headSha !== undefined && indexSha !== headSha) {
+        return true;
+    }
+    if (headTreeSha !== undefined &&
+        indexSha !== undefined &&
+        headTreeSha !== indexSha) {
+        return true;
+    }
+    if (headTreeSha !== undefined &&
+        headSha !== undefined &&
+        headTreeSha !== headSha) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Sentinel key for a mutated gitlink. Embeds the observed SHA triple so the
+ * key changes when the gitlink moves again (a constant key would make a
+ * second move on a dirty baseline indistinguishable from no move).
+ */
+function gitlinkSentinelKey(workspacePath, state) {
+    const fingerprint = [state.indexSha, state.headTreeSha, state.headSha]
+        .map((sha) => sha ?? "-")
+        .join("+");
+    return `${GITLINK_SENTINEL_PREFIX}${workspacePath}@${fingerprint}`;
+}
+async function submoduleWorkingTreeInitialized(rootCwd, submodulePath) {
+    try {
+        const info = await lstat(path.resolve(rootCwd, ...submodulePath.split("/"), ".git"));
+        return info.isFile() || info.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function collectSubmoduleEntries(input) {
+    // undefined = collection failed for this submodule (recorded, fail-closed).
+    const repoRoot = joinFsPath(input.rootCwd, input.workspacePath);
+    try {
+        const porcelain = await input.dependencies.readSubmoduleStatus(repoRoot);
+        input.repos.push({
+            repoRelativePath: input.repoWorkspacePath,
+            repoId: input.repoWorkspacePath,
+            state: "clean-status-read",
+            porcelain,
+        });
+        const childEntries = parsePorcelainEntries(porcelain);
+        const expanded = new Map();
+        for (const [childPath, code] of childEntries) {
+            expanded.set(`${input.repoWorkspacePath}/${childPath}`, code);
+        }
+        if (input.depth < MAX_SUBMODULE_DEPTH) {
+            const nestedPaths = await readSubmoduleRegistrations(repoRoot, input.dependencies);
+            for (const nestedPath of nestedPaths) {
+                const nestedWorkspacePath = `${input.repoWorkspacePath}/${nestedPath}`;
+                const initialized = await submoduleWorkingTreeInitialized(repoRoot, nestedPath);
+                if (!initialized) {
+                    input.repos.push({
+                        repoRelativePath: nestedWorkspacePath,
+                        repoId: nestedWorkspacePath,
+                        state: "uninitialized",
+                        porcelain: "",
+                    });
+                    continue;
+                }
+                // Gitlink probe at this nesting level: the parent of `nested` is the
+                // current repository (repoRoot). Same three-SHA semantics as the
+                // top level; a moved nested HEAD surfaces as a SHA-tagged sentinel.
+                const nestedGitlink = await readGitlinkState(repoRoot, nestedPath, input.dependencies);
+                if (nestedGitlink.readFailed) {
+                    input.repos.push({
+                        repoRelativePath: nestedWorkspacePath,
+                        repoId: nestedWorkspacePath,
+                        state: "status-read-failed",
+                        porcelain: "",
+                        errorDetail: `gitlink probe failed: ${nestedGitlink.errorDetail ?? "unknown"}`,
+                    });
+                    continue;
+                }
+                const nestedEntries = await collectSubmoduleEntries({
+                    rootCwd: repoRoot,
+                    workspacePath: nestedPath,
+                    repoWorkspacePath: nestedWorkspacePath,
+                    depth: input.depth + 1,
+                    repos: input.repos,
+                    dependencies: input.dependencies,
+                });
+                if (nestedEntries === undefined) {
+                    // Nested collection failures are recorded in the shared
+                    // repos array with state status-read-failed; completeness
+                    // is derived from those states after the top-level loop.
+                    continue;
+                }
+                for (const [nestedFile, code] of nestedEntries) {
+                    // nestedEntries keys are already full workspace paths
+                    // (prefixed with nestedWorkspacePath).
+                    expanded.set(nestedFile, code);
+                }
+                if (gitlinkMutated(nestedGitlink)) {
+                    expanded.set(gitlinkSentinelKey(nestedWorkspacePath, nestedGitlink), "M ");
+                }
+                // Drop the child's own directory-level entry for the nested
+                // submodule (gitlink ` M nested` or embedded `?? nested/`);
+                // its file facts now come from the nested repository.
+                expanded.delete(`${input.repoWorkspacePath}/${nestedPath}`);
+            }
+        }
+        return expanded;
+    }
+    catch (error) {
+        input.repos.push({
+            repoRelativePath: input.repoWorkspacePath,
+            repoId: input.repoWorkspacePath,
+            state: "status-read-failed",
+            porcelain: "",
+            errorDetail: error instanceof Error ? error.message : String(error),
+        });
+        return undefined;
+    }
+}
+function joinFsPath(root, workspacePath) {
+    return path.resolve(root, ...workspacePath.split("/"));
+}
+/**
+ * Expand a parent porcelain snapshot into workspace file-level facts.
+ * Callers pass the already-captured parent porcelain so the parent bytes are
+ * captured once and reused.
+ */
+export async function expandWorkspaceStatus(input) {
+    const dependencies = input.dependencies ?? DEFAULT_WORKSPACE_STATUS_DEPENDENCIES;
+    const parentEntries = parsePorcelainEntries(input.parentPorcelain);
+    const repos = [
+        {
+            repoRelativePath: "",
+            repoId: "parent",
+            state: "clean-status-read",
+            porcelain: input.parentPorcelain,
+        },
+    ];
+    const entries = new Map();
+    let complete = true;
+    const registrations = input.hasGitmodulesFile
+        ? await readSubmoduleRegistrations(input.rootCwd, dependencies)
+        : [];
+    for (const registration of registrations) {
+        const initialized = await submoduleWorkingTreeInitialized(input.rootCwd, registration);
+        if (!initialized) {
+            repos.push({
+                repoRelativePath: registration,
+                repoId: registration,
+                state: "uninitialized",
+                porcelain: "",
+            });
+            continue;
+        }
+        // Gitlink probe: SHA-compare the parent index gitlink against the
+        // child's checked-out HEAD. Only a real HEAD move (e.g. the writer
+        // committed inside the submodule) becomes a sentinel; dirty child
+        // content stays covered by the child's file-level entries.
+        const gitlink = await readGitlinkState(input.rootCwd, registration, dependencies);
+        if (gitlink.readFailed) {
+            repos.push({
+                repoRelativePath: registration,
+                repoId: registration,
+                state: "status-read-failed",
+                porcelain: "",
+                errorDetail: `gitlink probe failed: ${gitlink.errorDetail ?? "unknown"}`,
+            });
+            complete = false;
+            continue;
+        }
+        const submoduleEntries = await collectSubmoduleEntries({
+            rootCwd: input.rootCwd,
+            workspacePath: registration,
+            repoWorkspacePath: registration,
+            depth: 1,
+            repos,
+            dependencies,
+        });
+        if (submoduleEntries === undefined) {
+            complete = false;
+            continue;
+        }
+        for (const [workspacePath, code] of submoduleEntries) {
+            entries.set(workspacePath, code);
+        }
+        if (gitlinkMutated(gitlink)) {
+            entries.set(gitlinkSentinelKey(registration, gitlink), "M ");
+        }
+    }
+    // Completeness is derived from the recorded repo states: any
+    // status-read-failed repository at any depth (top-level or nested)
+    // makes the observation incomplete, so nested failures bubble up.
+    // (.gitmodules read failures throw and fail the whole observation.)
+    const completeNow = complete &&
+        !repos.some((repo) => repo.state === "status-read-failed");
+    // Parent entries: keep everything except directory-level gitlink entries
+    // of submodules whose own status was read successfully AND whose gitlink
+    // is unchanged. When the parent still reports the submodule as modified
+    // (gitlink differs from the index — the writer committed inside the
+    // submodule, or checked out another commit), keep a sentinel entry so the
+    // change stays visible in the expanded delta instead of silently
+    // vanishing behind the child's clean status. The child's clean file-level
+    // status cannot distinguish "gitlink untouched" from "gitlink moved";
+    // only the parent entry can, so it is preserved whenever non-clean.
+    const expandedRegistrations = new Set(repos
+        .filter((repo) => repo.repoRelativePath !== "" &&
+        repo.state === "clean-status-read")
+        .map((repo) => repo.repoRelativePath));
+    for (const [parentPath, code] of parentEntries) {
+        if (expandedRegistrations.has(parentPath)) {
+            // Directory-level submodule entries are dropped: file-level facts
+            // come from the child repos, and a moved gitlink is surfaced by the
+            // SHA probe as a sentinel during the registration loop. Porcelain
+            // codes cannot distinguish dirty content from a moved HEAD, so no
+            // code-based sentinel may be derived here.
+            continue;
+        }
+        if (entries.has(parentPath))
+            continue; // child facts take precedence
+        entries.set(parentPath, code);
+    }
+    return {
+        parentPorcelain: input.parentPorcelain,
+        entries,
+        repos,
+        complete: completeNow,
+    };
+}
+/** Prefix marking a preserved parent gitlink fact (mutated submodule HEAD). */
+export const GITLINK_SENTINEL_PREFIX = "\u0000gitlink\u0000/";
+/** Serialize expanded entries back into sorted porcelain-v1-shaped lines. */
+export function synthesizeExpandedPorcelain(entries) {
+    const lines = [];
+    for (const [filePath, code] of [...entries.entries()].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) {
+        lines.push(`${code} ${filePath}`);
+    }
+    return lines.join("\n") + (lines.length > 0 ? "\n" : "");
+}
+/** Check for a `.gitmodules` file at the repository root. */
+export async function hasGitmodulesFile(rootCwd) {
+    try {
+        await access(path.resolve(rootCwd, ".gitmodules"));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/shared/path-safety.js

@@ -1,6 +1,7 @@
 import { constants as fsConstants } from "node:fs";
 import { lstat, open, realpath } from "node:fs/promises";
 import path from "node:path";
+import { sameFileIdentity } from "./file-identity.js";
 function assertContained(root, target, label) {
     if (target === root || !target.startsWith(`${root}${path.sep}`)) {
         throw new Error(`${label}: path escapes boundary: ${target}`);
@@ -81,8 +82,7 @@ export async function readFileBoundarySafe(input) {
         if (current.isSymbolicLink() ||
             !current.isFile() ||
             current.nlink !== 1 ||
-            current.dev !== opened.dev ||
-            current.ino !== opened.ino) {
+            !sameFileIdentity(opened, current)) {
             throw new Error(`${input.label}: path changed while opening`);
         }
         return await handle.readFile();

package/dist/shared/wizard-local-telemetry.js

@@ -12,7 +12,8 @@ function deleteHeaderCaseInsensitive(headers, name) {
 }
 function configuredHeader(headers, name) {
     const key = Object.keys(headers ?? {}).find((entry) => entry.toLowerCase() === name.toLowerCase());
-    return key ? headers?.[key] : undefined;
+    const value = key ? headers?.[key] : undefined;
+    return typeof value === "string" ? value : undefined;
 }
 function setStaticHeader(headers, configured, name, defaultValue) {
     deleteHeaderCaseInsensitive(headers, name);