@algosuite/vo-mcp 0.2.0-beta.71 → 0.2.0-beta.72

package/dist/agent-auth-probe-cli.mjs

@@ -300,7 +300,7 @@ function normalizeClaudePermissionMode(value) {
   }
   return normalized;
 }
-function buildClaudeArgs({ permissionMode = DEFAULT_PERMISSION_MODE, maxTurns, model, effort, maxBudgetUsd, researchHarness = false, toolPolicy = "default", env = process.env } = {}) {
+function buildClaudeArgs({ permissionMode = DEFAULT_PERMISSION_MODE, maxTurns, model, effort, maxBudgetUsd, researchHarness = false, toolPolicy = "default", structuredOutputSchema, env = process.env } = {}) {
   const effectivePermissionMode = normalizeClaudePermissionMode(permissionMode);
   if (!["default", "skill_readonly", "frozen_inputs_only"].includes(toolPolicy)) {
     throw new Error(`unsupported Claude tool policy "${toolPolicy}"`);
@@ -338,6 +338,12 @@ function buildClaudeArgs({ permissionMode = DEFAULT_PERMISSION_MODE, maxTurns, m
       "none"
     );
   }
+  if (structuredOutputSchema !== void 0) {
+    if (!restrictedSkill || !structuredOutputSchema || typeof structuredOutputSchema !== "object" || Array.isArray(structuredOutputSchema)) {
+      throw new Error("structured output schema is allowed only for a restricted skill");
+    }
+    args.push("--json-schema", JSON.stringify(structuredOutputSchema));
+  }
   if (frozenInputsOnly) {
     args.push("--strict-mcp-config", "--safe-mode");
   }
@@ -425,13 +431,15 @@ function extractModelUsage(evt) {
 // ../../scripts/virtual-office/code-runner/claude-result-event.mjs
 var CAPPED_RESULT_SUBTYPES = Object.freeze(["error_max_budget_usd", "error_max_turns"]);
 function buildResultEvent(evt) {
-  const isError = Boolean(evt.is_error) || evt.subtype === "error_max_turns" || evt.subtype === "error_during_execution";
+  const isError = Boolean(evt.is_error) || evt.subtype === "error_max_budget_usd" || evt.subtype === "error_max_turns" || evt.subtype === "error_max_structured_output_retries" || evt.subtype === "error_during_execution";
   return {
     kind: "result",
     isError,
     costUsd: typeof evt.total_cost_usd === "number" ? evt.total_cost_usd : null,
     summary: typeof evt.result === "string" && evt.result.length > 0 ? evt.result : evt.subtype || (isError ? "error" : "completed"),
+    terminalSubtype: typeof evt.subtype === "string" ? evt.subtype : null,
     numTurns: typeof evt.num_turns === "number" ? evt.num_turns : null,
+    structuredOutput: Object.hasOwn(evt, "structured_output") ? evt.structured_output : null,
     tokenUsage: extractTokenUsage(evt),
     modelUsage: extractModelUsage(evt)
   };
@@ -544,9 +552,145 @@ function applyCliVersionFloor({ versionOutput, env = process.env, log = console.
   return { refused: !allowUnsafe, check, message };
 }
 
+// ../../scripts/virtual-office/code-runner/claude-skill-capability.mjs
+import { spawnSync as spawnSync6 } from "node:child_process";
+import { accessSync, constants, realpathSync as realpathSync2, statSync } from "node:fs";
+import path3 from "node:path";
+var VALIDATED_CLAUDE_SKILL_VERSIONS = Object.freeze(["2.1.263"]);
+var REQUIRED_CLAUDE_SKILL_HELP = Object.freeze([
+  "--allowedTools",
+  "--disable-slash-commands",
+  "--json-schema",
+  "--max-budget-usd",
+  "--no-chrome",
+  "--no-session-persistence",
+  "--output-format",
+  "--permission-mode",
+  "--permission-prompts",
+  "--safe-mode",
+  "--strict-mcp-config",
+  "--tools"
+]);
+var PROBE_TIMEOUT_MS = 2e3;
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+var cache = /* @__PURE__ */ new Map();
+function hasOption(help, option) {
+  const literal = option.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+  return new RegExp(`(^|\\s)${literal}(?=\\s|,|=|<|$)`, "mu").test(help);
+}
+function assessClaudeSkillCapability({ versionOutput, helpOutput }) {
+  const version = parseCliVersion(versionOutput);
+  if (!version || !VALIDATED_CLAUDE_SKILL_VERSIONS.includes(version)) {
+    return { compatible: false, version, reason: "claude version is not in the validated restricted-skill manifest" };
+  }
+  const help = String(helpOutput ?? "");
+  const missing = REQUIRED_CLAUDE_SKILL_HELP.filter((option) => !hasOption(help, option));
+  if (missing.length > 0) {
+    return { compatible: false, version, reason: `claude help is missing required options: ${missing.join(", ")}` };
+  }
+  if (!/--permission-prompts[\s\S]{0,300}(?:"none"|\bnone\b)/mu.test(help) || !/--output-format[\s\S]{0,300}\bstream-json\b/mu.test(help)) {
+    return { compatible: false, version, reason: "claude help does not prove required none/stream-json values" };
+  }
+  return { compatible: true, version, reason: "validated restricted-skill CLI contract" };
+}
+function runProbe(bin, args, env, timeoutMs = PROBE_TIMEOUT_MS) {
+  if (process.platform === "win32") {
+    try {
+      const launch = buildWindowsClaudeLaunch({ bin, args, env });
+      return spawnSync6(launch.bin, launch.args, {
+        ...launch.spawnOptions,
+        env,
+        encoding: "utf8",
+        timeout: timeoutMs
+      });
+    } catch (error) {
+      return { status: null, stdout: "", stderr: "", error };
+    }
+  }
+  return spawnSync6(bin, args, { env, encoding: "utf8", timeout: timeoutMs, windowsHide: true });
+}
+function probeText(probe) {
+  return `${String(probe?.stdout ?? "")}
+${String(probe?.stderr ?? "")}`.trim();
+}
+function resolveClaudeBinaryIdentity(bin = "claude", env = process.env) {
+  let resolvedBin = String(bin);
+  try {
+    if (process.platform === "win32") {
+      resolvedBin = buildWindowsClaudeLaunch({ bin: resolvedBin, args: [], env }).bin;
+    } else if (!path3.isAbsolute(resolvedBin)) {
+      const found = String(env?.PATH ?? "").split(path3.delimiter).find((dir) => {
+        try {
+          accessSync(path3.join(dir, resolvedBin), constants.X_OK);
+          return true;
+        } catch {
+          return false;
+        }
+      });
+      if (found) resolvedBin = path3.join(found, resolvedBin);
+    }
+    const canonical = realpathSync2(resolvedBin);
+    const stat = statSync(canonical);
+    return { resolvedBin: canonical, fingerprint: `${canonical}\0${stat.size}\0${stat.mtimeMs}` };
+  } catch {
+    const pathValue2 = String(env?.PATH ?? env?.Path ?? "");
+    return { resolvedBin, fingerprint: `${resolvedBin}\0${pathValue2}` };
+  }
+}
+function probeClaudeSkillCapability({
+  bin = "claude",
+  env = process.env,
+  versionOutput,
+  spawnProbe = runProbe,
+  now = () => Date.now(),
+  cacheTtlMs = CACHE_TTL_MS,
+  timeoutMs = PROBE_TIMEOUT_MS,
+  freshIdentity = false,
+  resolveIdentity = resolveClaudeBinaryIdentity
+} = {}) {
+  const identity = resolveIdentity(bin, env);
+  const key = identity.fingerprint;
+  const existing = cache.get(key);
+  if (!freshIdentity && versionOutput === void 0 && existing && now() - existing.at < cacheTtlMs) {
+    return existing.value;
+  }
+  const versionProbe = freshIdentity || versionOutput === void 0 ? spawnProbe(identity.resolvedBin, ["--version"], env, timeoutMs) : null;
+  if (versionProbe?.error || versionProbe && versionProbe.status !== 0) {
+    return {
+      compatible: false,
+      version: null,
+      resolvedBin: identity.resolvedBin,
+      reason: "claude version capability probe failed"
+    };
+  }
+  const effectiveVersionOutput = versionProbe ? probeText(versionProbe) : versionOutput;
+  const suppliedVersion = parseCliVersion(effectiveVersionOutput);
+  if (existing && now() - existing.at < cacheTtlMs && suppliedVersion === existing.value.version) {
+    return existing.value;
+  }
+  const helpProbe = spawnProbe(identity.resolvedBin, ["--help"], env, timeoutMs);
+  if (helpProbe?.error || helpProbe?.status !== 0) {
+    return {
+      compatible: false,
+      version: suppliedVersion,
+      resolvedBin: identity.resolvedBin,
+      reason: "claude help capability probe failed"
+    };
+  }
+  const assessed = assessClaudeSkillCapability({
+    versionOutput: effectiveVersionOutput,
+    helpOutput: probeText(helpProbe)
+  });
+  const value = { ...assessed, resolvedBin: identity.resolvedBin };
+  cache.set(key, { at: now(), value });
+  return value;
+}
+
 // ../../scripts/virtual-office/code-runner/claude-auth-check.mjs
 var FIRST_VERSION_TIMEOUT_MS = 4500;
 var RETRY_VERSION_TIMEOUT_MS = 2e3;
+var AUTH_PROBE_BUDGET_MS = 9500;
+var MIN_SKILL_PROBE_MS = 250;
 function errorCode(error) {
   return String(error?.code || "").toUpperCase();
 }
@@ -572,9 +716,12 @@ async function checkClaudeAuth({
   spawnVersion = spawnClaudeSync,
   probeLogin = probeClaudeLoginState,
   getStoredKey = getAnthropicKey,
-  env = process.env
+  probeSkillCapability = probeClaudeSkillCapability,
+  env = process.env,
+  now = () => Date.now()
 } = {}) {
   try {
+    const startedAt = now();
     let probe = spawnVersion(["--version"], {
       timeout: FIRST_VERSION_TIMEOUT_MS,
       encoding: "utf8",
@@ -608,23 +755,40 @@ async function checkClaudeAuth({
     }
     const floorGate = applyCliVersionFloor({ versionOutput: probe.stdout, env });
     if (floorGate.refused) {
-      return { installed: true, authenticated: false, message: floorGate.message };
+      return {
+        installed: true,
+        authenticated: false,
+        version: floorGate.check.version ?? void 0,
+        skillCapable: false,
+        message: floorGate.message
+      };
     }
     const loggedIn = retriedAfterTimeout ? null : probeLogin();
     if (loggedIn === false) {
       return {
         installed: true,
         authenticated: false,
+        version: floorGate.check.version ?? void 0,
+        skillCapable: false,
         message: "claude CLI is installed but NOT logged in \u2014 its login is SEPARATE from the Claude Desktop app and the Claude Code IDE extension. Run: claude auth login (Claude subscription), then restart the runner."
       };
     }
+    const authTier = resolveClaudeAuthTier({ env, loggedIn, getStoredKey });
+    const remainingMs = AUTH_PROBE_BUDGET_MS - (now() - startedAt);
+    const skillCapability = loggedIn === true && remainingMs >= MIN_SKILL_PROBE_MS ? probeSkillCapability({
+      versionOutput: probe.stdout,
+      env,
+      timeoutMs: Math.min(2e3, remainingMs)
+    }) : { compatible: false };
     return {
       installed: true,
       authenticated: true,
+      version: floorGate.check.version ?? void 0,
+      skillCapable: skillCapability.compatible === true,
       // Dispatch-time billing signal, carried on the same probe that already
       // paid for the login read. Never sent for a non-authenticated result:
       // there is no tier without a working credential.
-      authTier: resolveClaudeAuthTier({ env, loggedIn, getStoredKey }),
+      authTier,
       message: loggedIn === true ? "claude CLI installed and logged in (claude auth status)" : "claude binary found (login state unknown \u2014 auth check is best-effort)"
     };
   } catch (error) {
@@ -647,8 +811,8 @@ var ClaudeRunner = class {
   get binary() {
     return "claude";
   }
-  buildArgs({ permissionMode, maxTurns, model, effort, maxBudgetUsd, researchHarness, toolPolicy } = {}) {
-    return buildClaudeArgs({ permissionMode, maxTurns, model, effort, maxBudgetUsd, researchHarness, toolPolicy });
+  buildArgs({ permissionMode, maxTurns, model, effort, maxBudgetUsd, researchHarness, toolPolicy, structuredOutputSchema } = {}) {
+    return buildClaudeArgs({ permissionMode, maxTurns, model, effort, maxBudgetUsd, researchHarness, toolPolicy, structuredOutputSchema });
   }
   parseEvent(line) {
     return parseStreamEvent(line);
@@ -672,11 +836,14 @@ var ClaudeRunner = class {
   async checkAuth() {
     return checkClaudeAuth();
   }
+  checkSkillCapability({ bin = this.binary, env = process.env } = {}) {
+    return probeClaudeSkillCapability({ bin, env, freshIdentity: true });
+  }
 };
 var claudeRunner = new ClaudeRunner();
 
 // ../../scripts/virtual-office/code-runner/codex-runner.mjs
-import { spawnSync as spawnSync6 } from "node:child_process";
+import { spawnSync as spawnSync7 } from "node:child_process";
 import { existsSync as existsSync3 } from "node:fs";
 import { win32 } from "node:path";
 
@@ -928,7 +1095,7 @@ function parseCodexEvent(line) {
   return null;
 }
 var CodexRunner = class {
-  constructor({ spawn: spawn2 = spawnSync6, resolveBinary = resolveCodexBinary, env = process.env } = {}) {
+  constructor({ spawn: spawn2 = spawnSync7, resolveBinary = resolveCodexBinary, env = process.env } = {}) {
     this.spawn = spawn2;
     this.resolveBinary = resolveBinary;
     this.env = env;
@@ -1039,7 +1206,7 @@ ${login.stderr || ""}`.trim();
 var codexRunner = new CodexRunner();
 
 // ../../scripts/virtual-office/code-runner/cursor-runner.mjs
-import { spawnSync as spawnSync7 } from "node:child_process";
+import { spawnSync as spawnSync8 } from "node:child_process";
 function buildCursorArgs({ model, prompt } = {}) {
   const args = ["-p", "--output-format", "stream-json", "--force"];
   if (model) {
@@ -1144,7 +1311,7 @@ var CursorRunner = class {
   /** Best-effort: is `cursor-agent` on PATH? Never throws. */
   async checkAuth() {
     try {
-      const { status, error } = spawnSync7("cursor-agent", ["--version"], {
+      const { status, error } = spawnSync8("cursor-agent", ["--version"], {
         shell: false,
         windowsHide: true,
         timeout: 3e3,