@proagentstore/cli 0.4.48 → 0.4.50

package/dist/browser-runner/coding/inspect.js

@@ -44,15 +44,29 @@ export function gitArgv(cmd, opts = {}) {
             // caller can learn a tree is dirty but never which branch it is dirty on, which is how
             // a delegated run pushed a PR branch and left the checkout parked there unnoticed
             // (#276). Additive: every existing consumer keeps the same file lines it always got.
-            return ["status", "--short", "--branch"];
+            //
+            // `path` reaches this one too (#508). Narrowing every command rather than four of the
+            // five is what lets the tool description say "it applies" with no caveat — and a
+            // caveat is what a model has to reason about and can get wrong.
+            return opts.relPath ? ["status", "--short", "--branch", "--", opts.relPath] : ["status", "--short", "--branch"];
+        // `path` used to reach exactly ONE of these five (#508). It is advertised on the tool as
+        // "Limit the command to one file or folder", `runRepoGit` resolves and validates it, and
+        // then four of the five branches dropped it on the floor — so
+        // `repo_git {cmd:"ls-files", path:"admin/lib/features/events"}` answered with every tracked
+        // file in the repository, truncated mid-list at 12KB. `git ls-files -- <path>` is the
+        // file-finder a Repo Coder has been missing, and the parameter to reach it was already in
+        // the schema and already validated; it was dropped one function later.
+        //
+        // Every one of these is git's own `--` pathspec discipline, unchanged: the validated path
+        // is appended after a literal separator and can never be read as a flag or a revision.
         case "diff":
             return opts.relPath ? ["diff", "--", opts.relPath] : ["diff"];
         case "diff-stat":
-            return ["diff", "--stat"];
+            return opts.relPath ? ["diff", "--stat", "--", opts.relPath] : ["diff", "--stat"];
         case "log":
-            return ["log", "--oneline", "-n", String(clampN)];
+            return opts.relPath ? ["log", "--oneline", "-n", String(clampN), "--", opts.relPath] : ["log", "--oneline", "-n", String(clampN)];
         case "ls-files":
-            return ["ls-files"];
+            return opts.relPath ? ["ls-files", "--", opts.relPath] : ["ls-files"];
         default:
             throw new InspectError(`unsupported git command: ${cmd}`);
     }
@@ -86,6 +100,12 @@ export function runRepoGit(workDir, cmd, opts = {}) {
         throw new InspectError("not a git repo");
     const relPath = opts.path ? relative(workDir, resolveInside(workDir, opts.path)) : undefined;
     const argv = gitArgv(cmd, { relPath, n: opts.n });
+    // Did the path the caller asked for actually reach git? Reported rather than assumed, because
+    // a runner is a SEPARATE release from the cloud that calls it: before #508 four of the five
+    // commands ignored `path` silently, and the answer — the whole repository — was indistinguishable
+    // from a correct one. An older runner omits this field entirely, which is what lets the cloud
+    // say "your machine ignored the filter" instead of relaying a wrong answer as a right one.
+    const pathApplied = relPath !== undefined && argv.includes(relPath);
     let out = "";
     try {
         out = execFileSync("git", argv, { cwd: workDir, encoding: "utf-8", timeout: 10_000, maxBuffer: 4 * 1024 * 1024 });
@@ -99,7 +119,7 @@ export function runRepoGit(workDir, cmd, opts = {}) {
     }
     const cap = opts.maxBytes ?? 64 * 1024;
     const truncated = out.length > cap;
-    return { cmd, output: truncated ? out.slice(0, cap) : out, truncated };
+    return { cmd, output: truncated ? out.slice(0, cap) : out, truncated, pathApplied };
 }
 /** Read the repo's `origin` remote URL — used to auto-associate a local checkout with its
  *  GitHub repo (so build status can query Actions). Fixed argv, no shell, no user input;
@@ -120,14 +140,125 @@ export function readGitRemoteOrigin(workDir) {
     }
 }
 const IGNORE_DIRS = new Set(["node_modules", ".git", "dist", "build", ".next", ".turbo", "coverage", ".wrangler"]);
-/** Bounded recursive file tree (names/type/size only — no contents). */
+/**
+ * Search the repo — the capability a Repo Coder never had (#508).
+ *
+ * Before this there was no grep, no filename match, no content match anywhere in the connector or
+ * the runner, so locating a file meant walking the tree by hand and guessing when it ran out.
+ *
+ * ── The bounds, and why each one is here rather than "cap the bytes at the end"
+ *
+ * A byte cap alone just moves the problem into the tool-result cap (#503): the model receives an
+ * arbitrary prefix of a list and no statement that a list was cut. Every bound below is COUNTED,
+ * so the result can say `50 of 812` and the model knows to narrow rather than conclude.
+ *
+ *   MAX_RESULTS   the whole answer, not per file — one number the caller can reason about.
+ *   PER_FILE      git's own `--max-count`, so a minified bundle cannot spend the whole budget.
+ *   MAX_LINE      a matching line from a generated file can be tens of KB on its own.
+ *   maxBuffer     git's stdout is read into memory before any of the above can apply.
+ *
+ * Worst case is ~50 × (path + 160) ≈ 11KB, comfortably inside the 12KB the connector allows and
+ * the 24,000 chars a tool result may carry.
+ *
+ * ── Fixed strings, not regexes
+ *
+ * `-F`. The job is "where does this identifier / filename appear", which is what a model supplies
+ * naturally, and a bare `foo(` — the obvious thing to search for in code — is an invalid regex.
+ * It also means no pattern the model invents can become a pathological match on the owner's own
+ * machine. Deliberate deviation from the argv sketched in #508, which used `-e` alone.
+ *
+ * ── The safety property is unchanged
+ *
+ * `path` is still resolveInside-validated and still appended after a literal `--`. The PATTERN is
+ * never a git token in `path` mode (the filter runs here, in JS) and in `content` mode it is the
+ * fixed operand of `-e`, which git cannot read as a flag whatever it contains.
+ */
+export const SEARCH_MAX_RESULTS = 50;
+const SEARCH_PER_FILE = 5;
+const SEARCH_MAX_LINE = 160;
+const SEARCH_MAX_PATTERN = 200;
+export function repoSearch(workDir, opts) {
+    if (!existsSync(resolve(workDir, ".git")))
+        throw new InspectError("not a git repo");
+    const pattern = (opts.pattern ?? "").trim();
+    if (!pattern)
+        throw new InspectError("a search `pattern` is required");
+    if (pattern.length > SEARCH_MAX_PATTERN)
+        throw new InspectError(`search pattern is too long (max ${SEARCH_MAX_PATTERN} characters)`);
+    const mode = opts.mode === "path" ? "path" : "content";
+    const limit = Math.max(1, Math.min(SEARCH_MAX_RESULTS, Math.floor(opts.maxResults ?? SEARCH_MAX_RESULTS)));
+    const relPath = opts.path ? relative(workDir, resolveInside(workDir, opts.path)) : undefined;
+    const argv = mode === "content"
+        ? ["grep", "-n", "-I", "-i", "-F", "--untracked", "--max-count", String(SEARCH_PER_FILE), "-e", pattern]
+        : // Tracked PLUS untracked-not-ignored: a file created ten minutes ago is exactly the one
+            // somebody is trying to find, and `ls-files` alone would deny it exists.
+            ["ls-files", "--cached", "--others", "--exclude-standard"];
+    // `.` rather than nothing: `git grep` run from a subdirectory would otherwise search the whole
+    // tree, and the caller asked for a folder.
+    if (relPath && relPath !== "")
+        argv.push("--", relPath);
+    let out;
+    try {
+        out = execFileSync("git", argv, { cwd: workDir, encoding: "utf-8", timeout: 15_000, maxBuffer: 4 * 1024 * 1024 });
+    }
+    catch (e) {
+        const err = e;
+        // `git grep` exits 1 for "no matches", which is an ANSWER, not a failure.
+        if (err.status === 1)
+            out = err.stdout ?? "";
+        else if (err.code === "ENOBUFS")
+            throw new InspectError(`too many matches for "${pattern}" to read safely — search a narrower path, or a longer/more specific pattern`);
+        else if (err.stdout)
+            out = err.stdout;
+        else
+            throw new InspectError(err.message || `git ${mode} search failed`);
+    }
+    const lines = out.split("\n").filter((l) => l !== "");
+    const all = mode === "content"
+        ? lines.map(parseGrepLine).filter((m) => m !== null)
+        : // The pattern never reaches git here — the filter is a plain case-insensitive substring
+            // over the path, which is what "find the file called X" actually means.
+            lines.filter((p) => p.toLowerCase().includes(pattern.toLowerCase())).map((p) => ({ path: p }));
+    return { mode, pattern, matches: all.slice(0, limit), shown: Math.min(all.length, limit), total: all.length, truncated: all.length > limit };
+}
+/** `path:line:text` — split on the FIRST two colons only, since code is full of them. */
+function parseGrepLine(line) {
+    const first = line.indexOf(":");
+    if (first <= 0)
+        return null;
+    const second = line.indexOf(":", first + 1);
+    if (second < 0)
+        return null;
+    const n = Number.parseInt(line.slice(first + 1, second), 10);
+    if (!Number.isFinite(n))
+        return null;
+    return { path: line.slice(0, first), line: n, text: line.slice(second + 1).trim().slice(0, SEARCH_MAX_LINE) };
+}
+/** The deepest `maxDepth` this will honour. Named because the TOOL has to say it (#508). */
+export const TREE_MAX_DEPTH = 4;
+/**
+ * Bounded recursive file tree (names/type/size only — no contents).
+ *
+ * Two caps stop it, and until #508 only ONE of them was reported. `truncated` was set by the
+ * ENTRY cap alone; a directory sitting at the depth boundary was emitted as an entry and its
+ * children simply not queued, so it rendered exactly like a directory with nothing in it.
+ *
+ * From the model's side "this folder is empty" and "this folder is deeper than I am allowed to
+ * look" were the same observation, and it cannot navigate on that: asked about a file seven
+ * segments down, it saw a leaf, decided the leaf WAS the file, and called `repo_read_file` on a
+ * directory — twice in the turn that produced this ticket. `deeper` is the per-entry fact that
+ * removes the ambiguity, and it is deliberately "contents not listed" rather than "has more
+ * inside": checking the latter costs a readdir per boundary directory, and the model's next move
+ * (call again with `path`) is the same either way.
+ */
 export function repoTree(workDir, relPath = ".", maxDepth = 3, maxEntries = 500) {
     const start = resolveInside(workDir, relPath, { checkSymlink: true });
-    const depthCap = Math.max(1, Math.min(4, maxDepth));
+    const depthCap = Math.max(1, Math.min(TREE_MAX_DEPTH, maxDepth));
     const entryCap = Math.max(1, Math.min(1000, maxEntries));
     const entries = [];
     const queue = [{ dir: start, depth: 0 }];
     let truncated = false;
+    let truncatedByDepth = false;
     while (queue.length) {
         const { dir, depth } = queue.shift();
         let items;
@@ -142,24 +273,36 @@ export function repoTree(workDir, relPath = ".", maxDepth = 3, maxEntries = 500)
                 continue;
             if (entries.length >= entryCap) {
                 truncated = true;
-                return { root: relPath, entries, truncated };
+                return { root: relPath, entries, truncated, truncatedByDepth, depthCap };
             }
             const abs = resolve(dir, it.name);
             const rel = relative(workDir, abs);
             if (it.isDirectory()) {
-                entries.push({ path: rel, type: "dir" });
-                if (depth + 1 < depthCap)
+                const walk = depth + 1 < depthCap;
+                entries.push(walk ? { path: rel, type: "dir" } : { path: rel, type: "dir", deeper: true });
+                if (walk)
                     queue.push({ dir: abs, depth: depth + 1 });
+                else
+                    truncatedByDepth = true;
             }
             else if (it.isFile()) {
                 let size;
                 try {
                     size = statSync(abs).size;
                 }
-                catch { }
+                catch {
+                    // Benign, and traced rather than assumed (#291). `size` stays `undefined`, which JSON
+                    // drops, so the entry reaches the model as `{path, type: "file"}` — the same listing a
+                    // successful stat produces, because `repo-local.ts`'s renderer prints `e.path` and has
+                    // never shown a size at all. The test is whether the fallback can be mistaken for a
+                    // real answer: `size: 0` would be a claim about an empty file; an absent field is not
+                    // a claim. The entry itself is still emitted because `readdir` saw it, and the one
+                    // case where that is already stale — deleted between the readdir and this stat —
+                    // degrades into an honest error from `repo_read_file`, not into a wrong listing.
+                }
                 entries.push({ path: rel, type: "file", size });
             }
         }
     }
-    return { root: relPath, entries, truncated };
+    return { root: relPath, entries, truncated, truncatedByDepth, depthCap };
 }

package/dist/browser-runner/coding/repo-write.js

@@ -119,10 +119,18 @@ export function switchRepoBranch(workDir, branch) {
     // CONFIRM, do not assume. The exit code says the command ran; only reading HEAD back says where
     // the checkout actually is, and that is the only thing the cloud is allowed to report as done.
     const after = currentBranch(workDir);
-    let dirtyAfter = false;
+    // And the same rule for the tree: `null` when git would not answer, never `false`. Nothing in
+    // the cloud reads this field today — `repo-policy-act.ts` acts on `refused`, `error` and its own
+    // independent read — so this is prophylactic rather than a live defect, and it is recorded that
+    // way. What makes it worth changing anyway is that the value is a CLAIM and the next reader
+    // inherits it: `dirty: false` off a failed `git status` says "clean" in the one field whose
+    // whole job is to say whether anything came across. Absent is degraded; manufactured is wrong.
+    let dirtyAfter;
     try {
         dirtyAfter = isDirty(workDir);
     }
-    catch { }
+    catch {
+        dirtyAfter = null;
+    }
     return { ok: after === to, changed: after === to, from, to, branch: after, dirty: dirtyAfter };
 }

package/dist/browser-runner/coding/runtime.js

@@ -2,7 +2,7 @@ import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { RunnerInputError } from "../errors.js";
 import { defaultStatePath, HeadlessSession } from "./headless.js";
-import { InspectError, readGitRemoteOrigin, readRepoFile, repoTree, runRepoGit } from "./inspect.js";
+import { InspectError, readGitRemoteOrigin, readRepoFile, repoSearch, repoTree, runRepoGit } from "./inspect.js";
 import { switchRepoBranch } from "./repo-write.js";
 import { checkWorkdir, ensureRepo, sanitizeSessionName } from "./repo.js";
 /** Hard cap on a pane returned to the brain/console (matches the worker MAX_PANE_CHARS). */
@@ -65,6 +65,16 @@ export class CodingRuntime {
             throw new InspectError(`unsupported git write command: ${String(input.cmd)}`);
         return switchRepoBranch(this.resolveWorkDir(input), input.branch);
     }
+    /**
+     * Find something in the repo — by file CONTENT or by file NAME (#508).
+     *
+     * The one capability the read-only inspection surface never had. Without it, locating a file
+     * meant walking `tree` by hand, and a path deeper than the tree's four-level cap was not
+     * reachable in any number of calls that did not already know the answer.
+     */
+    search(input) {
+        return repoSearch(this.resolveWorkDir(input), input);
+    }
     /** Bounded recursive file tree of the session's repo (names/type/size only). */
     tree(input) {
         return repoTree(this.resolveWorkDir(input), input.path, input.maxDepth, input.maxEntries);
@@ -177,6 +187,17 @@ export class CodingRuntime {
      * turn of a session very often runs after the final capture poll, and ending is where that
      * record would otherwise be lost — silently, and only for the turns at the end of every
      * session, which is a bias rather than noise.
+     *
+     * …and, since #554, WHO PAID for it. The spend was already returned here; the observation that
+     * makes it attributable was one field away on the session object in hand, so every closing turn
+     * of every session reached the ledger with `payer` NULL even when the credential was known. The
+     * bias is the same one the paragraph above describes, which is why the omission mattered: it
+     * did not lose a random sample of turns, it lost the last turn of every session.
+     *
+     * `null` is a REAL answer here, not a default. `end()` tolerates a `sessionId` it has never
+     * heard of, and the honest report for a session this runner does not have is that it cannot say
+     * what the engine authenticated with — not a guess derived from the preset (see
+     * `usage-payer.ts`, and the alternative #554 rejected).
      */
     end(sessionId) {
         const session = this.sessions.get(sessionId);
@@ -186,12 +207,16 @@ export class CodingRuntime {
         // happens after the final capture poll. Discarding the tail would systematically lose exactly
         // the acts this record exists for.
         const acts = session ? session.takeActs() : [];
+        // Read BEFORE `stop()`: `authResolved` is a live getter over the merged spawn env
+        // (`headless.ts`), so it must be taken while the session is still the object that spawned
+        // the process rather than after it has been torn down and dropped from the map.
+        const authResolved = session ? session.authResolved : null;
         if (session) {
             session.stop();
             this.sessions.delete(sessionId);
         }
         this.takeovers.delete(sessionId);
-        return { ok: true, usage, acts };
+        return { ok: true, usage, acts, authResolved };
     }
     list() {
         return [...this.sessions.entries()].map(([sessionId, s]) => ({

package/dist/browser-runner/server.js

@@ -214,6 +214,19 @@ async function route(runner, req, res) {
             return json(res, 400, { error: e instanceof Error ? e.message : String(e) });
         }
     }
+    // Find a file by content or by name (#508). A SEPARATE endpoint rather than another `/coding/git`
+    // command on purpose: an older runner answers an unknown path with a 404, which the cloud reads
+    // unambiguously as "this machine is too old" — an unknown `cmd` would arrive as a 400 that reads
+    // identically to a real search failure.
+    if (req.method === "POST" && path === "/coding/search") {
+        const b = await readJson(req);
+        try {
+            return json(res, 200, runner.coding.search(b));
+        }
+        catch (e) {
+            return json(res, 400, { error: e instanceof Error ? e.message : String(e) });
+        }
+    }
     if (req.method === "POST" && path === "/coding/git") {
         const b = await readJson(req);
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proagentstore/cli",
-  "version": "0.4.48",
+  "version": "0.4.50",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",