@proagentstore/cli 0.4.56 → 0.4.58

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

@@ -1,4 +1,4 @@
-import { execFileSync } from "node:child_process";
+import { execFileSync, spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readdirSync, rmSync, statSync } from "node:fs";
 import { join } from "node:path";
 /**
@@ -72,6 +72,49 @@ export function authenticatedCloneUrl(cloneUrl, token, username) {
     const user = encodeURIComponent(username || "x-access-token");
     return cloneUrl.replace(/^https:\/\//i, `https://${user}:${encodeURIComponent(token)}@`);
 }
+/**
+ * Parse a GitHub SSH welcome banner into an identity name.
+ *
+ * GitHub writes to stderr on a successful `ssh -T git@github.com`:
+ *   `Hi <name>! You've successfully authenticated, but GitHub does not provide shell access.`
+ *
+ * For a deploy key the name is `<org>/<repo>`. For a user account it is the login.
+ * This function is PURE so it can be unit-tested without a network.
+ */
+export function parseSshIdentity(raw) {
+    // The banner arrives on stderr; strip ANSI color/style sequences (`ESC[...m`) that some SSH
+    // versions prepend. The ESC byte is expressed via String.fromCharCode rather than as a literal
+    // in a regex pattern, because Biome's noControlCharactersInRegex rule rejects control characters
+    // in regex literals (same rule that transcript-lines.ts and tmux.ts suppress with biome-ignore).
+    const ESC = String.fromCharCode(27);
+    const clean = raw.split(ESC).join("").replace(/\[[0-9;]*m/g, "").trim();
+    const m = clean.match(/^Hi\s+([^!]+)!/m);
+    return m ? m[1].trim() : null;
+}
+/**
+ * Ask the machine what git identity SSH presents for `host`.
+ *
+ * Uses `BatchMode=yes` so it never prompts for a passphrase, and `ConnectTimeout=5` so a
+ * firewall that drops packets (rather than refusing) does not stall the diagnostics response.
+ * `StrictHostKeyChecking=accept-new` avoids an interactive prompt on first connection.
+ *
+ * Never throws — every failure is an identity of `null`, because this is a transparency probe
+ * and a network hiccup must not make the diagnostics endpoint useless.
+ */
+export function probeGitSshIdentity(host) {
+    // `ssh -T` exits non-zero (1) even on success — GitHub's welcome message deliberately closes
+    // the connection without a shell. `spawnSync` is used rather than `execFileSync` so a non-zero
+    // exit does not throw; the content of stderr is what matters, not the exit code.
+    const result = spawnSync("ssh", ["-T", "-o", "BatchMode=yes", "-o", "StrictHostKeyChecking=accept-new", "-o", "ConnectTimeout=5", `git@${host}`], {
+        encoding: "utf-8",
+        timeout: 10_000,
+    });
+    // stderr carries the welcome message; stdout is empty for a normal `ssh -T`.
+    const raw = String(result.stderr ?? "").slice(0, 500);
+    const identity = parseSshIdentity(raw);
+    const isDeployKey = identity === null ? null : identity.includes("/");
+    return { checked: true, host, identity, isDeployKey, raw };
+}
 /**
  * Ensure a repo is present at `dir`, cloning it from `cloneUrl` if not. Idempotent
  * — an existing checkout is left alone (no clobber). For private repos the cloud

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, repoSearch, repoTree, runRepoGit } from "./inspect.js";
+import { InspectError, readGitRemoteOrigin, readRepoFile, repoSearch, repoSync, repoTree, runRepoGit } from "./inspect.js";
 import { switchRepoBranch } from "./repo-write.js";
 import { checkWorkdir, ensureRepo, sanitizeSessionName } from "./repo.js";
 import { asTurnAuthor } from "./turn-author.js";
@@ -54,7 +54,15 @@ export class CodingRuntime {
     }
     /** Run a whitelisted read-only git command in the session's repo. */
     git(input) {
-        return runRepoGit(this.resolveWorkDir(input), input.cmd, { path: input.path, n: input.n });
+        return runRepoGit(this.resolveWorkDir(input), input.cmd, { path: input.path, n: input.n, ref: input.ref });
+    }
+    /**
+     * Where the checkout stands against its upstream — fetch (cached), then count ahead/behind
+     * (#785). Never pulls. The one endpoint here that reaches the NETWORK, which is why it carries
+     * its own cache and its own no-prompt environment (`inspect.ts`).
+     */
+    sync(input) {
+        return repoSync(this.resolveWorkDir(input), { branch: input.branch, forceFetch: input.forceFetch });
     }
     /**
      * The ONE write the platform may make in a checkout by itself (#322) — put it back on a branch
@@ -117,6 +125,7 @@ export class CodingRuntime {
                 env: input.env,
                 statePath: defaultStatePath(this.reposBaseDir),
                 resumeFrom: input.resumeFrom,
+                seed: input.seed,
                 ghScope: input.ghScope,
                 bin: input.bin,
             });
@@ -126,8 +135,12 @@ export class CodingRuntime {
         // clears its own key on that exit. Reporting after would say "started clean" about a launch
         // that did carry a conversation, and the transcript (which shows the crash) would disagree.
         const resumed = session.resumedConversation;
+        // Read alongside `resumed`, and BEFORE `start()` for the same reason: a bad `--resume` that
+        // kills the process on spawn clears the engine's key, and a seed answer read afterwards would
+        // describe a different launch from the one the caller asked about.
+        const seeded = session.seededConversation;
         session.start();
-        return { ...this.snapshot(input.sessionId), resumed };
+        return { ...this.snapshot(input.sessionId), resumed, seeded };
     }
     /**
      * The pane the brain reasons over + the inferred run state.
@@ -153,6 +166,8 @@ export class CodingRuntime {
             // exactly the question asked about a session that just stopped.
             authResolved: session.authResolved,
             engineRuntime: session.engineRuntime,
+            engineMode: session.engineMode,
+            engineModeWarning: session.engineModeWarning,
             // Reported on EVERY capture, including one where the session is not alive: "how did the
             // last turn end" is exactly the question asked about a session that just stopped, and
             // the omitted-when-null shape keeps "not measured" distinguishable from a verdict.
@@ -247,6 +262,8 @@ export class CodingRuntime {
             takeover: this.takeovers.has(sessionId),
             authResolved: s.authResolved,
             engineRuntime: s.engineRuntime,
+            engineMode: s.engineMode,
+            engineModeWarning: s.engineModeWarning,
             ghGuard: s.ghGuard,
         }));
     }

package/dist/browser-runner/server.js

@@ -1,6 +1,8 @@
 import { createServer, } from "node:http";
 import { URL } from "node:url";
 import { LocalRunner, RunnerInputError } from "./runner.js";
+import { probeGitSshIdentity } from "./coding/repo.js";
+import { listGithubOrgs, listGithubRepos, searchGithubRepos, getGithubRepoDetail, getGithubCredentialScope } from "./coding/github-browse.js";
 export function createRunnerServer(runner) {
     return createServer(async (req, res) => {
         try {
@@ -176,6 +178,95 @@ async function route(runner, req, res) {
         // use tmux, have their own /tmux/* endpoints and are unaffected.
         return json(res, 200, { tracked: runner.coding.diagnostics() });
     }
+    if ((req.method === "GET" || req.method === "POST") && path === "/coding/git-identity") {
+        // Report the SSH identity this machine presents to github.com (#684). Called by
+        // `coding_diagnostics` to surface deploy-key vs user-account mismatches without a
+        // failed clone. Never throws on the runner side — a network hiccup returns identity:null.
+        const b = req.method === "POST" ? await readJson(req).catch(() => ({})) : {};
+        const host = String(b.host || "github.com");
+        return json(res, 200, probeGitSshIdentity(host));
+    }
+    // ── GitHub credential scope (#688) ────────────────────────────────────────
+    // Read-only: reports the authenticated gh login + org memberships. Surfaces
+    // which account and organisations the runner's credentials can reach, before
+    // any browse operation begins. Never writes, never mutates anything on GitHub.
+    if ((req.method === "GET" || req.method === "POST") && path === "/coding/github-credentials") {
+        return json(res, 200, getGithubCredentialScope());
+    }
+    // ── GitHub org + repo enumeration (#685) ──────────────────────────────────
+    // Read-only: lists orgs and repos reachable by the machine's `gh` credentials.
+    // Never writes, never mutates anything on GitHub.
+    if ((req.method === "GET" || req.method === "POST") && path === "/coding/github-orgs") {
+        return json(res, 200, listGithubOrgs());
+    }
+    if ((req.method === "GET" || req.method === "POST") && path === "/coding/github-repos") {
+        const b = req.method === "POST"
+            ? await readJson(req).catch(() => ({}))
+            : {};
+        // Query params override body for GET callers (more REST-idiomatic).
+        const qOwner = url.searchParams.get("owner");
+        const qLimit = url.searchParams.get("limit");
+        const qSince = url.searchParams.get("since");
+        const qVis = url.searchParams.get("visibility");
+        const input = {
+            owner: qOwner ?? b.owner,
+            limit: qLimit ? Number(qLimit) : b.limit,
+            since: qSince ?? b.since,
+            visibility: (qVis === "public" || qVis === "private" || qVis === "all")
+                ? qVis
+                : b.visibility,
+        };
+        return json(res, 200, listGithubRepos(input));
+    }
+    // ── GitHub repository search (#686) ───────────────────────────────────────
+    // Read-only: searches repos reachable by the machine's `gh` credentials via
+    // GitHub's own search API. One API call per query (no per-repo fan-out).
+    // Results are cached in-process for 5 minutes to guard the 30 req/min quota.
+    if ((req.method === "GET" || req.method === "POST") && path === "/coding/github-search") {
+        const b = req.method === "POST"
+            ? await readJson(req).catch(() => ({}))
+            : {};
+        const qQuery = url.searchParams.get("query");
+        const qOwner = url.searchParams.get("owner");
+        const qLang = url.searchParams.get("language");
+        const qTopic = url.searchParams.get("topic");
+        const qPushedAfter = url.searchParams.get("pushedAfter");
+        const qOpenPrs = url.searchParams.get("openPrs");
+        const qLimit = url.searchParams.get("limit");
+        const qSort = url.searchParams.get("sort");
+        const bTyped = b;
+        const input = {
+            query: qQuery ?? bTyped.query,
+            owner: qOwner ?? bTyped.owner,
+            language: qLang ?? bTyped.language,
+            topic: qTopic ?? bTyped.topic,
+            pushedAfter: qPushedAfter ?? bTyped.pushedAfter,
+            openPrs: qOpenPrs !== null ? qOpenPrs === "true" : bTyped.openPrs,
+            limit: qLimit ? Number(qLimit) : bTyped.limit,
+            sort: (qSort === "stars" || qSort === "forks" || qSort === "updated")
+                ? qSort
+                : bTyped.sort,
+        };
+        return json(res, 200, searchGithubRepos(input));
+    }
+    // ── GitHub repository detail (#687) ──────────────────────────────────────
+    // Read-only: fetches issues, PRs, and branches for a given owner/repo slug
+    // via `gh api`. Results are cached in-process for 2 minutes.
+    if ((req.method === "GET" || req.method === "POST") && path === "/coding/github-repo-detail") {
+        const b = req.method === "POST"
+            ? await readJson(req).catch(() => ({}))
+            : {};
+        const bTyped = b;
+        const qRepo = url.searchParams.get("repo");
+        const qLimit = url.searchParams.get("limit");
+        const qState = url.searchParams.get("state");
+        const input = {
+            repo: qRepo ?? bTyped.repo ?? "",
+            limit: qLimit ? Number(qLimit) : bTyped.limit,
+            state: (qState === "all" || qState === "open") ? qState : bTyped.state,
+        };
+        return json(res, 200, getGithubRepoDetail(input));
+    }
     if (req.method === "POST" && path === "/coding/browse") {
         const { readdirSync, statSync } = await import("node:fs");
         const { resolve } = await import("node:path");
@@ -240,6 +331,18 @@ async function route(runner, req, res) {
             return json(res, 400, { error: e instanceof Error ? e.message : String(e) });
         }
     }
+    // Where the checkout stands against its upstream (#785): fetch (cached a minute), then count
+    // ahead/behind. Never pulls. A SEPARATE endpoint for the reason `/coding/search` is one: an
+    // older runner 404s it, which the cloud reads as "unverified" — never as "in sync".
+    if (req.method === "POST" && path === "/coding/sync") {
+        const b = await readJson(req);
+        try {
+            return json(res, 200, runner.coding.sync(b));
+        }
+        catch (e) {
+            return json(res, 400, { error: e instanceof Error ? e.message : String(e) });
+        }
+    }
     // The ONE write surface (#322). A standing policy may put a checkout back on the branch it
     // declared; it may not commit, discard, or touch a remote. An older runner 404s this, which the
     // cloud reports as "asked, not confirmed" rather than as done.

package/package.json

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