@algosuite/vo-mcp 0.2.0-beta.4 → 0.2.0-beta.7

package/bin/vo-mcp

@@ -5,6 +5,7 @@
  * Usage:
  *   vo-mcp                                  # MCP stdio server (default)
  *   vo-mcp install                          # one-command installer
+ *   vo-mcp update                           # update MCP + runner package
  *   vo-mcp login                            # credential login (browser loopback)
  *   vo-mcp pair                             # device-code pairing (enter a code in the web)
  *   vo-mcp runner                           # agent runner daemon
@@ -17,6 +18,8 @@ const subcommand = process.argv[3];
 
 if (command === 'install') {
   import('../dist/install-cli.js');
+} else if (command === 'update') {
+  import('../dist/update-cli.js');
 } else if (command === 'login') {
   import('../dist/login-cli.js');
 } else if (command === 'pair') {

package/dist/cli.js

@@ -1368,6 +1368,31 @@ var init_credential_store = __esm({
   }
 });
 
+// src/tools/memory/safe-memory-file.ts
+import { resolve, sep } from "node:path";
+function isSafeMemoryFileName(fileName) {
+  return fileName.length <= 200 && fileName.trim() === fileName && !fileName.includes("/") && !fileName.includes("\\") && !fileName.includes(":") && SAFE_MEMORY_FILE_RE.test(fileName);
+}
+function resolveMemoryFilePath(memoryDir, fileName) {
+  if (!isSafeMemoryFileName(fileName)) {
+    throw new Error(`unsafe memory file_name: ${fileName.slice(0, 80)}`);
+  }
+  const root = resolve(memoryDir);
+  const filePath = resolve(root, fileName);
+  const rootPrefix = root.endsWith(sep) ? root : `${root}${sep}`;
+  if (filePath !== root && !filePath.startsWith(rootPrefix)) {
+    throw new Error(`memory file path escapes memory directory: ${fileName.slice(0, 80)}`);
+  }
+  return filePath;
+}
+var SAFE_MEMORY_FILE_RE;
+var init_safe_memory_file = __esm({
+  "src/tools/memory/safe-memory-file.ts"() {
+    "use strict";
+    SAFE_MEMORY_FILE_RE = /^[A-Za-z0-9][A-Za-z0-9._ -]*\.md$/i;
+  }
+});
+
 // src/tools/memory/sync-config.ts
 var sync_config_exports = {};
 __export(sync_config_exports, {
@@ -1413,10 +1438,13 @@ async function pullMemory(controlPlaneUrl, token, memoryDir, fetchFn) {
   if (!data.ok || !Array.isArray(data.entries)) {
     throw new Error("GET /api/v1/agent-config/memory/me response missing ok=true or entries array");
   }
+  const writes = data.entries.map((entry) => ({
+    entry,
+    filePath: resolveMemoryFilePath(memoryDir, entry.file_name)
+  }));
   mkdirSync4(memoryDir, { recursive: true });
   const files = [];
-  for (const entry of data.entries) {
-    const filePath = join7(memoryDir, entry.file_name);
+  for (const { entry, filePath } of writes) {
     writeFileSync3(filePath, entry.content, "utf8");
     files.push(entry.file_name);
   }
@@ -1428,7 +1456,7 @@ async function pushMemory(controlPlaneUrl, token, memoryDir, sessionId, fetchFn)
   }
   const localFiles = readdirSync4(memoryDir).filter((f) => f.endsWith(".md")).map((f) => ({
     file_name: f,
-    content: readFileSync7(join7(memoryDir, f), "utf8"),
+    content: readFileSync7(resolveMemoryFilePath(memoryDir, f), "utf8"),
     entry_type: f === "MEMORY.md" ? "index" : "topic"
   }));
   if (localFiles.length === 0) {
@@ -1566,6 +1594,7 @@ var init_sync_config = __esm({
   "src/tools/memory/sync-config.ts"() {
     "use strict";
     init_common();
+    init_safe_memory_file();
     TOOL_NAME22 = "vo_sync_config";
     inputSchema22 = {
       type: "object",
@@ -5023,6 +5052,8 @@ function suggestedHandoffPath(session_id, isoTimestamp) {
 }
 
 // src/tools/session/report-session-state.ts
+init_auth_token_source();
+init_credential_store();
 var TOOL_NAME19 = "vo_report_session_state";
 var VALID_AGENT_TYPES = ["claude-code", "codex", "cursor", "continue"];
 var MAX_GOAL_CHARS = 500;
@@ -5073,7 +5104,7 @@ var inputSchema19 = {
   required: ["operator_id", "session_id", "agent_type", "context_used_pct"],
   additionalProperties: false
 };
-var description19 = "Reports per-session context-window utilization to VO and returns a directive: 'continue' (under 70%), 'prepare_handoff' (70-84%), or 'execute_handoff_now' (\u226585%). Implements V1 launch gate #9 (fleet context lifecycle management) per the official VO roadmap. Cloud-control-plane mode when VO_CONTROL_PLANE_URL + VO_CONTROL_PLANE_ADMIN_TOKEN + VO_TENANT_ID are set; auto-allocates the session on first report so interactive agents (Claude Code, Cursor, Codex, Continue) appear on the live fleet whiteboard. Stub-local fallback when cloud config is absent or fails. The response shape stays stable across modes (`backend_mode` field in the payload tells the caller which mode produced the verdict).";
+var description19 = "Reports per-session context-window utilization to VO and returns a directive: 'continue' (under 70%), 'prepare_handoff' (70-84%), or 'execute_handoff_now' (\u226585%). Implements V1 launch gate #9 (fleet context lifecycle management) per the official VO roadmap. Cloud-control-plane mode when VO_CONTROL_PLANE_URL plus a user/scoped VO credential (or legacy admin token) is available; auto-allocates the session on first report so interactive agents (Claude Code, Cursor, Codex, Continue) appear on the live fleet whiteboard. Stub-local fallback when cloud config is absent or fails. The response shape stays stable across modes (`backend_mode` field in the payload tells the caller which mode produced the verdict).";
 function isStringArray2(v, maxItems) {
   if (!Array.isArray(v)) return false;
   if (v.length > maxItems) return false;
@@ -5098,14 +5129,39 @@ function isToolInput19(v) {
   }
   return true;
 }
-function getCloudConfig() {
-  const url = process.env["VO_CONTROL_PLANE_URL"];
-  const token = process.env["VO_CONTROL_PLANE_ADMIN_TOKEN"];
-  const tenant_id = process.env["VO_TENANT_ID"];
-  if (!url || !token || !tenant_id) return null;
-  return { url, token, tenant_id };
+async function fetchCloudIdentity(url, token, fetchFn) {
+  try {
+    const response = await fetchFn(`${url}/api/v1/auth/me`, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${token}`
+      }
+    });
+    if (!response.ok) return null;
+    const data = await response.json();
+    if (!data.ok || !data.provisioned || !data.operator_id || !data.tenant_id) return null;
+    return { operator_id: data.operator_id, tenant_id: data.tenant_id };
+  } catch {
+    return null;
+  }
 }
-async function tryCloudReportState(cloud, input) {
+async function getCloudConfig(fetchFn = fetch) {
+  const url = process.env["VO_CONTROL_PLANE_URL"]?.trim();
+  if (!url) return null;
+  const tokenSource = createAuthTokenSourceFromEnv(
+    process.env,
+    fetchFn,
+    () => readStoredCredential(process.env)
+  );
+  const token = await tokenSource?.getToken();
+  if (!token) return null;
+  const tenant_id = process.env["VO_TENANT_ID"]?.trim();
+  if (tenant_id) return { url, token, tenant_id };
+  const identity = await fetchCloudIdentity(url, token, fetchFn);
+  if (!identity) return null;
+  return { url, token, tenant_id: identity.tenant_id, operator_id: identity.operator_id };
+}
+async function tryCloudReportState(cloud, input, fetchFn = fetch) {
   try {
     const reportBody = {
       context_used_pct: input.context_used_pct
@@ -5118,7 +5174,7 @@ async function tryCloudReportState(cloud, input) {
       reportBody["recent_tool_uses"] = input.recent_tool_uses;
     }
     const reportUrl = `${cloud.url}/api/v1/session/${input.session_id}/report-state`;
-    let response = await fetch(reportUrl, {
+    let response = await fetchFn(reportUrl, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -5128,7 +5184,7 @@ async function tryCloudReportState(cloud, input) {
     });
     if (response.status === 404) {
       const allocateBody = {
-        operator_id: input.operator_id,
+        operator_id: cloud.operator_id ?? input.operator_id,
         tenant_id: cloud.tenant_id,
         agent_type: input.agent_type,
         current_goal: input.current_goal ?? "Interactive session"
@@ -5137,7 +5193,7 @@ async function tryCloudReportState(cloud, input) {
         allocateBody["initial_context_used_pct"] = input.context_used_pct;
       }
       const allocateUrl = `${cloud.url}/api/v1/session`;
-      const allocateResponse = await fetch(allocateUrl, {
+      const allocateResponse = await fetchFn(allocateUrl, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -5148,7 +5204,10 @@ async function tryCloudReportState(cloud, input) {
       if (!allocateResponse.ok) {
         return null;
       }
-      response = await fetch(reportUrl, {
+      const allocateData = await allocateResponse.json();
+      const retrySessionId = typeof allocateData.session?.session_id === "string" && allocateData.session.session_id.length > 0 ? allocateData.session.session_id : input.session_id;
+      const retryReportUrl = `${cloud.url}/api/v1/session/${retrySessionId}/report-state`;
+      response = await fetchFn(retryReportUrl, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -5187,7 +5246,7 @@ async function handleReportSessionState(deps, rawInput, _signal) {
       `invalid input. Required fields: operator_id (non-empty string), session_id (non-empty string), agent_type (one of: ${VALID_AGENT_TYPES.join(" | ")}), context_used_pct (number 0-100). Optional: current_goal (string \u2264${MAX_GOAL_CHARS} chars), recent_files_touched (string[] \u2264${MAX_RECENT_FILES}), recent_tool_uses (string[] \u2264${MAX_RECENT_TOOLS}).`
     );
   }
-  const cloud = getCloudConfig();
+  const cloud = await getCloudConfig();
   if (cloud !== null) {
     const cloudPayload = await tryCloudReportState(cloud, rawInput);
     if (cloudPayload !== null) {
@@ -5433,6 +5492,107 @@ async function handleConciergeDispatch(deps, rawInput, _signal) {
 
 // src/server.ts
 init_sync_config();
+
+// src/tools/memory/private-knowledge.ts
+init_common();
+var UPSERT_TOOL_NAME = "vo_private_knowledge_upsert";
+var CONTEXT_TOOL_NAME = "vo_private_knowledge_context";
+var KNOWLEDGE_CLASSES = ["memory", "skill", "doctrine", "hook", "command"];
+var PRECISION_CHAR_BUDGET = 12e3;
+var upsertInputSchema = {
+  type: "object",
+  properties: {
+    knowledge_class: { type: "string", enum: KNOWLEDGE_CLASSES },
+    source_path: { type: "string", description: "Stable private source identifier; not exposed to other users." },
+    title: { type: "string", description: 'Descriptive, retrieval-friendly title (e.g. "AlgoTax OCR redaction architecture", not "notes") \u2014 retrieval matches on it.' },
+    content: { type: "string", description: "Private knowledge text to store server-side. Keep each entry tight and focused (~1-3 pages, under ~12k chars); split larger corpora into separate entries." }
+  },
+  required: ["knowledge_class", "source_path", "title", "content"],
+  additionalProperties: false
+};
+var contextInputSchema = {
+  type: "object",
+  properties: {
+    query: { type: "string" },
+    limit: { type: "number", minimum: 1, maximum: 50 },
+    knowledge_class: { type: "string", enum: KNOWLEDGE_CLASSES }
+  },
+  required: ["query"],
+  additionalProperties: false
+};
+var upsertDescription = "Uploads or refreshes the authenticated operator\u2019s private cloud knowledge. Works for Claude, Codex, Cursor, and cowork clients via the same vo-mcp login credential. Returns metadata only, not raw stored content. PRECISION DISCIPLINE: keep each entry tight and focused (~1-3 pages) with a descriptive retrieval-friendly title \u2014 retrieval surfaces whole entries, so small dense entries beat bulk dumps. Split large corpora into focused entries, then run a retrieval self-test via vo_private_knowledge_context before relying on the knowledge.";
+var contextDescription = "Retrieves prompt-ready private knowledge context for the authenticated operator. Returns snippets/context only; no raw corpus download. Also the retrieval self-test surface: after upserting critical knowledge, query for it here and confirm the entry surfaces before trusting it in downstream work.";
+function isKnowledgeClass(value) {
+  return typeof value === "string" && KNOWLEDGE_CLASSES.includes(value);
+}
+function isUpsertInput(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const input = value;
+  return isKnowledgeClass(input["knowledge_class"]) && typeof input["source_path"] === "string" && typeof input["title"] === "string" && typeof input["content"] === "string";
+}
+function isContextInput(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const input = value;
+  if (typeof input["query"] !== "string") return false;
+  if (input["limit"] !== void 0 && typeof input["limit"] !== "number") return false;
+  if (input["knowledge_class"] !== void 0 && !isKnowledgeClass(input["knowledge_class"])) return false;
+  return true;
+}
+async function getCloudAuth(fetchFn) {
+  const controlPlaneUrl = process.env["VO_CONTROL_PLANE_URL"]?.replace(/\/+$/, "");
+  if (!controlPlaneUrl) {
+    return { ok: false, reason: "VO_CONTROL_PLANE_URL not set \u2014 cloud mode disabled" };
+  }
+  const { createAuthTokenSourceFromEnv: createAuthTokenSourceFromEnv2 } = await Promise.resolve().then(() => (init_auth_token_source(), auth_token_source_exports));
+  const { readStoredCredential: readStoredCredential2 } = await Promise.resolve().then(() => (init_credential_store(), credential_store_exports));
+  const tokenSource = createAuthTokenSourceFromEnv2(process.env, fetchFn, () => readStoredCredential2(process.env));
+  if (!tokenSource) return { ok: false, reason: "No auth configured. Run `vo-mcp login`." };
+  const token = await tokenSource.getToken();
+  if (!token) return { ok: false, reason: "Failed to obtain auth token. Run `vo-mcp login` again." };
+  return { ok: true, controlPlaneUrl, token };
+}
+async function callPrivateKnowledge(path3, body, fetchFn) {
+  const auth = await getCloudAuth(fetchFn);
+  if (!auth.ok) return { ok: false, reason: auth.reason };
+  const response = await fetchFn(`${auth.controlPlaneUrl}${path3}`, {
+    method: "POST",
+    headers: {
+      authorization: `Bearer ${auth.token}`,
+      "content-type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  const text = await response.text();
+  const parsed = text ? JSON.parse(text) : null;
+  if (response.status < 200 || response.status >= 300) {
+    return { ok: false, status: response.status, response: parsed ?? text };
+  }
+  return parsed;
+}
+async function handlePrivateKnowledgeUpsert(_deps, rawInput, _signal, fetchFn = globalThis.fetch) {
+  if (!isUpsertInput(rawInput)) {
+    throw invalidParams(UPSERT_TOOL_NAME, "expected { knowledge_class, source_path, title, content }.");
+  }
+  const payload = await callPrivateKnowledge("/api/v1/knowledge/private", rawInput, fetchFn);
+  const envelope = {
+    tool: UPSERT_TOOL_NAME,
+    schema_version: 1,
+    payload
+  };
+  if (rawInput.content.length > PRECISION_CHAR_BUDGET) {
+    envelope.precision_note = `content is ${rawInput.content.length} chars (> ${PRECISION_CHAR_BUDGET}). Tight 1-3 page entries retrieve better \u2014 consider splitting into focused entries, then re-test retrieval via ${CONTEXT_TOOL_NAME}.`;
+  }
+  return jsonContent(envelope);
+}
+async function handlePrivateKnowledgeContext(_deps, rawInput, _signal, fetchFn = globalThis.fetch) {
+  if (!isContextInput(rawInput)) {
+    throw invalidParams(CONTEXT_TOOL_NAME, "expected { query, optional limit, optional knowledge_class }.");
+  }
+  const payload = await callPrivateKnowledge("/api/v1/knowledge/private/context", rawInput, fetchFn);
+  return jsonContent({ tool: CONTEXT_TOOL_NAME, schema_version: 1, payload });
+}
+
+// src/server.ts
 function buildToolRegistry() {
   return {
     [TOOL_NAME]: {
@@ -5610,6 +5770,22 @@ function buildToolRegistry() {
         inputSchema: inputSchema22
       },
       handler: handleSyncConfig
+    },
+    [UPSERT_TOOL_NAME]: {
+      definition: {
+        name: UPSERT_TOOL_NAME,
+        description: upsertDescription,
+        inputSchema: upsertInputSchema
+      },
+      handler: handlePrivateKnowledgeUpsert
+    },
+    [CONTEXT_TOOL_NAME]: {
+      definition: {
+        name: CONTEXT_TOOL_NAME,
+        description: contextDescription,
+        inputSchema: contextInputSchema
+      },
+      handler: handlePrivateKnowledgeContext
     }
   };
 }
@@ -5901,6 +6077,64 @@ function createNullConsensusEngineClient(reason = NULL_CLIENT_DEFAULT_REASON) {
   };
 }
 
+// src/consensus/meta-model-caller.ts
+var META_MODEL_API_BASE_URL = "https://api.meta.ai/v1";
+var META_CONSENSUS_MODEL = "muse-spark-1.1";
+var META_MODEL_API_KEY_ENV = "MODEL_API_KEY";
+var META_MODEL_API_KEY_ALIAS = "META_API";
+function resolveMetaKey(env) {
+  return String(env[META_MODEL_API_KEY_ENV] || env[META_MODEL_API_KEY_ALIAS] || "").trim();
+}
+function positiveMaxTokens(value) {
+  const parsed = Math.floor(Number(value));
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 2048;
+}
+function createMetaModelCaller(options = {}) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const envSource = options.envSource ?? process.env;
+  const reasoningEffort = options.reasoningEffort ?? "high";
+  return async function callMetaWithMetrics2(prompt, systemPrompt, model, maxTokens, _privacyOptions, signal) {
+    const key = resolveMetaKey(envSource);
+    if (!key) throw new Error(`Missing ${META_MODEL_API_KEY_ENV} for Meta Model API`);
+    const messages = [
+      ...systemPrompt ? [{ role: "system", content: systemPrompt }] : [],
+      { role: "user", content: prompt }
+    ];
+    const response = await fetchImpl(`${META_MODEL_API_BASE_URL}/chat/completions`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${key}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: model || META_CONSENSUS_MODEL,
+        messages,
+        max_tokens: positiveMaxTokens(maxTokens),
+        reasoning_effort: reasoningEffort
+      }),
+      signal
+    });
+    const payload = await response.json();
+    if (!response.ok) {
+      const message = String(payload.error?.message || response.statusText || "request failed").slice(0, 500);
+      throw Object.assign(new Error(`Meta Model API ${response.status}: ${message}`), { status: response.status });
+    }
+    const content = payload.choices?.[0]?.message?.content;
+    if (typeof content !== "string" || !content.trim()) {
+      throw new Error(`Meta Model API returned no text (finish=${payload.choices?.[0]?.finish_reason || "unknown"})`);
+    }
+    const inputTokens = Number(payload.usage?.prompt_tokens || 0);
+    const outputTokens = Number(payload.usage?.completion_tokens || 0);
+    return {
+      content,
+      inputTokens,
+      outputTokens,
+      totalTokens: Number(payload.usage?.total_tokens || inputTokens + outputTokens)
+    };
+  };
+}
+var callMetaWithMetrics = createMetaModelCaller();
+
 // src/consensus/engine-options.ts
 var AGREEMENT_GATE_ENV_VAR = "VO_CONSENSUS_AGREEMENT_GATE";
 function isTruthyFlag(raw) {
@@ -6195,7 +6429,8 @@ var DEFAULT_MODELS = {
   // callGeminiWithMetrics; 2.5-pro REJECTS budget 0 ("only works in thinking mode").
   // Flash is also ~10x cheaper. 2026-06-02.
   google: "gemini-2.5-flash",
-  deepseek: "deepseek-chat"
+  deepseek: "deepseek-chat",
+  meta: META_CONSENSUS_MODEL
 };
 function probeProviders(env = process.env) {
   const out = [];
@@ -6203,6 +6438,7 @@ function probeProviders(env = process.env) {
   if ((env["OPENAI_API_KEY"] ?? "").trim().length > 0) out.push("openai");
   if ((env["GOOGLE_API_KEY"] ?? "").trim().length > 0) out.push("google");
   if ((env["DEEPSEEK_API_KEY"] ?? "").trim().length > 0) out.push("deepseek");
+  if ((env[META_MODEL_API_KEY_ENV] ?? "").trim().length > 0 || (env[META_MODEL_API_KEY_ALIAS] ?? "").trim().length > 0) out.push("meta");
   return out;
 }
 async function loadFactoryAndCallers(injectedEngine, injectedShared) {
@@ -6248,21 +6484,24 @@ async function tryCreateEngineConsensusClientFromEnvAsync(options = {}) {
     anthropic: loaded.shared.callAnthropicWithMetrics,
     openai: loaded.shared.callOpenAIWithMetrics,
     google: loaded.shared.callGeminiWithMetrics,
-    deepseek: loaded.shared.callDeepSeekWithMetrics
+    deepseek: loaded.shared.callDeepSeekWithMetrics,
+    meta: options.metaCaller ?? callMetaWithMetrics
   };
   const modelByProvider = {
     anthropic: options.models?.anthropic ?? DEFAULT_MODELS.anthropic,
     openai: options.models?.openai ?? DEFAULT_MODELS.openai,
     google: options.models?.google ?? DEFAULT_MODELS.google,
-    deepseek: options.models?.deepseek ?? DEFAULT_MODELS.deepseek
+    deepseek: options.models?.deepseek ?? DEFAULT_MODELS.deepseek,
+    meta: options.models?.meta ?? DEFAULT_MODELS.meta
   };
+  const adapterEnv = !(env[META_MODEL_API_KEY_ENV] ?? "").trim() && (env[META_MODEL_API_KEY_ALIAS] ?? "").trim() ? { ...env, [META_MODEL_API_KEY_ENV]: env[META_MODEL_API_KEY_ALIAS] } : env;
   const panel = [];
   for (const p of providers) {
     try {
       const adapter = loaded.engine.createAdapter(p, {
         model: modelByProvider[p],
         caller: callerByProvider[p],
-        envSource: env
+        envSource: adapterEnv
       });
       panel.push(adapter);
     } catch {
@@ -6484,7 +6723,7 @@ async function runLogin(opts = {}) {
   const nowIso = opts.nowIso ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   const openBrowser = opts.openBrowser ?? defaultOpenBrowser;
   const state = randomBytes(32).toString("base64url");
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     let settled = false;
     const finish = (err, result) => {
       if (settled) return;
@@ -6492,7 +6731,7 @@ async function runLogin(opts = {}) {
       clearTimeout(timer);
       server.close();
       if (err) reject(err);
-      else resolve(result);
+      else resolve2(result);
     };
     const server = createServer2((req, res) => {
       const url = new URL(req.url ?? "/", "http://127.0.0.1");