@algosuite/vo-mcp 0.2.0-beta.73 → 0.2.0-beta.74

package/dist/runner-cli.js

@@ -314,21 +314,21 @@ function backupConfigOnce(configPath) {
   copyFileSync(configPath, backupPath);
   return backupPath;
 }
-function writeFileAtomic(path24, content) {
-  sweepStaleTempFiles(path24);
-  const temp = `${path24}.vo-mcp-tmp-${process.pid}-${Date.now()}`;
+function writeFileAtomic(path25, content) {
+  sweepStaleTempFiles(path25);
+  const temp = `${path25}.vo-mcp-tmp-${process.pid}-${Date.now()}`;
   try {
     writeFileSync2(temp, content, { encoding: "utf8", mode: 384 });
-    if (existsSync3(path24)) {
+    if (existsSync3(path25)) {
       try {
-        chmodSync2(temp, statSync(path24).mode & 511);
+        chmodSync2(temp, statSync(path25).mode & 511);
       } catch {
       }
     }
     let lastErr = null;
     for (let attempt = 0; attempt < RENAME_RETRIES; attempt += 1) {
       try {
-        renameSync(temp, path24);
+        renameSync(temp, path25);
         return;
       } catch (err) {
         lastErr = err;
@@ -337,7 +337,7 @@ function writeFileAtomic(path24, content) {
         sleepSync(RENAME_RETRY_MS);
       }
     }
-    writeFileSync2(path24, content, "utf8");
+    writeFileSync2(path25, content, "utf8");
     try {
       unlinkSync2(temp);
     } catch {
@@ -503,8 +503,8 @@ function tablePath(line) {
 function tableSections(lines) {
   const starts = [];
   for (let index = 0; index < lines.length; index += 1) {
-    const path24 = tablePath(lines[index] ?? "");
-    if (path24) starts.push({ path: path24, start: index });
+    const path25 = tablePath(lines[index] ?? "");
+    if (path25) starts.push({ path: path25, start: index });
   }
   return starts.map((section, index) => ({
     ...section,
@@ -696,11 +696,11 @@ function resolveLinuxConfigHome(home, env2) {
   const configured = env2["XDG_CONFIG_HOME"]?.trim();
   return configured && isAbsolute2(configured) ? configured : join5(home, ".config");
 }
-function launcherIsCurrent(path24, desiredContent, label, log2) {
-  if (!existsSync6(path24)) return false;
-  if (readFileSync5(path24, "utf8") === desiredContent) return true;
-  const backupPath = `${path24}.backup-${Date.now()}`;
-  copyFileSync2(path24, backupPath);
+function launcherIsCurrent(path25, desiredContent, label, log2) {
+  if (!existsSync6(path25)) return false;
+  if (readFileSync5(path25, "utf8") === desiredContent) return true;
+  const backupPath = `${path25}.backup-${Date.now()}`;
+  copyFileSync2(path25, backupPath);
   log2(`  Backed up existing ${label} to: ${backupPath}`);
   return false;
 }
@@ -916,17 +916,17 @@ function resolveDesktopConfigPath(home, plat, appData) {
   }
   return join6(home, ".config", "Claude", "claude_desktop_config.json");
 }
-function readClaudeConfig(path24) {
-  if (!existsSync7(path24)) return { kind: "absent", config: {}, mtimeMs: null };
+function readClaudeConfig(path25) {
+  if (!existsSync7(path25)) return { kind: "absent", config: {}, mtimeMs: null };
   for (let attempt = 0; attempt < 3; attempt += 1) {
-    const before = statSync3(path24).mtimeMs;
+    const before = statSync3(path25).mtimeMs;
     let raw;
     try {
-      raw = readFileSync6(path24, "utf8");
+      raw = readFileSync6(path25, "utf8");
     } catch {
       return { kind: "invalid", config: {}, mtimeMs: before };
     }
-    if (!existsSync7(path24) || statSync3(path24).mtimeMs !== before) continue;
+    if (!existsSync7(path25) || statSync3(path25).mtimeMs !== before) continue;
     const text = raw.replace(/^\uFEFF/u, "");
     if (!text.trim()) return { kind: "empty", config: {}, mtimeMs: before };
     try {
@@ -938,9 +938,9 @@ function readClaudeConfig(path24) {
   }
   return { kind: "invalid", config: {}, mtimeMs: null };
 }
-function writeClaudeConfig(path24, config) {
-  mkdirSync6(dirname4(path24), { recursive: true });
-  writeFileAtomic(path24, `${JSON.stringify(config, null, 2)}
+function writeClaudeConfig(path25, config) {
+  mkdirSync6(dirname4(path25), { recursive: true });
+  writeFileAtomic(path25, `${JSON.stringify(config, null, 2)}
 `);
 }
 function carriedEntryKeys(entry) {
@@ -4250,13 +4250,13 @@ async function getTaskKnowledgeContextRequest(req, taskId, { query, knowledgeReq
   const canonicalQuery = canonicalizeKnowledgeContextQuery(query);
   if (canonicalQuery.trim()) body.query = canonicalQuery;
   if (typeof knowledgeRequestId === "string" && knowledgeRequestId) body.knowledge_request_id = knowledgeRequestId;
-  const path24 = `/api/v1/code-task/${encodeURIComponent(taskId)}/knowledge-context`;
+  const path25 = `/api/v1/code-task/${encodeURIComponent(taskId)}/knowledge-context`;
   const timeoutMs = Math.max(Number(taskRequestTimeoutMs) || 0, MIN_KNOWLEDGE_CONTEXT_TIMEOUT_MS);
   for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt += 1) {
     let res;
     let cause;
     try {
-      res = await req("POST", path24, body, { timeoutMs });
+      res = await req("POST", path25, body, { timeoutMs });
     } catch (err) {
       cause = err;
     }
@@ -4324,10 +4324,10 @@ async function getPreparedJobRequest(req, taskId, options = {}, invalidateToken
   if (typeof taskId !== "string" || taskId.length === 0) {
     return { ok: false, reason: "missing_task_id", status: 0, ...envMeta };
   }
-  const path24 = `/api/v1/code-task/${encodeURIComponent(taskId)}/prepared-job?${query}`;
+  const path25 = `/api/v1/code-task/${encodeURIComponent(taskId)}/prepared-job?${query}`;
   let res;
   try {
-    res = await req("GET", path24, void 0, { timeoutMs });
+    res = await req("GET", path25, void 0, { timeoutMs });
   } catch (err) {
     return { ok: false, reason: `transport: ${err?.message || String(err)}`, status: 0, ...envMeta };
   }
@@ -4427,11 +4427,11 @@ function createControlPlaneClient({
   if (!resolvedBaseUrl) throw new Error("VO_CONTROL_PLANE_URL is required for the code-runner daemon");
   const root = resolvedBaseUrl.replace(/\/+$/, "");
   const claimOccurrences = /* @__PURE__ */ new Map();
-  async function req(method, path24, body, { timeoutMs } = {}) {
+  async function req(method, path25, body, { timeoutMs } = {}) {
     const bearer = await resolveBearer(env2);
     const controller = timeoutMs ? new AbortController() : null;
     let timeoutId;
-    const request = Promise.resolve(fetchImpl(`${root}${path24}`, {
+    const request = Promise.resolve(fetchImpl(`${root}${path25}`, {
       method,
       headers: {
         "content-type": "application/json",
@@ -4444,7 +4444,7 @@ function createControlPlaneClient({
     const timeout = new Promise((_, reject) => {
       timeoutId = setTimeout(() => {
         controller.abort();
-        reject(new Error(`control-plane ${path24} timed out after ${timeoutMs}ms`));
+        reject(new Error(`control-plane ${path25} timed out after ${timeoutMs}ms`));
       }, timeoutMs);
     });
     try {
@@ -4453,7 +4453,7 @@ function createControlPlaneClient({
       clearTimeout(timeoutId);
     }
   }
-  const taskReq = (method, path24, body, options = {}) => req(method, path24, body, { timeoutMs: taskRequestTimeoutMs, ...options });
+  const taskReq = (method, path25, body, options = {}) => req(method, path25, body, { timeoutMs: taskRequestTimeoutMs, ...options });
   const claimGate = makeClaimGateNotice({ log: (m) => console.warn(`[code-runner ${(/* @__PURE__ */ new Date()).toISOString()}] ${m}`) });
   return {
     getClaimGate: () => claimGate.current(),
@@ -4625,8 +4625,8 @@ function createControlPlaneClient({
       return listAllPrOpenedTasks(taskReq);
     },
     async downloadTaskAttachment(taskId, attachmentId) {
-      const path24 = `/api/v1/code-task/${encodeURIComponent(taskId)}/attachment/${encodeURIComponent(attachmentId)}`;
-      const res = await taskReq("GET", path24);
+      const path25 = `/api/v1/code-task/${encodeURIComponent(taskId)}/attachment/${encodeURIComponent(attachmentId)}`;
+      const res = await taskReq("GET", path25);
       if (res.status === 401) cachedFirebaseToken = null;
       if (!res.ok) throw new Error(`attachment download failed: HTTP ${res.status}`);
       return Buffer.from(await res.arrayBuffer());
@@ -7960,14 +7960,14 @@ function parsePorcelainZ(out) {
   for (let i = 0; i < tokens.length; i += 1) {
     const token2 = tokens[i];
     if (!token2) continue;
-    const path24 = token2.slice(3);
-    if (path24) files.push(path24);
+    const path25 = token2.slice(3);
+    if (path25) files.push(path25);
     if (token2[0] === "R" || token2[0] === "C") i += 1;
   }
   return files;
 }
-function isAgentScratch(path24) {
-  const normalized = String(path24 || "");
+function isAgentScratch(path25) {
+  const normalized = String(path25 || "");
   return SCRATCH_PATTERNS.some((pattern) => pattern.test(normalized));
 }
 var SCRATCH_PATTERNS;
@@ -10303,9 +10303,9 @@ async function readSpool(spoolDir = SPOOL_DIR) {
   }
   return out;
 }
-async function readCloudMap(path24) {
+async function readCloudMap(path25) {
   try {
-    return JSON.parse(await readFile2(path24, "utf8"));
+    return JSON.parse(await readFile2(path25, "utf8"));
   } catch {
     return {};
   }
@@ -10606,9 +10606,9 @@ function backoffMs(streak, baseMs) {
   if (streak <= 0) return 0;
   return Math.min(baseMs * 2 ** Math.min(streak - 1, 20), MAX_BACKOFF_MS);
 }
-async function loadState(path24) {
+async function loadState(path25) {
   try {
-    const parsed = JSON.parse(await readFile3(path24, "utf8"));
+    const parsed = JSON.parse(await readFile3(path25, "utf8"));
     if (parsed && typeof parsed === "object" && Number.isInteger(parsed.byte_offset) && parsed.byte_offset >= 0) {
       return { ...parsed, byte_offset: parsed.byte_offset };
     }
@@ -10616,15 +10616,15 @@ async function loadState(path24) {
   }
   return { byte_offset: 0, last_event_id: null, forwarded_total: 0, rejected_total: 0, rejected_event_ids: [] };
 }
-async function saveState(path24, state) {
-  await mkdir2(dirname9(path24), { recursive: true });
-  await writeFile3(path24, JSON.stringify(state, null, 2), "utf8");
+async function saveState(path25, state) {
+  await mkdir2(dirname9(path25), { recursive: true });
+  await writeFile3(path25, JSON.stringify(state, null, 2), "utf8");
 }
-async function readNewBytes(path24, offset, max) {
-  const st = await stat2(path24);
+async function readNewBytes(path25, offset, max) {
+  const st = await stat2(path25);
   if (st.size <= offset) return { buf: Buffer.alloc(0), size: st.size };
   const length = Math.min(st.size - offset, max);
-  const fh = await open(path24, "r");
+  const fh = await open(path25, "r");
   try {
     const buf = Buffer.alloc(length);
     const { bytesRead } = await fh.read(buf, 0, length, offset);
@@ -11742,10 +11742,10 @@ function formatShadowLogLine(record) {
   const loud = record.unexplained_fields?.length ? "!! " : "";
   return `${loud}[prepared-job-shadow] ${parts.join(" ")}`;
 }
-function appendShadowRecord(record, { path: path24 = PREPARED_JOB_SHADOW_SINK, append = appendFileSync, mkdir: mkdir5 = mkdirSync8 } = {}) {
+function appendShadowRecord(record, { path: path25 = PREPARED_JOB_SHADOW_SINK, append = appendFileSync, mkdir: mkdir5 = mkdirSync8 } = {}) {
   try {
-    mkdir5(dirname10(path24), { recursive: true });
-    append(path24, `${JSON.stringify(record)}
+    mkdir5(dirname10(path25), { recursive: true });
+    append(path25, `${JSON.stringify(record)}
 `, "utf8");
     return true;
   } catch {
@@ -13209,7 +13209,7 @@ function noteCiViaRest(log2) {
   log2("watch: CI status read via REST check-runs/status (gh's GraphQL rollup needs actions:read for checkSuite.workflowRun, which the read scope does not carry)");
 }
 async function readCommitCiViaRest(repo, sha, { run, env: env2 }) {
-  const api = async (path24) => JSON.parse(await run("gh", ["api", path24], { timeout: 3e4, env: env2 }) || "{}");
+  const api = async (path25) => JSON.parse(await run("gh", ["api", path25], { timeout: 3e4, env: env2 }) || "{}");
   const rollup = [];
   let total = null;
   for (let page = 1; page <= REST_MAX_PAGES && (total === null || rollup.length < total); page += 1) {
@@ -13873,9 +13873,9 @@ function buildControlHandler({ getStatus, requestStop, allowedOrigin }) {
       res.end();
       return;
     }
-    const path24 = String(req.url || "").split("?")[0];
+    const path25 = String(req.url || "").split("?")[0];
     res.setHeader("content-type", "application/json");
-    if (req.method === "GET" && path24 === "/status") {
+    if (req.method === "GET" && path25 === "/status") {
       let status;
       try {
         status = getStatus();
@@ -13886,7 +13886,7 @@ function buildControlHandler({ getStatus, requestStop, allowedOrigin }) {
       res.end(JSON.stringify({ ok: true, ...status }));
       return;
     }
-    if (req.method === "POST" && path24 === "/stop") {
+    if (req.method === "POST" && path25 === "/stop") {
       if (!isControlOriginAllowed(req.headers.origin, allowedOrigin) || !req.headers["x-vo-control"]) {
         res.statusCode = 403;
         res.end(JSON.stringify({ ok: false, error: "forbidden" }));
@@ -14921,9 +14921,9 @@ function operatorTierToRung(tier, difficulty, thresholds) {
   if (tier === "best" && difficulty >= thresholds.rungBounds.R5) return "R5";
   return base;
 }
-function readCodexModelsCache({ path: path24 = DEFAULT_CODEX_MODELS_CACHE, read = readFileSync9 } = {}) {
+function readCodexModelsCache({ path: path25 = DEFAULT_CODEX_MODELS_CACHE, read = readFileSync9 } = {}) {
   try {
-    const parsed = JSON.parse(read(path24, "utf8"));
+    const parsed = JSON.parse(read(path25, "utf8"));
     return Array.isArray(parsed?.models) ? parsed : null;
   } catch {
     return null;
@@ -15180,15 +15180,15 @@ function formatDecisionReason(decision, maxLen = 480) {
   const s = `[${decision.routerVersion}] ${decision.taskClass} d=${decision.difficulty} c=${decision.confidence} \u2192 ${decision.rung}/${decision.tier}${decision.effort ? ` effort=${decision.effort}` : ""} turns=${decision.maxTurns} $${decision.maxBudgetUsd}${decision.flags.length ? ` [${decision.flags.join(",")}]` : ""} :: ${decision.reasons.join("; ")}`;
   return s.length > maxLen ? `${s.slice(0, maxLen - 1)}\u2026` : s;
 }
-function appendDecisionFallback(decision, { path: path24 = DECISION_FALLBACK_PATH, append = appendFileSync2, mkdir: mkdir5 = mkdirSync9, task, thresholds, roleCostInputs } = {}) {
+function appendDecisionFallback(decision, { path: path25 = DECISION_FALLBACK_PATH, append = appendFileSync2, mkdir: mkdir5 = mkdirSync9, task, thresholds, roleCostInputs } = {}) {
   try {
-    mkdir5(dirname12(path24), { recursive: true });
-    append(path24, `${JSON.stringify(decision)}
+    mkdir5(dirname12(path25), { recursive: true });
+    append(path25, `${JSON.stringify(decision)}
 `, "utf8");
     if (isRouterDecision(decision)) {
       try {
         const records = buildShadowRecords({ decision, task, thresholds: thresholds || loadThresholds(), roleCostInputs });
-        for (const record of records) append(path24, `${JSON.stringify(record)}
+        for (const record of records) append(path25, `${JSON.stringify(record)}
 `, "utf8");
       } catch {
       }
@@ -16711,7 +16711,7 @@ async function processSkillTask(client, task, cfg, {
   resolveDispatch = resolveEffortDispatch,
   checkSkillCapability = ({ runner, bin, env: capabilityEnv }) => typeof runner.checkSkillCapability === "function" ? runner.checkSkillCapability({ bin, env: capabilityEnv }) : { compatible: false, reason: "resolved runner has no restricted-skill capability probe" },
   createScratch = () => mkdtemp2(join19(tmpdir(), "algohq-skill-task-")),
-  removeScratch = (path24) => rm2(path24, { recursive: true, force: true })
+  removeScratch = (path25) => rm2(path25, { recursive: true, force: true })
 } = {}) {
   const id = task.code_task_id;
   let run = null;
@@ -18658,6 +18658,72 @@ var init_task_worktree_preparation = __esm({
   }
 });
 
+// ../../scripts/virtual-office/code-runner/preflight-clone-dir.mjs
+import fs14 from "node:fs";
+import path24 from "node:path";
+function sanitize2(value, fallback) {
+  const cleaned = String(value || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+  return cleaned || fallback;
+}
+function cloneDirForServedRepo(repoSlug, clonesRootDir) {
+  if (!clonesRootDir || !path24.isAbsolute(String(clonesRootDir))) return null;
+  if (!repoSlug || !VALID_REPO_SLUG2.test(String(repoSlug))) return null;
+  const [owner, name] = String(repoSlug).split("/");
+  if (owner === "." || owner === ".." || name === "." || name === "..") return null;
+  if (owner.startsWith("-") || name.startsWith("-")) return null;
+  return path24.join(clonesRootDir, `${sanitize2(owner, "owner")}__${sanitize2(name, "repo")}`);
+}
+function resolvePreflightCwd(cfg = {}, env2 = process.env) {
+  const clonesRoot2 = String(env2?.VO_CODE_RUNNER_CLONES_ROOT || "").trim();
+  const served = Array.isArray(cfg?.servedRepos) ? cfg.servedRepos : [];
+  for (const repo of served) {
+    const dir = cloneDirForServedRepo(repo, clonesRoot2);
+    if (dir) return dir;
+  }
+  return String(env2?.VO_CODE_RUNNER_REPO || "").trim() || process.cwd();
+}
+function isGitWorkingTree(dir, { exists = fs14.existsSync } = {}) {
+  if (!dir) return false;
+  try {
+    return exists(path24.join(dir, ".git")) === true;
+  } catch {
+    return false;
+  }
+}
+function describeMissingClone(health, dir) {
+  const note = `no git clone at ${dir} yet \u2014 the first task creates it; git fetch not probed`;
+  if (!health) return health;
+  if (blockingReason(health)) return { ...health, git: UNKNOWN };
+  return { ...health, git: UNKNOWN, detail: `${note}; ${health.detail ?? ""}`.slice(0, 500) };
+}
+function makeServedClonePreflight({
+  cfg = {},
+  preflight = runHostPreflight,
+  exists = fs14.existsSync
+} = {}) {
+  return async function servedClonePreflight(options = {}) {
+    const env2 = options.env ?? process.env;
+    const dir = resolvePreflightCwd(cfg, env2);
+    if (!isGitWorkingTree(dir, { exists })) {
+      return describeMissingClone(await preflight({ ...options, cwd: null }), dir);
+    }
+    const health = await preflight({ ...options, cwd: dir });
+    if (health && blockingReason(health) === health.git && NOT_A_REPOSITORY_RE.test(String(health.detail ?? ""))) {
+      return describeMissingClone(await preflight({ ...options, cwd: null }), dir);
+    }
+    return health;
+  };
+}
+var VALID_REPO_SLUG2, NOT_A_REPOSITORY_RE;
+var init_preflight_clone_dir = __esm({
+  "../../scripts/virtual-office/code-runner/preflight-clone-dir.mjs"() {
+    "use strict";
+    init_host_preflight();
+    VALID_REPO_SLUG2 = /^[A-Za-z0-9._-]+\/[A-Za-z0-9._-]+$/u;
+    NOT_A_REPOSITORY_RE = /not a git repository|does not appear to be a git repos/iu;
+  }
+});
+
 // ../../scripts/virtual-office/code-runner-daemon.mjs
 var code_runner_daemon_exports = {};
 __export(code_runner_daemon_exports, {
@@ -18985,7 +19051,7 @@ async function main({ env: env2 = process.env, once: once2 = false } = {}) {
   const agentAvailability = makeAgentAvailabilityProvider({ onError: (e) => log(`agent probe failed: ${e.message}`) });
   await agentAvailability.ready();
   const accountUsage = makeAccountUsageProvider();
-  const hostGate = makeHostPreflightGate({ cwd: process.cwd(), runGit: runProcess2, runAgent: runProcess2, bin: cfg.runnerBin, agent: cfg.agent, env: env2, log });
+  const hostGate = makeHostPreflightGate({ preflight: makeServedClonePreflight({ cfg }), runGit: runProcess2, runAgent: runProcess2, bin: cfg.runnerBin, agent: cfg.agent, env: env2, log });
   const loopTick = makeLoopTicks({ client, cfg, env: env2, log, getActive: () => active, runnerInstanceId, capacityController, localModelController: createLocalModelRemoteController({ env: env2, log }), preparedJobController: createPreparedJobRemoteController({ log }), getAgentAvailability: () => agentAvailability.get(), getAccountUsage: () => accountUsage.get(), getHostHealth: () => hostGate.get() });
   const backoff = makeReconnectBackoff({ baseMs: cfg.pollSec * 1e3, log });
   let detachedFlushRunning = false;
@@ -19129,6 +19195,7 @@ var init_code_runner_daemon = __esm({
     init_task_worktree_preparation();
     init_process_runner2();
     init_host_preflight();
+    init_preflight_clone_dir();
     init_detached_economics_spool();
     RATE_LIMIT_RESUME_ENABLED = process.env.VO_RATE_LIMIT_RESUME !== "0";
     sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));