@algosuite/vo-mcp 0.2.0-beta.21 → 0.2.0-beta.23

package/dist/runner-cli.js

@@ -2241,6 +2241,37 @@ var init_spend_cap_shim = __esm({
   }
 });
 
+// ../../scripts/virtual-office/code-runner/installation-token.mjs
+async function fetchInstallationToken({ req, required = false, readOnly = false, repo = null }) {
+  const fail = (reason) => {
+    if (required) throw new Error(`installation-token required: ${reason}`);
+    return null;
+  };
+  try {
+    const res = await req(
+      "POST",
+      "/api/v1/github/installation-token",
+      readOnly ? { scope: "read", ...repo ? { repo } : {} } : {},
+      readOnly ? { timeoutMs: READ_TOKEN_TIMEOUT_MS } : {}
+    );
+    if (!res.ok) return fail(`HTTP ${res.status}`);
+    const json = await res.json();
+    if (!json || !json.token) return fail("missing token");
+    if (readOnly && json.scope !== "read") return fail("control plane did not confirm a read-only grant");
+    return { token: json.token, expiresAt: json.expires_at || null };
+  } catch (err) {
+    if (required) throw err;
+    return null;
+  }
+}
+var READ_TOKEN_TIMEOUT_MS;
+var init_installation_token = __esm({
+  "../../scripts/virtual-office/code-runner/installation-token.mjs"() {
+    "use strict";
+    READ_TOKEN_TIMEOUT_MS = 15e3;
+  }
+});
+
 // src/runner/control-plane-auth-stub.mjs
 var control_plane_auth_stub_exports = {};
 __export(control_plane_auth_stub_exports, {
@@ -2564,37 +2595,9 @@ function createControlPlaneClient({
       const json = await res.json();
       return json?.action || null;
     },
-    /**
-     * Mint a short-lived (~1h), repo-scoped GitHub App installation token for
-     * THIS runner's operator (M3). The control-plane keys the mint on the
-     * authenticated operator (ctx.operator_id), so the token covers only that
-     * operator's installation.
-     *
-     * Returns { token, expiresAt } on success. In legacy/admin mode it returns
-     * null on a miss so the caller may use ambient `gh`. In scoped-operator mode
-     * callers pass `{ required: true }`, which fails closed instead of letting a
-     * missing/mis-scoped installation fall through to the runner machine's `gh`.
-     *
-     * The minted token is only usable for push + PR if the GitHub App grants
-     * BOTH `Contents: write` (git push) AND `Pull requests: write` (gh pr
-     * create) — see docs/vo/github-app-setup-2026-06-18.md. A token missing
-     * either scope fails at push (→ ambient fallback) or at `gh pr create`.
-     */
-    async getInstallationToken({ required = false } = {}) {
-      const fail = (reason) => {
-        if (required) throw new Error(`installation-token required: ${reason}`);
-        return null;
-      };
-      try {
-        const res = await req("POST", "/api/v1/github/installation-token", {});
-        if (!res.ok) return fail(`HTTP ${res.status}`);
-        const json = await res.json();
-        if (!json || !json.token) return fail("missing token");
-        return { token: json.token, expiresAt: json.expires_at || null };
-      } catch (err) {
-        if (required) throw err;
-        return null;
-      }
+    /** Mint a GitHub App installation token — see installation-token.mjs. */
+    async getInstallationToken({ required = false, readOnly = false, repo = null } = {}) {
+      return fetchInstallationToken({ req, required, readOnly, repo });
     },
     /**
      * Read the operator's dispatch-mode config (Fast→Ultracode effort setting).
@@ -2617,6 +2620,7 @@ var cachedFirebaseToken;
 var init_control_plane_client = __esm({
   "../../scripts/virtual-office/code-runner/control-plane-client.mjs"() {
     "use strict";
+    init_installation_token();
     cachedFirebaseToken = null;
   }
 });
@@ -3844,6 +3848,11 @@ function itemText(item) {
   }
   return "";
 }
+function parseCodexVersion(stdout) {
+  if (typeof stdout !== "string") return null;
+  const match = stdout.match(/\b(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)\b/u);
+  return match ? match[1] : null;
+}
 function parseCodexEvent(line) {
   const trimmed = String(line || "").trim();
   if (!trimmed) return null;
@@ -3938,7 +3947,7 @@ var init_codex_runner = __esm({
             ...this.getSpawnOptions({ bin }),
             windowsHide: true,
             timeout: 3e3,
-            stdio: "ignore"
+            encoding: "utf8"
           });
           if (version.error) {
             return { installed: false, authenticated: false, message: `codex not found on PATH: ${version.error.message}` };
@@ -3946,6 +3955,8 @@ var init_codex_runner = __esm({
           if (version.status !== 0) {
             return { installed: true, authenticated: false, message: "codex exists but --version failed (auth unclear)" };
           }
+          const cliVersion = parseCodexVersion(version.stdout);
+          const versionField = cliVersion ? { version: cliVersion } : {};
           const login = this.spawn(bin, ["login", "status"], {
             ...this.getSpawnOptions({ bin }),
             windowsHide: true,
@@ -3960,18 +3971,21 @@ ${login.stderr || ""}`.trim();
               return {
                 installed: true,
                 authenticated: true,
+                ...versionField,
                 message: "codex API key available (no persisted ChatGPT login)"
               };
             }
             return {
               installed: true,
               authenticated: false,
+              ...versionField,
               message: output || login.error?.message || "codex is installed but not logged in"
             };
           }
           return {
             installed: true,
             authenticated: true,
+            ...versionField,
             message: output || "codex login status succeeded"
           };
         } catch (err) {
@@ -6417,12 +6431,23 @@ function resolveAgentClaimContext(provider, defaultAgent) {
 }
 async function collectAgentAvailability({
   agents = listAgents(),
-  runnerFor = (agent) => resolveRunner({ VO_CODE_RUNNER_AGENT: agent }).runner
+  runnerFor = (agent) => resolveRunner({ VO_CODE_RUNNER_AGENT: agent }).runner,
+  probeTimeoutMs = PROBE_TIMEOUT_MS
 } = {}) {
   const probes = agents.map(async (agent) => {
+    const degraded = { agent, installed: false, authenticated: false };
     try {
-      const r = await runnerFor(agent).checkAuth();
-      return { agent, installed: Boolean(r?.installed), authenticated: Boolean(r?.authenticated) };
+      const r = await Promise.race([
+        Promise.resolve().then(() => runnerFor(agent).checkAuth()),
+        new Promise((resolve2) => setTimeout(() => resolve2(null), probeTimeoutMs))
+      ]);
+      if (!r) return degraded;
+      return {
+        agent,
+        installed: Boolean(r?.installed),
+        authenticated: Boolean(r?.authenticated),
+        ...typeof r?.version === "string" && r.version ? { version: r.version } : {}
+      };
     } catch {
       return { agent, installed: false, authenticated: false };
     }
@@ -6438,28 +6463,53 @@ function makeAgentAvailabilityProvider({
 } = {}) {
   let cached2 = null;
   let fetchedAt = 0;
-  let inFlight = false;
+  let inFlight = null;
+  const refresh = () => {
+    if (inFlight) return inFlight;
+    try {
+      inFlight = Promise.resolve(collect()).then((list) => {
+        cached2 = list;
+        fetchedAt = now();
+      }).catch((e) => onError(e)).finally(() => {
+        inFlight = null;
+      });
+    } catch (e) {
+      inFlight = null;
+      onError(e);
+      return Promise.resolve();
+    }
+    return inFlight;
+  };
   return {
     get() {
-      if (!inFlight && now() - fetchedAt >= ttlMs) {
-        inFlight = true;
-        Promise.resolve(collect()).then((list) => {
-          cached2 = list;
-          fetchedAt = now();
-        }).catch((e) => onError(e)).finally(() => {
-          inFlight = false;
-        });
-      }
+      if (!inFlight && now() - fetchedAt >= ttlMs) refresh();
+      return cached2;
+    },
+    /**
+     * Resolve once a probe has actually completed, so the FIRST heartbeat can
+     * report real agents. Without this the daemon heartbeats immediately with
+     * `available_agents: []` (the cache is null until the first probe lands),
+     * and a supervisor activation attestation — which requires the default
+     * agent present, installed AND authenticated — can never be satisfied. The
+     * supervisor then kills and restarts the child forever: observed on
+     * JacksPC 2026-07-25, uptime stuck at 1s across every heartbeat.
+     *
+     * Bounded on purpose: a wedged probe must delay startup, never prevent it.
+     */
+    async ready(timeoutMs = 2e4) {
+      if (Array.isArray(cached2)) return cached2;
+      await Promise.race([refresh(), new Promise((r) => setTimeout(r, timeoutMs))]);
       return cached2;
     }
   };
 }
-var DEFAULT_TTL_MS;
+var DEFAULT_TTL_MS, PROBE_TIMEOUT_MS;
 var init_agent_availability = __esm({
   "../../scripts/virtual-office/code-runner/agent-availability.mjs"() {
     "use strict";
     init_resolve_runner();
     DEFAULT_TTL_MS = 5 * 60 * 1e3;
+    PROBE_TIMEOUT_MS = 1e4;
   }
 });
 
@@ -8823,11 +8873,41 @@ var init_reconnect_backoff = __esm({
   }
 });
 
+// ../../scripts/virtual-office/code-runner/redact-tokens.mjs
+function redactSecrets(text) {
+  if (typeof text !== "string" || text.length === 0) return text;
+  let out = text;
+  for (const [re, mask] of TOKEN_PATTERNS) out = out.replace(re, mask);
+  return out;
+}
+function redactPatch(patch) {
+  if (!patch || typeof patch !== "object") return patch;
+  const out = Array.isArray(patch) ? [...patch] : { ...patch };
+  for (const [k, v] of Object.entries(out)) {
+    if (typeof v === "string") out[k] = redactSecrets(v);
+    else if (v && typeof v === "object") out[k] = redactPatch(v);
+  }
+  return out;
+}
+var TOKEN_PATTERNS;
+var init_redact_tokens = __esm({
+  "../../scripts/virtual-office/code-runner/redact-tokens.mjs"() {
+    "use strict";
+    TOKEN_PATTERNS = [
+      [/\b(?:gh[oprsu]|vocred|npm)_[A-Za-z0-9._-]{10,}\b/gu, "[REDACTED]"],
+      [/\bgithub_pat_[A-Za-z0-9_]{10,}\b/gu, "[REDACTED]"],
+      // Keep the scheme so the line still reads as an auth header, matching
+      // sanitizeMaintenanceDiagnostic's behaviour.
+      [/\bBearer\s+[A-Za-z0-9._~+/-]{10,}=*/giu, "Bearer [REDACTED]"]
+    ];
+  }
+});
+
 // ../../scripts/virtual-office/code-runner/task-helpers.mjs
 function makeSafeProgress(log3) {
   return async (client, id, patch) => {
     try {
-      const r = await client.postProgress(id, patch);
+      const r = await client.postProgress(id, redactPatch(patch));
       if (r && r.terminal) log3(`task ${id} is terminal server-side; stopping updates`);
       return r;
     } catch (err) {
@@ -8853,20 +8933,34 @@ function buildPrBody(task, run, files, { armAutoMerge = false } = {}) {
     "### Prompt",
     "",
     "```",
-    String(task.prompt).slice(0, 2e3),
+    redactSecrets(String(task.prompt)).slice(0, 2e3),
     "```",
     "",
     "### Agent summary",
     "",
-    String(run.summary || "").slice(0, 2e3),
+    redactSecrets(String(run.summary || "")).slice(0, 2e3),
     "",
     "---",
     armAutoMerge ? "_Opened by the AlgoHQ code-runner daemon. After CI passes, the watcher must obtain a durable consensus receipt and merge the exact verified SHA._" : "_Opened by the AlgoHQ code-runner daemon. This PR awaits the verify-before-act gate / operator review \u2014 it is NOT auto-merged._"
   ].filter((l) => l !== "").join("\n");
 }
+async function mintRunnerGithubTokens({ client, taskId, log: log3, repo = null, requirePublish = false }) {
+  const publishToken = (await client.getInstallationToken({ required: requirePublish }))?.token ?? null;
+  let agentReadToken = null;
+  let reason = null;
+  try {
+    agentReadToken = (await client.getInstallationToken({ readOnly: true, repo }))?.token ?? null;
+    if (!agentReadToken) reason = "control plane returned no confirmed read-only grant";
+  } catch (err) {
+    reason = err?.message ?? String(err);
+  }
+  if (!agentReadToken) log3(`task ${taskId}: no GitHub read access for the agent (${reason}); it cannot read a private repo`);
+  return { publishToken, agentReadToken };
+}
 var init_task_helpers = __esm({
   "../../scripts/virtual-office/code-runner/task-helpers.mjs"() {
     "use strict";
+    init_redact_tokens();
   }
 });
 
@@ -8882,8 +8976,12 @@ function safeBaseEnv(env2 = {}) {
   }
   return result;
 }
-function buildAgentProcessEnv(env2, { agent = "agent", runnerId = "vo-runner", taskId = "task" } = {}) {
+function buildAgentProcessEnv(env2, { agent = "agent", runnerId = "vo-runner", taskId = "task", githubReadToken = null } = {}) {
   const base = safeBaseEnv(env2);
+  if (typeof githubReadToken === "string" && githubReadToken) {
+    base.GH_TOKEN = githubReadToken;
+    base.GITHUB_TOKEN = githubReadToken;
+  }
   if (String(env2?.AGENT_ID || "").trim()) return { ...base, AGENT_ID: env2.AGENT_ID };
   const generated = [
     "vo",
@@ -9574,7 +9672,7 @@ async function processOneTask(client, task, cfg) {
     const wt = await Promise.resolve(createFixWorktree("code-task", { source: id.slice(0, 8), repo: task.repo }));
     worktreeName = wt.worktreeName;
     if (!worktreeName || !wt.worktreeDir) throw new Error("worktree isolation failure \u2014 refusing to run in the main tree");
-    const githubToken = (await client.getInstallationToken({ required: cfg.requireGithubAppAuth }))?.token ?? null;
+    const { publishToken: githubToken, agentReadToken: agentGithubReadToken } = await mintRunnerGithubTokens({ client, taskId: id, log: log2, repo: task.repo, requirePublish: cfg.requireGithubAppAuth });
     const parentTask = task.resumed_from ? await client.getTask(task.resumed_from).catch(() => null) : null;
     const continuationRestore = await prepareContinuationBranch(wt.worktreeDir, {
       task,
@@ -9609,7 +9707,7 @@ async function processOneTask(client, task, cfg) {
       model,
       effort: effectiveEffort,
       maxBudgetUsd: effectiveMaxBudgetUsd,
-      env: buildAgentProcessEnv(process.env, { agent: cfg.agent, runnerId: cfg.runnerId, taskId: id }),
+      env: buildAgentProcessEnv(process.env, { agent: cfg.agent, runnerId: cfg.runnerId, taskId: id, githubReadToken: agentGithubReadToken }),
       onProgress: (text) => {
         void safeProgress(client, id, runnerStagePatch("agent_working", text));
       },
@@ -9794,6 +9892,7 @@ async function main({ env: env2 = process.env, once: once2 = false } = {}) {
   const runWatch = makeWatchRunner({ client, log: log2, maxFixAttempts: cfg.watchMaxFix, autoMergeEnabled: cfg.armAutoMerge });
   const watchCoordinator = makeWatchCycleCoordinator({ runWatch, log: log2, intervalMs: cfg.watchIntervalSec * 1e3 });
   const agentAvailability = makeAgentAvailabilityProvider({ onError: (e) => log2(`agent probe failed: ${e.message}`) });
+  await agentAvailability.ready();
   const accountUsage = makeAccountUsageProvider();
   const loopTick = makeLoopTicks({ client, cfg, env: env2, log: log2, getActive: () => active, runnerInstanceId, capacityController, localModelController: createLocalModelRemoteController({ env: env2, log: log2 }), getAgentAvailability: () => agentAvailability.get(), getAccountUsage: () => accountUsage.get() });
   const backoff = makeReconnectBackoff({ baseMs: cfg.pollSec * 1e3, log: log2 });