@bridge_gpt/mcp-server 0.2.51 → 0.2.52

package/build/executor/worker-log.js

@@ -26,11 +26,39 @@ export function buildWorkerLogPath(worktreePath, platform = process.platform) {
 export function renderWorkerLogChunk(chunk, _stream = "stdout") {
     return chunk;
 }
+/**
+ * True for a Node-`fs`-shaped "does not exist" rejection (`code: "ENOENT"`).
+ * The normal, expected outcome of probing a first-ever attempt's log path —
+ * never itself a reason to warn.
+ */
+function isMissingFileError(err) {
+    return typeof err === "object" && err !== null && err.code === "ENOENT";
+}
+/**
+ * The bounded, secret-free archive-preservation warning (BAPI-1021, AC-6).
+ * Carries ONLY the stable category and the current/archive path identifiers —
+ * never the caught exception's message or stack. Emitted at most once per tee
+ * creation, whether the existence probe or the rename itself failed.
+ */
+export function formatWorkerLogArchivePreservationWarning(currentLogPath, archivePath) {
+    return archivePath
+        ? `worker log archive: could not preserve the prior attempt's log ` +
+            `(${currentLogPath} -> ${archivePath}); the new attempt continues.`
+        : `worker log archive: could not confirm whether a prior attempt's log exists ` +
+            `at ${currentLogPath}; the new attempt continues.`;
+}
 /**
  * Create the `.conductor` directory, initialize an empty `worker.log`, and return
  * a tee handle. When an `appendFile` boundary is supplied, chunks are appended
  * incrementally; otherwise a buffered fallback re-writes the accumulated content
  * via `writeFile` so all consumed chunks are preserved in order.
+ *
+ * BAPI-1021 (AC-6): before writing the new empty log, archives any PRIOR
+ * attempt's log under a timestamped filename in the same directory — so a
+ * retried job in the same worktree does not silently overwrite what the
+ * previous attempt wrote. Best-effort throughout: a missing prior log is the
+ * normal first-attempt case (no warning); a probe or rename failure degrades
+ * to exactly one bounded warning and tee creation still proceeds.
  */
 export async function createWorkerLogTee(worktreePath, deps) {
     const platform = deps.platform ?? process.platform;
@@ -38,7 +66,35 @@ export async function createWorkerLogTee(worktreePath, deps) {
     const dir = pathApi.join(worktreePath, CONDUCTOR_WORKER_LOG_DIR);
     const logPath = pathApi.join(dir, CONDUCTOR_WORKER_LOG_FILE);
     await deps.mkdir(dir, { recursive: true });
+    if (deps.stat && deps.rename) {
+        try {
+            await deps.stat(logPath);
+        }
+        catch (err) {
+            if (!isMissingFileError(err)) {
+                deps.errorLog?.(formatWorkerLogArchivePreservationWarning(logPath));
+            }
+            // Missing (or unconfirmable) is the normal first-attempt case either
+            // way: fall through to the truncating write below without a rename.
+            await deps.writeFile(logPath, "");
+            return createTeeHandle(logPath, deps);
+        }
+        // The current log exists: archive it before truncating.
+        const clock = deps.now ?? Date.now;
+        const timestamp = new Date(clock()).toISOString().replace(/:/g, "-");
+        const archivePath = pathApi.join(dir, `worker.${timestamp}.log`);
+        try {
+            await deps.rename(logPath, archivePath);
+        }
+        catch {
+            deps.errorLog?.(formatWorkerLogArchivePreservationWarning(logPath, archivePath));
+        }
+    }
     await deps.writeFile(logPath, "");
+    return createTeeHandle(logPath, deps);
+}
+/** Shared tee-handle construction, used by every `createWorkerLogTee` return path. */
+function createTeeHandle(logPath, deps) {
     let buffer = "";
     let closed = false;
     return {

package/build/executor/worktree.js

@@ -126,6 +126,17 @@ async function resolveCommitSha(deps, worktreeCwd, ref) {
  * `policy.reuseExistingBranch` selects between the two supported modes (see
  * {@link EnsureExecutorWorktreePolicy}); it defaults to the fresh-off-base,
  * F7-guarded behavior so callers that omit it are unchanged.
+ *
+ * BAPI-1019 — DO NOT provide operator environment files here. The interactive
+ * path (`createWorktrees` in `../start-tickets.ts`) calls `linkOperatorEnvFiles`
+ * after creating a worktree, because a human working in one needs `.env`. An
+ * EXECUTOR worktree must hold neither a copy nor a link: a link resolves to the
+ * operator's real `.env` exactly as a copy did, which is how Architecture Miss 28
+ * reached a live database. The executor's worktree is instead STRIPPED of
+ * `.env*` immediately before spawn (`env-file-guard.ts`), and the spawn is
+ * refused if that cannot be confirmed. Reusing the interactive linker at this
+ * seam — for symmetry, or to "fix" a worker that wants configuration — would
+ * reintroduce the miss.
  */
 export async function ensureExecutorWorktree(job, options, deps, policy = {}) {
     const branchResult = resolveExecutorBranch(job);

package/build/git-reachability.js

@@ -0,0 +1,147 @@
+/**
+ * Working-tree git trackedness oracle (BAPI-1027 / R10).
+ *
+ * The server-side plan linter owns the RULE — "a cited document that is not
+ * tracked is absent from the executor's worktree, so the citation resolves to
+ * nothing" — but it cannot own the FACT: the API server has no working tree.
+ * This helper supplies the fact and nothing else. It answers exactly one
+ * question, for exactly the paths it is handed:
+ *
+ *     is this repository-relative path tracked in git?
+ *
+ * It deliberately contains NO lint logic. It does not extract citations from a
+ * plan, decide whether a path is documentation, assign a reason code, or
+ * reproduce any Python rule. Keeping the rule in one place and the git access in
+ * another is what lets the linter and A1b's R55 compiler share one rule set while
+ * each supplies its own oracle — the catalog's R-2 non-divergence constraint.
+ *
+ * Git runs through an injected argument-array seam modeled on
+ * `GitIgnoreRunCommand`/`GitIgnoreDeps` in `git-ignore-utils.ts`, so this is
+ * unit-testable without a real repository and can never be shell-interpolated.
+ */
+/** Max paths resolved in one invocation; mirrors the server's evidence bound. */
+export const TRACKED_PATH_REQUEST_MAX_COUNT = 500;
+/**
+ * Normalize one declared path exactly as the server's shared rules do.
+ *
+ * Mirrors `normalize_repo_relative_path` in `api/library/plan_lint_rules.py`:
+ * trim, `\` -> `/`, strip a single leading `./`. The two runtimes MUST agree on
+ * what makes two paths the same path — this helper answers questions about paths
+ * the server named, and a helper with its own notion of identity would answer
+ * about a different path than the one that was asked about.
+ *
+ * A genuinely unsafe path is REFUSED, never rewritten into a safe-looking one:
+ * silently normalizing `../../etc/passwd` would attribute an answer to a path the
+ * caller never asked about. A redundant `./` prefix is not that — it denotes the
+ * same path, and the server strips it too.
+ */
+export function normalizeRepoRelativePath(path) {
+    if (typeof path !== "string" || path.trim() === "") {
+        return { ok: false, reason: "must be a non-empty string" };
+    }
+    const candidate = path.trim();
+    if (candidate.includes("\0")) {
+        return { ok: false, reason: "must not contain a NUL character" };
+    }
+    let normalized = candidate.replace(/\\/g, "/");
+    if (normalized.startsWith("./"))
+        normalized = normalized.slice(2);
+    if (normalized === "") {
+        return { ok: false, reason: "must be a non-empty repository-relative path" };
+    }
+    if (normalized.startsWith("/")) {
+        return { ok: false, reason: "must be repository-relative, not absolute" };
+    }
+    if (normalized.length >= 2 && normalized[1] === ":") {
+        return { ok: false, reason: "must be repository-relative, not a drive-qualified path" };
+    }
+    if (normalized === ".." ||
+        normalized.startsWith("../") ||
+        normalized.includes("/../")) {
+        return { ok: false, reason: "must not contain a relative path segment" };
+    }
+    return { ok: true, path: normalized };
+}
+/**
+ * Reject a path this helper must not hand to git.
+ *
+ * Returns a human-readable reason, or `null` when the path is acceptable. Thin
+ * wrapper over {@link normalizeRepoRelativePath} for callers that only need the
+ * verdict.
+ */
+export function rejectUnsafeRepoRelativePath(path) {
+    const result = normalizeRepoRelativePath(path);
+    return result.ok ? null : result.reason;
+}
+/**
+ * Resolve git trackedness for `paths` inside the working tree at `cwd`.
+ *
+ * `git ls-files` lists only the paths it considers TRACKED, so the answer is a
+ * set difference: a requested path git echoes back is tracked, and one it omits
+ * is not. `-z` makes the output NUL-delimited so a filename containing a newline
+ * cannot desynchronize parsing, `--full-name` makes every emitted path
+ * repository-root-relative regardless of `cwd`, and `--` terminates option
+ * parsing so a path beginning with `-` is never read as a flag.
+ *
+ * Every path is validated BEFORE the command runs; one bad path fails the whole
+ * call rather than being dropped, because a silently skipped path would come back
+ * as "no evidence" and read as an incomplete check rather than an authoring error.
+ */
+export async function resolveTrackedPaths(cwd, paths, deps) {
+    if (!Array.isArray(paths)) {
+        return { ok: false, error: "paths must be an array of repository-relative strings." };
+    }
+    // Deduplicate while preserving the caller's order, so one path asked for twice
+    // costs one argument and yields one fact.
+    const requested = [];
+    const seen = new Set();
+    for (const raw of paths) {
+        const normalization = normalizeRepoRelativePath(raw);
+        if (!normalization.ok) {
+            return {
+                ok: false,
+                error: `Cited document path ${JSON.stringify(raw)} ${normalization.reason}.`,
+            };
+        }
+        if (seen.has(normalization.path))
+            continue;
+        seen.add(normalization.path);
+        requested.push(normalization.path);
+    }
+    if (requested.length === 0)
+        return { ok: true, facts: [] };
+    if (requested.length > TRACKED_PATH_REQUEST_MAX_COUNT) {
+        return {
+            ok: false,
+            error: `Refusing to resolve ${requested.length} cited document paths; the limit ` +
+                `is ${TRACKED_PATH_REQUEST_MAX_COUNT}.`,
+        };
+    }
+    let result;
+    try {
+        result = await deps.runCommand("git", ["ls-files", "-z", "--full-name", "--", ...requested], { cwd });
+    }
+    catch (err) {
+        return {
+            ok: false,
+            error: `git ls-files could not be run: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    if (!result || typeof result.exitCode !== "number" || typeof result.stdout !== "string") {
+        return { ok: false, error: "git ls-files returned an unreadable result." };
+    }
+    if (result.exitCode !== 0) {
+        // Reported as an inability to check, with git's own stderr for diagnosis —
+        // never as "all of these are untracked".
+        const detail = (result.stderr || "").trim();
+        return {
+            ok: false,
+            error: `git ls-files exited ${result.exitCode}${detail ? `: ${detail}` : ""}`,
+        };
+    }
+    const trackedSet = new Set(result.stdout.split("\0").filter((entry) => entry !== ""));
+    return {
+        ok: true,
+        facts: requested.map((path) => ({ path, tracked: trackedSet.has(path) })),
+    };
+}