@algosuite/vo-mcp 0.2.0-beta.60 → 0.2.0-beta.61

package/dist/ci/check-local-pr-overlap.js

@@ -106643,6 +106643,81 @@ if (process.argv[1] && import.meta.url === pathToFileURL(path.resolve(process.ar
   process.exitCode = exitCode;
 }
 
+// ../../scripts/virtual-office/code-runner/self-claim-identity.mjs
+var CODE_TASK_BRANCH_RE = /^(?:refs\/heads\/)?vo\/code-task-([0-9a-z]{8,})-/iu;
+var CODE_TASK_MARKER_RE = /(?:^|[\s[(])code-task:([0-9a-z][0-9a-z-]{7,63})/iu;
+var MIN_TASK_ID_TOKEN_LENGTH = 8;
+var MAX_TASK_ID_LENGTH = 36;
+var TASK_ID_CHARS_RE = /^[0-9a-z][0-9a-z-]*$/u;
+function normalizeTaskId(value) {
+  return String(value ?? "").trim().toLowerCase();
+}
+function taskIdFromCodeTaskBranch(branch) {
+  const match = CODE_TASK_BRANCH_RE.exec(String(branch ?? "").trim());
+  return match ? match[1].toLowerCase() : "";
+}
+function taskIdFromClaimMarker(currentTask) {
+  const match = CODE_TASK_MARKER_RE.exec(String(currentTask ?? ""));
+  return match ? match[1].toLowerCase() : "";
+}
+function resolvePublishingTaskId({ taskId = "", branch = "", env = {} } = {}) {
+  const none = { taskId: "", token: "", source: "none", exact: false };
+  const fromBranch = taskIdFromCodeTaskBranch(branch);
+  const branchToken = fromBranch.length >= MIN_TASK_ID_TOKEN_LENGTH ? fromBranch : "";
+  const explicit = normalizeTaskId(taskId);
+  if (explicit.length >= MIN_TASK_ID_TOKEN_LENGTH && TASK_ID_CHARS_RE.test(explicit)) {
+    return { taskId: explicit, token: explicit.slice(0, MIN_TASK_ID_TOKEN_LENGTH), source: "explicit", exact: true };
+  }
+  const fromEnv = normalizeTaskId(env?.VO_CODE_TASK_ID);
+  if (fromEnv.length >= MIN_TASK_ID_TOKEN_LENGTH && TASK_ID_CHARS_RE.test(fromEnv)) {
+    if (branchToken && !fromEnv.startsWith(branchToken)) {
+      return { ...none, source: "conflict" };
+    }
+    return { taskId: fromEnv, token: fromEnv.slice(0, MIN_TASK_ID_TOKEN_LENGTH), source: "env", exact: true };
+  }
+  if (branchToken) return { taskId: branchToken, token: branchToken, source: "branch", exact: false };
+  return none;
+}
+function matchesPublishingTask(candidate, publishing) {
+  const value = normalizeTaskId(candidate);
+  if (!publishing?.token) return false;
+  if (value.length < MIN_TASK_ID_TOKEN_LENGTH || value.length > MAX_TASK_ID_LENGTH) return false;
+  if (!TASK_ID_CHARS_RE.test(value)) return false;
+  if (!value.startsWith(publishing.token)) return false;
+  if (publishing.exact) return publishing.taskId.startsWith(value) || value.startsWith(publishing.taskId);
+  return true;
+}
+function claimTaskId(conflict, publishing) {
+  if (!publishing?.token) return "";
+  const marked = taskIdFromClaimMarker(conflict?.currentTask);
+  if (marked && matchesPublishingTask(marked, publishing)) return marked;
+  const agentId = String(conflict?.agentId ?? "").trim().toLowerCase();
+  if (!agentId) return "";
+  const index = agentId.lastIndexOf(`-${publishing.token}`);
+  if (index < 0) return "";
+  const tail = agentId.slice(index + 1);
+  return matchesPublishingTask(tail, publishing) ? tail : "";
+}
+function claimBelongsToTask(conflict, publishing) {
+  return claimTaskId(conflict, publishing) !== "";
+}
+function partitionSelfClaims(conflicts = [], publishing = { token: "" }) {
+  const self2 = [];
+  const foreign = [];
+  for (const conflict of conflicts) {
+    (claimBelongsToTask(conflict, publishing) ? self2 : foreign).push(conflict);
+  }
+  return { self: self2, foreign };
+}
+function describeSelfClaimExclusion(self2 = [], publishing = { token: "" }) {
+  if (self2.length === 0) return "";
+  const files = [...new Set(self2.map((conflict) => conflict?.matchedFile || conflict?.file || "?"))];
+  return [
+    `Self-claims ignored: ${self2.length} live whiteboard claim(s) held by this publishing task (task ${publishing.taskId || publishing.token}, matched via ${publishing.source}).`,
+    ...files.map((file) => `- ${file}`)
+  ].join("\n");
+}
+
 // ../../scripts/ci/check-local-pr-overlap.mjs
 function normalizeFileList(files = []) {
   return [...new Set(files.flatMap((file) => String(file || "").split(/\r?\n/)).map((file) => file.trim().replaceAll("\\", "/")).filter(Boolean))];
@@ -106728,7 +106803,10 @@ function evaluateOverlapGate({
   whiteboardReason = "",
   requireWhiteboard = true,
   allowOverlap = false,
-  prLabel = "local branch"
+  prLabel = "local branch",
+  // Never silent: when the publishing task's OWN claims were dropped, say so and
+  // name them. A gate that quietly ignores claims cannot be told from a broken one.
+  selfClaimNote = ""
 } = {}) {
   const files = normalizeFileList(changedFiles);
   const overlaps = classifyOverlaps(files, otherPrs || []);
@@ -106740,6 +106818,7 @@ function evaluateOverlapGate({
   lines.push(`Local overlap gate for ${prLabel}`);
   lines.push(`Changed files: ${files.length}`);
   if (otherPrs?.length) lines.push(`Compared against open PRs: ${otherPrs.length}`);
+  if (selfClaimNote) lines.push(selfClaimNote);
   if (directOverlap || overlaps.packageOverlaps.length || overlaps.sharedDepOverlaps.length) {
     lines.push("");
     lines.push(buildOverlapReport(overlaps, 0));
@@ -106780,6 +106859,32 @@ function evaluateOverlapGate({
     report: lines.join("\n")
   };
 }
+function decideOverlapGate({
+  changedFiles,
+  otherPrs = [],
+  busResult = { available: true, conflicts: [] },
+  taskId = "",
+  branch = "",
+  env = process.env,
+  requireWhiteboard = true,
+  allowOverlap = false,
+  prLabel = branch || "local branch"
+} = {}) {
+  const publishing = resolvePublishingTaskId({ taskId, branch, env });
+  const { self: self2, foreign } = partitionSelfClaims(busResult?.conflicts || [], publishing);
+  const evaluated = evaluateOverlapGate({
+    changedFiles,
+    otherPrs,
+    busConflicts: foreign,
+    whiteboardAvailable: busResult?.available !== false,
+    whiteboardReason: busResult?.reason || "",
+    requireWhiteboard,
+    allowOverlap,
+    prLabel,
+    selfClaimNote: describeSelfClaimExclusion(self2, publishing)
+  });
+  return { ...evaluated, publishing, selfClaims: self2 };
+}
 async function main() {
   const { values: args } = parseArgs({
     options: {
@@ -106788,7 +106893,10 @@ async function main() {
       branch: { type: "string", default: "" },
       stdin: { type: "boolean", default: false },
       "exclude-pr": { type: "string", default: "" },
-      "agent-id": { type: "string", default: process.env.AGENT_ID || "" }
+      "agent-id": { type: "string", default: process.env.AGENT_ID || "" },
+      // The publishing code task. Explicit beats VO_CODE_TASK_ID beats the
+      // `vo/code-task-<id8>-…` branch; absent everywhere ⇒ nothing is excluded.
+      "task-id": { type: "string", default: "" }
     }
   });
   const changedFiles = args.stdin ? readFilesFromStdin() : readChangedFiles({ base: args.base, head: args.head });
@@ -106815,12 +106923,12 @@ async function main() {
     return 2;
   }
   const busResult = await checkForConflicts(changedFiles, { excludeAgentId: args["agent-id"] });
-  const result = evaluateOverlapGate({
+  const result = decideOverlapGate({
     changedFiles,
     otherPrs,
-    busConflicts: busResult.conflicts || [],
-    whiteboardAvailable: busResult.available !== false,
-    whiteboardReason: busResult.reason || "",
+    busResult,
+    taskId: args["task-id"],
+    branch: args.branch,
     requireWhiteboard: process.env.VO_ALLOW_WHITEBOARD_UNAVAILABLE !== "1",
     allowOverlap: process.env.VO_ALLOW_PR_OVERLAP === "1",
     prLabel: args.branch || "local branch"
@@ -106831,6 +106939,7 @@ async function main() {
 var __test3 = {
   HOSTILE_WORKTREE_GIT_GUARDS,
   gitText,
+  decideOverlapGate,
   evaluateOverlapGate,
   isPrDiffTooLargeError,
   normalizeFileList,
@@ -106842,7 +106951,8 @@ if (process.argv[1] && import.meta.url === pathToFileURL2(path2.resolve(process.
   process.exit(await main());
 }
 export {
-  __test3 as __test
+  __test3 as __test,
+  decideOverlapGate
 };
 /*! Bundled license information:
 

package/dist/install-cli.js

@@ -546,6 +546,43 @@ function installCodexMcpConfigAt(configPath, cliPath, controlPlaneUrl, log, mana
   log(`\u2713 Wrote AlgoHQ MCP to Codex: ${configPath}`);
 }
 
+// src/remote-mcp-entry.ts
+var REMOTE_MCP_SERVER_KEY = "vo-mcp-remote";
+var REMOTE_MCP_TOKEN_ENV = "VO_MCP_REMOTE_TOKEN";
+var REMOTE_MCP_ENDPOINT_PATH = "/api/v1/mcp";
+var REMOTE_MCP_AUTH_HEADER = `Bearer \${${REMOTE_MCP_TOKEN_ENV}}`;
+function remoteMcpOptIn(env) {
+  return (env["VO_REMOTE_MCP"] ?? "").trim() === "1";
+}
+function remoteMcpUrl(controlPlaneUrl) {
+  return `${controlPlaneUrl.trim().replace(/\/+$/, "")}${REMOTE_MCP_ENDPOINT_PATH}`;
+}
+function buildRemoteMcpEntry(controlPlaneUrl) {
+  return {
+    type: "http",
+    url: remoteMcpUrl(controlPlaneUrl),
+    headers: { Authorization: REMOTE_MCP_AUTH_HEADER }
+  };
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function isManagedRemoteMcpEntry(value) {
+  const entry = asRecord(value);
+  if (!entry) return false;
+  if (entry["type"] !== "http") return false;
+  const url = entry["url"];
+  if (typeof url !== "string" || !url.endsWith(REMOTE_MCP_ENDPOINT_PATH)) return false;
+  const headers = asRecord(entry["headers"]);
+  return headers?.["Authorization"] === REMOTE_MCP_AUTH_HEADER;
+}
+function remoteMcpEntryIsCurrent(value, desired) {
+  const entry = asRecord(value);
+  if (!entry) return false;
+  const headers = asRecord(entry["headers"]);
+  return entry["type"] === desired.type && entry["url"] === desired.url && headers?.["Authorization"] === desired.headers["Authorization"];
+}
+
 // src/autostart.ts
 import { homedir as homedir3, platform as platform2 } from "node:os";
 import { isAbsolute as isAbsolute2, join as join5 } from "node:path";
@@ -810,7 +847,20 @@ function resolveVoMcpCliPath() {
 }
 var INSTALL_LAUNCHER = { sticky: false, onlyExisting: false };
 var HEAL_LAUNCHER = { sticky: true, onlyExisting: true };
-function installMcpConfigAt(configPath, cliPath, controlPlaneUrl, log, label, launcher = { launcherPath: null, ...INSTALL_LAUNCHER }) {
+function reconcileRemoteEntry(mcpServers, remote) {
+  const existing = mcpServers[REMOTE_MCP_SERVER_KEY];
+  if (remote) {
+    return {
+      fragment: { [REMOTE_MCP_SERVER_KEY]: remote },
+      current: remoteMcpEntryIsCurrent(existing, remote)
+    };
+  }
+  if (existing !== void 0 && isManagedRemoteMcpEntry(existing)) {
+    return { fragment: { [REMOTE_MCP_SERVER_KEY]: void 0 }, current: false };
+  }
+  return { fragment: {}, current: true };
+}
+function installMcpConfigAt(configPath, cliPath, controlPlaneUrl, log, label, launcher = { launcherPath: null, ...INSTALL_LAUNCHER }, remote = null) {
   if (launcher.onlyExisting && !existsSync6(configPath)) return;
   const read = readClaudeConfig(configPath);
   if (read.kind === "invalid" || read.kind === "empty" && launcher.onlyExisting) {
@@ -824,8 +874,9 @@ function installMcpConfigAt(configPath, cliPath, controlPlaneUrl, log, label, la
   const voEntry = managedEntry ?? mcpServers["vo"];
   const { launcherPath } = launcher;
   const fallbackCli = chooseFallbackCli(voEntry?.env?.[MCP_FALLBACK_CLI_ENV], cliPath, launcher.sticky, launcherPath ? dirname4(launcherPath) : null);
-  const current = launcherPath ? !isStaleVoMcpEntry(voEntry, launcherPath, fallbackCli) : Boolean(voEntry?.args?.some((a) => a.includes(cliPath)));
-  if (current) {
+  const localCurrent = launcherPath ? !isStaleVoMcpEntry(voEntry, launcherPath, fallbackCli) : Boolean(voEntry?.args?.some((a) => a.includes(cliPath)));
+  const remoteState = reconcileRemoteEntry(mcpServers, remote);
+  if (localCurrent && remoteState.current) {
     log(`  ${label} already current: ${configPath}`);
     return;
   }
@@ -845,7 +896,11 @@ function installMcpConfigAt(configPath, cliPath, controlPlaneUrl, log, label, la
           ...preservedEnv,
           ...launcherPath && fallbackCli ? { [MCP_FALLBACK_CLI_ENV]: fallbackCli } : {}
         }
-      }
+      },
+      // Additive remote entry (11.3 slice A) — or the removal of one we wrote,
+      // when the operator has opted back out. Spread LAST so it can delete its
+      // own key; it never names 'vo-mcp', so the stdio entry above is safe.
+      ...remoteState.fragment
     }
   };
   if (readMtime !== null && (!existsSync6(configPath) || statSync3(configPath).mtimeMs !== readMtime)) {
@@ -854,6 +909,12 @@ function installMcpConfigAt(configPath, cliPath, controlPlaneUrl, log, label, la
   }
   writeClaudeConfig(configPath, merged);
   log(`\u2713 Wrote vo-mcp to ${label}: ${configPath}`);
+  if (remote) {
+    log(`  + remote MCP entry '${REMOTE_MCP_SERVER_KEY}' \u2192 ${remote.url} (serves vo_skill_list; every other tool stays on the local vo-mcp entry)`);
+    log(`    Set ${REMOTE_MCP_TOKEN_ENV} in your environment to authenticate it \u2014 no token is written to this file.`);
+  } else if (!remoteState.current) {
+    log(`  - removed the remote MCP entry '${REMOTE_MCP_SERVER_KEY}' (VO_REMOTE_MCP is not set to 1)`);
+  }
 }
 function installMcpConfig(log, env, mode = "install") {
   const home = env["HOME"]?.trim() || env["USERPROFILE"]?.trim() || homedir4();
@@ -861,6 +922,7 @@ function installMcpConfig(log, env, mode = "install") {
   const plat = platform3();
   const cliPath = resolveVoMcpCliPath();
   const controlPlaneUrl = env["VO_CONTROL_PLANE_URL"]?.trim() || DEFAULT_CONTROL_PLANE_URL2;
+  const remote = remoteMcpOptIn(env) ? buildRemoteMcpEntry(controlPlaneUrl) : null;
   const launcherPath = writeMcpLauncherForEnv(env, log, { platform: plat, home });
   const launcher = { launcherPath, ...mode === "heal" ? HEAL_LAUNCHER : INSTALL_LAUNCHER };
   const leg = (label, run) => {
@@ -871,8 +933,8 @@ function installMcpConfig(log, env, mode = "install") {
       log(`  \u26A0 ${label}: could not update the MCP registration \u2014 ${err instanceof Error ? err.message : String(err)}`);
     }
   };
-  leg("Claude Code CLI", () => installMcpConfigAt(resolveCodeConfigPath(home), cliPath, controlPlaneUrl, log, "Claude Code CLI", launcher));
-  leg("Claude Desktop", () => installMcpConfigAt(resolveDesktopConfigPath(home, plat, appData), cliPath, controlPlaneUrl, log, "Claude Desktop", launcher));
+  leg("Claude Code CLI", () => installMcpConfigAt(resolveCodeConfigPath(home), cliPath, controlPlaneUrl, log, "Claude Code CLI", launcher, remote));
+  leg("Claude Desktop", () => installMcpConfigAt(resolveDesktopConfigPath(home, plat, appData), cliPath, controlPlaneUrl, log, "Claude Desktop", launcher, remote));
   const codexPath = resolveCodexConfigPath(home);
   if (launcher.onlyExisting && !existsSync6(codexPath)) return;
   leg("Codex", () => {