@proagentstore/cli 0.4.41 → 0.4.43

package/dist/browser-runner/coding/engine-acts.js

@@ -94,6 +94,70 @@ function prRef(segment) {
     const num = segment.match(/\bgh\s+pr\s+(?:merge|create)\b(?:\s+-{1,2}\S+(?:=\S+)?)*\s+(\d+)\b/);
     return num ? `#${num[1]}` : null;
 }
+/** A pull request URL anywhere in a command's own output. Anchored on a literal `http` prefix. */
+const PR_URL = /https?:\/\/\S*?\/pull\/(\d+)/;
+/**
+ * Flatten a `tool_result` block's content to text — the RAW result, not the display line.
+ *
+ * `headless.ts`'s `toolResult()` collapses whitespace and truncates to 240 characters for the
+ * transcript, which is right for a human-readable pane and wrong here: `gh pr create` prints its
+ * URL after whatever else the compound command wrote, so the one token that matters is exactly what
+ * a 240-character cap would drop.
+ */
+export function resultText(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((b) => (b && typeof b === "object" && "text" in b ? String(b.text ?? "") : ""))
+            .join("\n");
+    }
+    return "";
+}
+/** An act that names a pull request but does not yet say WHICH one. */
+function wantsPrNumber(act) {
+    return (act.kind === "pr.open" || act.kind === "pr.merge") && act.target === null;
+}
+/**
+ * Fill in the PR number from the command's OWN output, for the acts that lack one (#417).
+ *
+ * `gh pr create --fill` is the common form and carries no number on the command line, so
+ * {@link prRef} returns null and `pull-attribution.ts` leaves the row unbadged. That file states the
+ * rule — **ATTRIBUTION IS EXACT OR ABSENT** — and rejects the tempting repair of pairing an
+ * unnumbered `pr.open` with whichever PR appeared around the same time, because a badge that is
+ * right most of the time is worse than no badge.
+ *
+ * This is not that repair. `gh pr create` prints the new PR's URL on stdout, and that output comes
+ * back as the `tool_result` for the SAME `tool_use_id` as the command that was classified. It is the
+ * command's own answer, in the same class of fact as the `ok` flag already taken from that block —
+ * not a temporal guess about what appeared nearby. When the output names no PR the target stays
+ * null, so absent stays absent.
+ *
+ * Deliberately narrow, because the one failure this module exists to avoid is a confident wrong
+ * number: only `pr.open`/`pr.merge` are eligible, only when their target is still null, and only
+ * against the result correlated to them by `tool_use_id`. A PR URL quoted incidentally in some other
+ * command's output reaches no act.
+ *
+ * **The "already exists" case is decided, not overlooked.** `gh pr create` on a branch that already
+ * has a PR fails with "a pull request for branch X already exists:" and that PR's URL, and this
+ * attributes the act to it. That is a judgement: it IS the pull request for this branch and the
+ * agent did just act on it, and dropping a real signal to avoid a case where the answer is still
+ * true costs more than it saves. The act still carries `ok: false`, so the record remains honest
+ * that the command failed.
+ *
+ * Only reachable from the structured stream-json path. A Codex/Grok raw spawn has no
+ * `tool_use`/`tool_result` framing at all, so its PRs stay unattributed — regexing its transcript
+ * instead would reintroduce exactly the temporal guess this design refuses.
+ */
+export function fillTargetFromResult(acts, content) {
+    if (!acts.some(wantsPrNumber))
+        return acts;
+    const m = resultText(content).match(PR_URL);
+    if (!m)
+        return acts;
+    const target = `#${m[1]}`;
+    return acts.map((a) => (wantsPrNumber(a) ? { ...a, target } : a));
+}
 function pushTarget(segment) {
     // `git push [flags] <remote> <refspec>` — take the first two non-flag words after `push`.
     const after = segment.split(/\bgit\s+push\b/)[1] ?? "";

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

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { classifyCommand, commandFromToolInput } from "./engine-acts.js";
+import { classifyCommand, commandFromToolInput, fillTargetFromResult } from "./engine-acts.js";
 import { parseEngineUsage } from "./engine-usage.js";
 /**
  * Merge the platform's resolved engine env over the machine's, where an EMPTY value means
@@ -604,7 +604,19 @@ export class HeadlessSession {
             return;
         this.awaitingResult.set(toolUseId, acts);
     }
-    /** The matching `tool_result` arrived — stamp the outcome and publish. */
+    /**
+     * The matching `tool_result` arrived — stamp the outcome and publish.
+     *
+     * The result carries more than the outcome: `gh pr create --fill` states its PR number nowhere
+     * but its own stdout, so an unnumbered `pr.open`/`pr.merge` takes it from here (#417). It is read
+     * from the RAW `block.content`, never from `toolResult()`'s display line — that truncates to 240
+     * characters for the transcript and would cut the URL off a verbose result.
+     *
+     * This path (and `noteAct`) is reachable ONLY from the structured stream-json handling above
+     * (`assistant` → `tool_use`, `user` → `tool_result`). A Codex/Grok session is a raw spawn with no
+     * such framing, so its PRs stay unattributed by construction; scraping its transcript instead
+     * would be the temporal guess `pull-attribution.ts` refuses.
+     */
     settleAct(block) {
         const id = typeof block.tool_use_id === "string" ? block.tool_use_id : "";
         const acts = this.awaitingResult.get(id);
@@ -612,7 +624,7 @@ export class HeadlessSession {
             return;
         this.awaitingResult.delete(id);
         const ok = block.is_error !== true;
-        for (const a of acts)
+        for (const a of fillTargetFromResult(acts, block.content))
             this.publishAct({ ...a, ok });
     }
     /** Publish everything still waiting, with an unknown outcome. */

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

@@ -1,15 +1,49 @@
 import { execFileSync } from "node:child_process";
-import { existsSync, mkdirSync, readdirSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, rmSync, statSync } from "node:fs";
 import { join } from "node:path";
 /**
- * Repo/workdir helpers for the coding engine.
- *
- * These lived in `coding/tmux.ts` and have nothing to do with tmux — `ensureRepo` runs `git
- * clone`. The coding engine stopped using tmux when it moved to the structured stream-json
- * interface, so anyone cleaning up that module found its two most load-bearing functions
- * inside it (#247). Split out so the tmux module is only tmux, and only the terminal-operator
- * agents depend on it.
+ * 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
+ * threw would be reported as a broken runner instead.
  */
+export function checkWorkdir(dir) {
+    const absent = { checked: true, path: dir, exists: false, isDirectory: false, entryCount: 0, insideWorkTree: false, gitChecked: true };
+    let isDirectory = false;
+    try {
+        isDirectory = statSync(dir).isDirectory();
+    }
+    catch {
+        return { ...absent };
+    }
+    if (!isDirectory)
+        return { ...absent, exists: true };
+    let entryCount = 0;
+    try {
+        entryCount = readdirSync(dir).length;
+    }
+    catch {
+        // Unreadable (permissions) — reported as empty rather than as a crash; the cloud's
+        // message for "empty" tells the owner to look at the path either way.
+    }
+    let insideWorkTree = false;
+    let gitChecked = true;
+    try {
+        const out = execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+            cwd: dir,
+            encoding: "utf-8",
+            timeout: 10_000,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        insideWorkTree = out.trim() === "true";
+    }
+    catch (e) {
+        // Exit 128 ("not a git repository") is an ANSWER. ENOENT is git missing from PATH, which
+        // is not — and reporting it as "not a checkout" would condemn every repo on that machine.
+        if (e?.code === "ENOENT")
+            gitChecked = false;
+    }
+    return { checked: true, path: dir, exists: true, isDirectory, entryCount, insideWorkTree, gitChecked };
+}
 /**
  * A safe, collision-resistant label derived from an arbitrary string.
  *

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

@@ -2,7 +2,7 @@ import { homedir } from "node:os";
 import { join, resolve } from "node:path";
 import { defaultStatePath, HeadlessSession } from "./headless.js";
 import { InspectError, readGitRemoteOrigin, readRepoFile, repoTree, runRepoGit } from "./inspect.js";
-import { ensureRepo, sanitizeSessionName } from "./repo.js";
+import { checkWorkdir, ensureRepo, sanitizeSessionName } from "./repo.js";
 /** Hard cap on a pane returned to the brain/console (matches the worker MAX_PANE_CHARS). */
 const MAX_PANE = 64 * 1024;
 export class CodingRuntime {
@@ -58,6 +58,16 @@ export class CodingRuntime {
     gitRemote(input) {
         return { remote: readGitRemoteOrigin(this.resolveWorkDir(input)) };
     }
+    /**
+     * Is the configured workdir usable AT ALL — present, non-empty, a checkout (#405)?
+     *
+     * The only endpoint here that answers a question about the PATH rather than about its
+     * contents, and the one the cloud needs before it may call a repo `ready`. Reports the
+     * resolved path so a message can name the thing the owner actually typed, `~` and all.
+     */
+    checkRepo(input) {
+        return checkWorkdir(this.resolveWorkDir(input));
+    }
     static taskTypes() {
         return ["coding.session"];
     }

package/dist/browser-runner/server.js

@@ -232,6 +232,18 @@ async function route(runner, req, res) {
             return json(res, 400, { error: e instanceof Error ? e.message : String(e) });
         }
     }
+    // Does the configured workdir exist / hold files / belong to a checkout (#405)? An older
+    // runner 404s this; the cloud reads the missing `checked:true` as "unverified" and leaves
+    // the repo's status alone rather than condemning it.
+    if (req.method === "POST" && path === "/coding/repo-check") {
+        const b = await readJson(req);
+        try {
+            return json(res, 200, runner.coding.checkRepo(b));
+        }
+        catch (e) {
+            return json(res, 400, { error: e instanceof Error ? e.message : String(e) });
+        }
+    }
     if (req.method === "POST" && path === "/coding/tree") {
         const b = await readJson(req);
         try {

package/package.json

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