@proagentstore/cli 0.4.143 → 0.4.145

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

@@ -1,3 +1,4 @@
+import { globMatches, isGlob } from "./path-glob.js";
 import { execFileSync } from "node:child_process";
 import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { relative, resolve, sep } from "node:path";
@@ -331,9 +332,12 @@ export function repoSearch(workDir, opts) {
     const lines = out.split("\n").filter((l) => l !== "");
     if (mode === "path") {
         // 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.
-        const all = 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 };
+        // over the path, which is what "find the file called X" actually means. A `glob` (#1070) is
+        // matched instead, over the WHOLE list, so `total` counts real matches, not the literal's.
+        const glob = (opts.glob ?? "").trim();
+        const useGlob = glob !== "" && isGlob(glob);
+        const all = lines.filter((p) => (useGlob ? globMatches(glob, 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, ...(useGlob ? { glob: true } : {}) };
     }
     const all = lines.map(parseGrepLine).filter((m) => m !== null);
     const perFile = new Map();

package/dist/browser-runner/coding/path-glob.js

@@ -0,0 +1,82 @@
+/**
+ * Glob patterns over repo-relative paths, for `repo_find` (#1070).
+ *
+ * `repo_find` matched its pattern as a plain substring, so `*.test.js` returned NOTHING — no path
+ * contains an asterisk — and an agent concluded a repository with ~90 test files had none. Silent false
+ * negatives are the failure; this is the matcher that ends them.
+ *
+ * Semantics (gitignore/ripgrep-like, case-insensitive like the substring search it extends):
+ *   `*`    any run of characters within ONE path segment (never a `/`)
+ *   `**`   any run across segments; `**` followed by `/` also matches zero folders
+ *   `?`    one character, not `/`
+ *   `[ab]` `[a-z]` `[!ab]`  a character class (`!` negates), never `/`
+ * A pattern WITHOUT a `/` matches any single segment — a file name or a folder name at any depth, a
+ * folder matching taking everything beneath it — so `*.test.js` and `*e2e*` mean what they mean in a
+ * shell or `rg -g`. A pattern WITH a `/` is anchored at the repository root (`src/*.ts`,
+ * `**\/handlers/*.js`); a leading `/` or `./` is accepted and means the same.
+ *
+ * DUPLICATED in `workers/api/src/lib/path-glob.ts`: the cloud filters with it when the runner is too old
+ * to (an old runner ignores `glob`). `workers/api/src/lib/path-glob.parity.test.ts` holds the two equal.
+ */
+/** Does this pattern use glob syntax? A pattern without any is the plain substring search, unchanged. */
+export function isGlob(pattern) {
+    return /[*?[]/.test(pattern);
+}
+function toRegExp(glob) {
+    let re = "";
+    for (let i = 0; i < glob.length; i++) {
+        const c = glob[i];
+        if (c === "*") {
+            if (glob[i + 1] === "*") {
+                i++;
+                if (glob[i + 1] === "/") {
+                    i++;
+                    re += "(?:.*/)?";
+                }
+                else
+                    re += ".*";
+            }
+            else
+                re += "[^/]*";
+        }
+        else if (c === "?")
+            re += "[^/]";
+        else if (c === "[") {
+            const end = glob.indexOf("]", i + 2);
+            if (end === -1) {
+                re += "\\[";
+                continue;
+            }
+            let body = glob.slice(i + 1, end).replace(/[\\^\]]/g, "\\$&");
+            const negate = body.startsWith("!");
+            if (negate)
+                body = body.slice(1);
+            re += `(?!/)[${negate ? "^" : ""}${body}]`;
+            i = end;
+        }
+        else
+            re += c.replace(/[.+^${}()|\\\]/]/g, "\\$&");
+    }
+    return new RegExp(`^${re}$`, "i");
+}
+/** Does `path` (repo-relative, `/`-separated) match `glob`? */
+export function globMatches(glob, path) {
+    const g = glob.trim().replace(/^\.?\/+/, "").replace(/\/+$/, "");
+    if (!g)
+        return false;
+    const re = toRegExp(g);
+    if (g.includes("/"))
+        return re.test(path);
+    return path.split("/").some((segment) => re.test(segment));
+}
+/**
+ * The longest run of literal text a match MUST contain — what an old runner's substring search is given,
+ * so the glob filter then runs over a superset that cannot have dropped a match. `""` when there is none
+ * (`*`, `**`, `???`): nothing literal to search by.
+ */
+export function globLiteral(glob) {
+    // Normalised exactly as `globMatches` normalises, or `./src/*.ts` would ask for "./src", which no path contains.
+    const pieces = glob.trim().replace(/^\.?\/+/, "").split(/\[[^\]]*\]|[*?]+/);
+    const longest = pieces.reduce((a, b) => (b.length > a.length ? b : a), "");
+    return longest.replace(/^\/+|\/+$/g, "");
+}

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

@@ -1,6 +1,7 @@
 import { execFileSync, spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readdirSync, rmSync, statSync } from "node:fs";
 import { join } from "node:path";
+import { RunnerInputError } from "../errors.js";
 /**
  * Inspect a workdir: does it exist, does it hold anything, is it a checkout. Never throws —
  * every failure is a `false`, because this function exists to REPORT a broken path and one that
@@ -175,10 +176,11 @@ export function ensureRepo(dir, opts = {}) {
             // The owner's own folder (a monorepo subfolder, a plain project) — run in it untouched.
             if (opts.ownFolder)
                 return dir;
-            throw new Error(`Refusing to clone into non-empty directory "${dir}" (no .git found) — move it aside or point at an empty path.`);
+            // A refusal about the owner's folder, answered as one (#1116) — never a runner crash.
+            throw new RunnerInputError(`Refusing to clone into non-empty directory "${dir}" (no .git found) — move it aside or point at an empty path.`, 409);
         }
         if (opts.ownFolder && checkWorkdir(dir).insideWorkTree) {
-            throw new Error(`"${dir}" is an empty folder inside another git checkout — not cloning a second repository into it. Point this repo at the checkout itself, or remove the folder.`);
+            throw new RunnerInputError(`"${dir}" is an empty folder inside another git checkout — not cloning a second repository into it. Point this repo at the checkout itself, or remove the folder.`, 409);
         }
         rmSync(dir, { recursive: true, force: true });
     }

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

@@ -314,7 +314,7 @@ export class CodingRuntime {
                 session.interrupt();
                 break;
             default:
-                throw new Error(`Unknown coding action: ${action.kind}`);
+                throw new RunnerInputError(`Unknown coding action: ${action.kind}`);
         }
         return this.snapshot(sessionId);
     }
@@ -472,8 +472,9 @@ export class CodingRuntime {
     }
     require(sessionId) {
         const session = this.sessions.get(sessionId);
+        // A caller naming a session this runner does not hold is a lookup, not a crash (#1116): 404, with the same sentence.
         if (!session)
-            throw new Error(`No coding session: ${sessionId}`);
+            throw new RunnerInputError(`No coding session: ${sessionId}`, 404);
         return session;
     }
 }

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

@@ -1,6 +1,7 @@
 import { execFileSync } from "node:child_process";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
+import { RunnerInputError } from "../errors.js";
 import { capturePane, createSession, killSession, listSessionsDetailed, runCommand as tmuxRunCommand, sendKey as tmuxSendKey, sendText as tmuxSendText, sessionExists, tmuxExec } from "./tmux.js";
 function shellPath() {
     return process.env.SHELL || "/bin/zsh";
@@ -14,7 +15,7 @@ export function splitTerminalTarget(raw, fallback) {
     if (m)
         return { backend: m[1].toLowerCase(), id: m[2].trim() };
     if (!fallback)
-        throw new Error("A target must include a backend prefix like `tmux:main`, or pass `backend` separately.");
+        throw new RunnerInputError("A target must include a backend prefix like `tmux:main`, or pass `backend` separately.");
     return { backend: fallback, id: value };
 }
 export function listTerminalTargets(backend = "all") {
@@ -43,7 +44,7 @@ export function captureTerminalTarget(target, opts = {}) {
     switch (t.backend) {
         case "tmux":
             if (!sessionExists(t.id))
-                throw new Error(`No tmux session "${t.id}".`);
+                throw new RunnerInputError(`No tmux session "${t.id}".`, 404);
             return capturePane(t.id, Math.min(Math.max(Number(opts.lines) || 200, 1), 2000));
         case "kitty":
             return kittyExec(["@", "get-text", "--match", `id:${t.id}`, "--extent", "all"], 5000);
@@ -227,11 +228,11 @@ function kittyForegroundCommand(id) {
 export function runTerminalCommand(target, command, backend) {
     const t = splitTerminalTarget(target, backend);
     if (!command.trim())
-        throw new Error("A `command` is required.");
+        throw new RunnerInputError("A `command` is required.");
     switch (t.backend) {
         case "tmux":
             if (!sessionExists(t.id))
-                throw new Error(`No tmux session "${t.id}".`);
+                throw new RunnerInputError(`No tmux session "${t.id}".`, 404);
             tmuxRunCommand(t.id, command);
             return capturePane(t.id, 200);
         case "kitty":
@@ -246,11 +247,11 @@ export function runTerminalCommand(target, command, backend) {
 export function sendTerminalKeys(target, opts) {
     const t = splitTerminalTarget(target, opts.backend);
     if (opts.text == null && (!opts.keys || opts.keys.length === 0))
-        throw new Error("Provide `text` and/or `keys` to send.");
+        throw new RunnerInputError("Provide `text` and/or `keys` to send.");
     switch (t.backend) {
         case "tmux":
             if (!sessionExists(t.id))
-                throw new Error(`No tmux session "${t.id}".`);
+                throw new RunnerInputError(`No tmux session "${t.id}".`, 404);
             if (opts.text != null)
                 tmuxSendText(t.id, opts.text);
             for (const key of opts.keys ?? [])
@@ -264,7 +265,7 @@ export function sendTerminalKeys(target, opts) {
             return captureTerminalTarget(t.id, { backend: "kitty" });
         case "iterm2":
             if ((opts.keys ?? []).length > 0)
-                throw new Error("iTerm2 generic key events are not supported yet; send text or run a command.");
+                throw new RunnerInputError("iTerm2 generic key events are not supported yet; send text or run a command.");
             itermSessionScript(t.id, `tell theSession to write text ${appleString(opts.text ?? "")}`);
             return captureTerminalTarget(t.id, { backend: "iterm2" });
     }
@@ -275,7 +276,7 @@ export function createTerminalTarget(opts) {
         case "tmux": {
             const name = String(opts.name || "").trim();
             if (!name)
-                throw new Error("A `name` is required for tmux.");
+                throw new RunnerInputError("A `name` is required for tmux.");
             if (sessionExists(name))
                 return { backend: "tmux", id: name, name, existed: true, workDir };
             createSession(name, workDir, opts.command);

package/dist/browser-runner/runner.js

@@ -242,7 +242,7 @@ export class LocalRunner {
     async approveTask(id) {
         const task = this.requireTask(id);
         if (task.status !== "needs_approval") {
-            throw new Error(`Task is not waiting for approval: ${task.status}`);
+            throw new RunnerInputError(`Task is not waiting for approval: ${task.status}`, 409);
         }
         task.status = "queued";
         task.updatedAt = new Date().toISOString();
@@ -662,7 +662,7 @@ export class LocalRunner {
         if (task.type === "browser.open") {
             const url = String(task.input.url || "");
             if (!url || !/^https?:\/\//.test(url)) {
-                throw new Error("browser.open requires an http(s) url");
+                throw new RunnerInputError("browser.open requires an http(s) url");
             }
             const context = await this.getBrowserContext();
             const page = context.pages()[0] || (await context.newPage());
@@ -701,12 +701,12 @@ export class LocalRunner {
             this.addTaskEvent(task, "browser.goto.completed", "Browser page loaded", output);
             return output;
         }
-        throw new Error(`Unknown task type: ${task.type}`);
+        throw new RunnerInputError(`Unknown task type: ${task.type}`);
     }
     requireTask(id) {
         const task = this.store.getTask(id);
         if (!task)
-            throw new Error(`Task not found: ${id}`);
+            throw new RunnerInputError(`Task not found: ${id}`, 404);
         return task;
     }
     async getBrowserContext() {

package/package.json

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