@llamaventures/cli 1.15.1 → 1.17.0

package/bin/llama-mcp.mjs

@@ -8,10 +8,19 @@
 // CLI: gcloud (preferred) → $LLAMA_TOKEN → ~/.llama/token.
 
 import { createRequire } from "module";
+import { randomUUID } from "crypto";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { getAuthHeaders, readBriefing, request, requestSse } from "../lib/client.mjs";
+import {
+  getAuthHeaders,
+  getBaseUrl,
+  getLastAgentEvent,
+  readBriefing,
+  request,
+  requestSse,
+  setClientRuntime,
+} from "../lib/client.mjs";
 
 const requireFromHere = createRequire(import.meta.url);
 const { version: PKG_VERSION } = requireFromHere("../package.json");
@@ -23,13 +32,28 @@ import {
   uploadExternalFile,
 } from "../lib/external.mjs";
 
+setClientRuntime({ client: "mcp" });
+
+function newHtmlUploadId() {
+  return `mcp-${randomUUID()}`;
+}
+
+function normalizeUploadId(value) {
+  if (typeof value !== "string" || !value.trim()) return null;
+  const id = value.trim();
+  if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(id)) {
+    throw new Error("clientUploadId must be 1-128 chars: letters, numbers, dot, underscore, colon, or hyphen");
+  }
+  return id;
+}
+
 // Wrap a request() call into the MCP CallToolResult shape. Catches errors
 // (NO_AUTH / 401 / 5xx / network) and surfaces them as `isError: true`
 // content so the calling agent sees a clean error string instead of the
 // MCP transport closing.
-async function callApi(method, path, body) {
+async function callApi(method, path, body, opts = {}) {
   try {
-    const result = await request(method, path, body);
+    const result = await request(method, path, body, opts);
     const text = typeof result === "string" ? result : JSON.stringify(result, null, 2);
     return { content: [{ type: "text", text }] };
   } catch (err) {
@@ -47,6 +71,10 @@ function textResult(text, isError = false) {
   };
 }
 
+function jsonResult(value, isError = false) {
+  return textResult(JSON.stringify(value, null, 2), isError);
+}
+
 function splitSources(value) {
   if (Array.isArray(value)) return value.filter(Boolean);
   if (!value || value === true) return undefined;
@@ -56,6 +84,20 @@ function splitSources(value) {
     .filter(Boolean);
 }
 
+function expectedIds(value) {
+  const expected = { dealIds: [], wikiSlugs: [], raw: [] };
+  if (!value) return expected;
+  const items = Array.isArray(value) ? value : String(value).split(",");
+  for (const item of items.map((s) => String(s).trim()).filter(Boolean)) {
+    const [kind, ...rest] = item.split(":");
+    const id = rest.join(":").trim();
+    if (kind === "deal" && id) expected.dealIds.push(id);
+    else if ((kind === "wiki" || kind === "slug") && id) expected.wikiSlugs.push(id);
+    else expected.raw.push(item);
+  }
+  return expected;
+}
+
 function buildEnrichmentAgentMessage(args = {}) {
   if (args.message) return String(args.message);
   const sources = splitSources(args.sources) ?? [
@@ -209,11 +251,47 @@ server.registerTool(
   },
   async ({ limit } = {}) => {
     const params = new URLSearchParams();
+    params.set("clientVersion", PKG_VERSION);
     if (limit) params.set("limit", String(limit));
     return callApi("GET", `/api/agent/manifest${params.toString() ? `?${params}` : ""}`);
   }
 );
 
+server.registerTool(
+  "record_eval_feedback",
+  {
+    description:
+      "Mark the latest llama CLI/MCP result as good/bad or add a real query " +
+      "to the Golden Query Eval candidate pool. Use when the user says a " +
+      "Llama Command search/result was right, wrong, missing a source, or should be regression-tested.",
+    inputSchema: {
+      action: z.enum(["good", "bad", "add"]).describe("feedback action"),
+      eventId: z.number().optional().describe("agent_client_events id; defaults to latest local event"),
+      query: z.string().optional().describe("required for manual add when no source event is available"),
+      surface: z.string().optional().describe("deal, wiki, activity, people, or manual"),
+      expect: z
+        .union([z.string(), z.array(z.string())])
+        .optional()
+        .describe("expected ids like wiki:llamaos-weekly-2026-06-17 or deal:<uuid>"),
+      reason: z.string().optional().describe("why this was good/bad or should be tracked"),
+      privacyLevel: z.string().optional().describe("default internal"),
+    },
+  },
+  async ({ action, eventId, query, surface, expect, reason, privacyLevel }) => {
+    const last = getLastAgentEvent();
+    const body = {
+      action,
+      eventId: eventId ?? last?.lastEventId,
+      query,
+      surface: surface ?? last?.lastSurface,
+      expected: expectedIds(expect),
+      reason,
+      privacyLevel: privacyLevel ?? "internal",
+    };
+    return callApi("POST", "/api/agent/eval-feedback", body);
+  }
+);
+
 server.registerTool(
   "skills_search",
   {
@@ -1320,17 +1398,230 @@ server.registerTool(
 // All html_* tools take an optional documentSlug param. Default 'main'.
 // Each deal can hold multiple named documents (different HTMLs); use
 // html_docs_list to discover slugs.
+const INLINE_HTML_UPLOAD_LIMIT = 50 * 1024;
+const MAX_HTML_BYTES = 5 * 1024 * 1024;
+const MAX_ASSET_BYTES = 50 * 1024 * 1024;
+const MAX_BUNDLE_BYTES = 100 * 1024 * 1024;
+
 function htmlUrl(dealId, slug) {
   return `/api/deals/${encodeURIComponent(dealId)}/documents/${encodeURIComponent(slug ?? "main")}/html`;
 }
 
+function looksLikeHtml(html) {
+  const head = String(html || "").trim().slice(0, 256).toLowerCase();
+  return head.startsWith("<!doctype html") || head.startsWith("<html");
+}
+
+function mimeForAsset(path) {
+  const ext = (String(path).split(".").pop() || "").toLowerCase();
+  return (
+    {
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      png: "image/png",
+      gif: "image/gif",
+      webp: "image/webp",
+      svg: "image/svg+xml",
+      ico: "image/x-icon",
+      avif: "image/avif",
+      css: "text/css",
+      js: "text/javascript",
+      json: "application/json",
+      woff: "font/woff",
+      woff2: "font/woff2",
+      ttf: "font/ttf",
+      otf: "font/otf",
+      mp4: "video/mp4",
+      webm: "video/webm",
+      pdf: "application/pdf",
+    }[ext] || "application/octet-stream"
+  );
+}
+
+async function detectSiblingAssetsDir(filePath) {
+  const { existsSync, statSync } = await import("node:fs");
+  const { dirname, basename, extname, join } = await import("node:path");
+  const dir = dirname(filePath);
+  const stem = basename(filePath, extname(filePath));
+  const candidates = [
+    `${stem}_files`,
+    `${stem} files`,
+    `${basename(filePath)}_files`,
+  ];
+  for (const name of candidates) {
+    const p = join(dir, name);
+    if (existsSync(p) && statSync(p).isDirectory()) return p;
+  }
+  return null;
+}
+
+async function collectAssets(assetsRoot) {
+  const { readFileSync, readdirSync, statSync } = await import("node:fs");
+  const { join, relative, sep, basename } = await import("node:path");
+  const rootStat = statSync(assetsRoot);
+  if (!rootStat.isDirectory()) {
+    throw new Error(`assetsDir must point to a directory: ${assetsRoot}`);
+  }
+  const collected = [];
+  const walk = (dir) => {
+    for (const name of readdirSync(dir)) {
+      const absPath = join(dir, name);
+      const st = statSync(absPath);
+      if (st.isDirectory()) {
+        walk(absPath);
+      } else if (st.isFile()) {
+        const relPath = relative(assetsRoot, absPath).split(sep).join("/");
+        collected.push({ absPath, relPath, bytes: st.size });
+      }
+    }
+  };
+  walk(assetsRoot);
+  if (collected.length === 0) {
+    throw new Error(`assetsDir is empty: ${assetsRoot}`);
+  }
+  const rootName = basename(assetsRoot);
+  const looksLikeSavePageDir = /[_ ]files$/i.test(rootName);
+  const finalPaths = looksLikeSavePageDir
+    ? collected.map((c) => ({ ...c, relPath: `${rootName}/${c.relPath}` }))
+    : collected;
+  let totalBytes = 0;
+  for (const item of finalPaths) {
+    if (item.relPath.split("/").some((seg) => seg === "..")) {
+      throw new Error(`asset path "${item.relPath}" contains "..", refused`);
+    }
+    if (item.bytes > MAX_ASSET_BYTES) {
+      throw new Error(
+        `asset "${item.relPath}" is ${item.bytes} bytes; cap is ${MAX_ASSET_BYTES}`,
+      );
+    }
+    totalBytes += item.bytes;
+    if (totalBytes > MAX_BUNDLE_BYTES) {
+      throw new Error(`total asset bytes exceeds ${MAX_BUNDLE_BYTES}`);
+    }
+  }
+  return {
+    assets: finalPaths.map((item) => ({
+      ...item,
+      data: readFileSync(item.absPath),
+      contentType: mimeForAsset(item.relPath),
+    })),
+    totalBytes,
+  };
+}
+
+async function uploadHtmlFromFile({
+  dealId,
+  filePath,
+  documentSlug,
+  source = "agent",
+  assetsDir,
+  autoDetectAssets = true,
+  verify = true,
+  clientUploadId,
+}) {
+  const { readFileSync, statSync } = await import("node:fs");
+  const st = statSync(filePath);
+  if (!st.isFile()) throw new Error(`filePath must point to a file: ${filePath}`);
+  const html = readFileSync(filePath, "utf8");
+  if (!html.trim()) throw new Error("HTML body is empty.");
+  const htmlBytes = Buffer.byteLength(html, "utf8");
+  if (htmlBytes > MAX_HTML_BYTES) {
+    throw new Error(
+      `HTML body is ${(htmlBytes / 1024 / 1024).toFixed(2)} MB; cap is 5 MB.`,
+    );
+  }
+  if (!looksLikeHtml(html)) {
+    throw new Error("HTML must start with <!doctype html> or <html.");
+  }
+
+  let effectiveAssetsDir = assetsDir || null;
+  if (!effectiveAssetsDir && autoDetectAssets !== false) {
+    effectiveAssetsDir = await detectSiblingAssetsDir(filePath);
+  }
+  const uploadId = normalizeUploadId(clientUploadId) || newHtmlUploadId();
+
+  let body;
+  if (!effectiveAssetsDir) {
+    body = await request("PUT", htmlUrl(dealId, documentSlug), {
+      html,
+      source,
+      client_upload_id: uploadId,
+    }, {
+      headers: { "X-Llama-Upload-Id": uploadId },
+    });
+  } else {
+    const { assets, totalBytes } = await collectAssets(effectiveAssetsDir);
+    const form = new FormData();
+    form.append("html", html);
+    form.append("source", source);
+    form.append("client_upload_id", uploadId);
+    for (const asset of assets) {
+      form.append(
+        `asset:${asset.relPath}`,
+        new Blob([asset.data], { type: asset.contentType }),
+        asset.relPath,
+      );
+    }
+    const headers = await getAuthHeaders();
+    const res = await fetch(`${getBaseUrl()}${htmlUrl(dealId, documentSlug)}`, {
+      method: "PUT",
+      headers: { ...headers, "X-Llama-Upload-Id": uploadId },
+      body: form,
+    });
+    body = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      throw new Error(
+        `HTTP ${res.status}: ${body?.error || JSON.stringify(body).slice(0, 300)}`,
+      );
+    }
+    body = { ...body, asset_bytes: body.asset_bytes ?? totalBytes };
+  }
+
+  let verified = { ok: false, skipped: true };
+  if (verify !== false) {
+    const latest = await request("GET", htmlUrl(dealId, documentSlug));
+    if (latest?.empty) throw new Error("verification failed: document came back empty after upload");
+    if (body?.version != null && Number(latest.version) !== Number(body.version)) {
+      throw new Error(`verification failed: expected version ${body.version}, got ${latest.version}`);
+    }
+    if (body?.bytes != null && latest.bytes != null && Number(latest.bytes) !== Number(body.bytes)) {
+      throw new Error(`verification failed: expected ${body.bytes} bytes, got ${latest.bytes}`);
+    }
+    if (body?.sha256 && latest.sha256 && String(latest.sha256) !== String(body.sha256)) {
+      throw new Error(`verification failed: expected sha256 ${body.sha256}, got ${latest.sha256}`);
+    }
+    verified = {
+      ok: true,
+      version: latest.version,
+      bytes: latest.bytes,
+      sha256: latest.sha256,
+      created_at: latest.created_at,
+    };
+  }
+
+  return {
+    ok: true,
+    document_slug: documentSlug || "main",
+    version: body?.version,
+    bytes: body?.bytes ?? verified.bytes ?? htmlBytes,
+    sha256: body?.sha256 ?? verified.sha256,
+    client_upload_id: body?.client_upload_id ?? uploadId,
+    idempotent_replay: body?.idempotent_replay,
+    asset_count: body?.asset_count,
+    asset_bytes: body?.asset_bytes,
+    assets_dir: effectiveAssetsDir,
+    verified,
+    viewer: `${getBaseUrl()}/deals/${encodeURIComponent(dealId)}/browse/${encodeURIComponent(documentSlug || "main")}`,
+  };
+}
+
 server.registerTool(
   "html_show",
   {
     description:
       "Read the current hand-authored HTML 'deal page' for a deal. " +
       "Returns {empty: true} if no one has uploaded HTML yet, or " +
-      "{empty: false, version, html, bytes, uploaded_by, source, " +
+      "{empty: false, version, html, bytes, sha256, uploaded_by, source, " +
       "created_at}. The HTML can be 5-500KB — be deliberate about " +
       "including the body in your reply. Use html_versions if you " +
       "just want the version list without the body. Each deal can " +
@@ -1365,7 +1656,9 @@ server.registerTool(
       "Creates a NEW version row — the previous version is retained " +
       "and restorable. Triggers SSE push so any open viewer auto- " +
       "refreshes. Constraints: HTML body MUST start with " +
-      "<!doctype html> or <html (case-insensitive); max 5 MB. ALWAYS " +
+      "<!doctype html> or <html (case-insensitive); max 5 MB. Reliability guard: " +
+      "this inline-string tool refuses bodies over 50KB; use html_upload_file " +
+      "or `llama html publish --file` for memos/reports. ALWAYS " +
       "call html_show first if anything exists — replace only the " +
       "relevant section, don't lose unrelated content. Source defaults " +
       "to 'agent' for MCP-originated uploads. Pass documentSlug to " +
@@ -1381,13 +1674,76 @@ server.registerTool(
         .enum(["web", "cli", "agent"])
         .optional()
         .describe("default: agent"),
+      clientUploadId: z.string().optional().describe("optional retry id; reuse the same value if retrying the same small inline upload"),
     },
   },
-  async ({ dealId, html, documentSlug, source }) =>
-    callApi("PUT", htmlUrl(dealId, documentSlug), {
+  async ({ dealId, html, documentSlug, source, clientUploadId }) => {
+    const bytes = Buffer.byteLength(String(html || ""), "utf8");
+    if (bytes > INLINE_HTML_UPLOAD_LIMIT) {
+      return textResult(
+        `Error: html_upload received ${(bytes / 1024).toFixed(1)} KB of inline HTML. ` +
+          `For reliability, do not pass large HTML through MCP tool arguments. ` +
+          `Use html_upload_file({ dealId, filePath, documentSlug }) or run ` +
+          `\`llama html publish <deal-id-or-name> --file <path> --doc <slug>\` instead.`,
+        true,
+      );
+    }
+    let uploadId;
+    try {
+      uploadId = normalizeUploadId(clientUploadId) || newHtmlUploadId();
+    } catch (err) {
+      return textResult(`Error: ${err?.message ?? String(err)}`, true);
+    }
+    return callApi("PUT", htmlUrl(dealId, documentSlug), {
       html,
       source: source ?? "agent",
-    })
+      client_upload_id: uploadId,
+    }, {
+      headers: { "X-Llama-Upload-Id": uploadId },
+    });
+  }
+);
+
+server.registerTool(
+  "html_upload_file",
+  {
+    description:
+      "Agent-safe HTML upload from a LOCAL FILE PATH. Use this instead " +
+      "of html_upload for any substantial memo/report; it avoids moving " +
+      "large HTML through the model/tool-call context. Reads filePath on " +
+      "the machine running this MCP server, preflights size/HTML shape, " +
+      "optionally auto-detects a sibling *_files asset folder, uploads, " +
+      "then reads the document back to verify version/bytes/sha256. For a higher " +
+      "level CLI flow that can resolve deal names and choose create/update, " +
+      "run `llama html publish <deal-id-or-name> --file <path>`.",
+    inputSchema: {
+      dealId: z.string().describe("deal uuid"),
+      filePath: z.string().describe("absolute or relative local filesystem path to the HTML file"),
+      documentSlug: z.string().optional().describe("default: 'main'"),
+      source: z.enum(["web", "cli", "agent"]).optional().describe("default: agent"),
+      assetsDir: z.string().optional().describe("optional local directory of relative assets"),
+      autoDetectAssets: z.boolean().optional().describe("default true; detects sibling *_files folders"),
+      verify: z.boolean().optional().describe("default true; read-after-write verification"),
+      clientUploadId: z.string().optional().describe("optional retry id; reuse the same value if retrying the same failed upload"),
+    },
+  },
+  async ({ dealId, filePath, documentSlug, source, assetsDir, autoDetectAssets, verify, clientUploadId }) => {
+    try {
+      const result = await uploadHtmlFromFile({
+        dealId,
+        filePath,
+        documentSlug,
+        source: source ?? "agent",
+        assetsDir,
+        autoDetectAssets,
+        verify,
+        clientUploadId,
+      });
+      return jsonResult(result);
+    } catch (err) {
+      return textResult(`Error: ${err?.message ?? String(err)}`, true);
+    }
+  },
 );
 
 server.registerTool(
@@ -1395,7 +1751,7 @@ server.registerTool(
   {
     description:
       "List version history for a deal's /browse page HTML. Returns " +
-      "an array of {version, bytes, uploaded_by, source, created_at, " +
+      "an array of {version, bytes, sha256, uploaded_by, source, created_at, " +
       "deleted_at} — newest first, including soft-deleted versions. " +
       "Use to find a target version for html_restore.",
     inputSchema: {
@@ -1488,11 +1844,12 @@ server.registerTool(
   "html_upload_bundle",
   {
     description:
-      "Upload HTML + binary assets as one atomic version. Use this " +
-      "INSTEAD of html_upload when the HTML references local images / " +
-      "fonts / CSS files via relative src=/href= attributes (typical " +
-      "of 'Save Page As Complete' exports). The server stores HTML + " +
-      "each asset as one transactional bundle (deal_browse_assets " +
+      "Legacy small inline upload for HTML + binary assets as one atomic version. " +
+      "For substantial memos/reports or 'Save Page As Complete' exports, use " +
+      "html_upload_file with filePath + assetsDir instead so large HTML/assets " +
+      "do not move through the model/tool-call context. This inline bundle " +
+      "tool refuses payloads over 50KB. The server stores HTML + each asset as " +
+      "one transactional bundle (deal_browse_assets " +
       "table), rewrites the HTML refs to version-pinned URLs at " +
       "/api/deals/<id>/asset/<path>?v=N, and triggers SSE push. " +
       "Constraints: HTML <= 5 MB; each asset <= 50 MB; total bundle " +
@@ -1528,12 +1885,32 @@ server.registerTool(
         .enum(["web", "cli", "agent"])
         .optional()
         .describe("default: agent"),
+      clientUploadId: z.string().optional().describe("optional retry id; reuse the same value if retrying the same bundle upload"),
     },
   },
-  async ({ dealId, html, assets, documentSlug, source }) => {
+  async ({ dealId, html, assets, documentSlug, source, clientUploadId }) => {
+    const inlineBytes =
+      Buffer.byteLength(String(html || ""), "utf8") +
+      assets.reduce((sum, a) => sum + Buffer.byteLength(String(a.base64 || ""), "utf8"), 0);
+    if (inlineBytes > INLINE_HTML_UPLOAD_LIMIT) {
+      return textResult(
+        `Error: html_upload_bundle received ${(inlineBytes / 1024).toFixed(1)} KB of inline tool-call payload. ` +
+          `For reliability, do not pass large HTML/assets through MCP arguments. ` +
+          `Use html_upload_file({ dealId, filePath, documentSlug, assetsDir }) or run ` +
+          `\`llama html publish <deal-id-or-name> --file <path> --assets <dir>\` instead.`,
+        true,
+      );
+    }
+    let uploadId;
+    try {
+      uploadId = normalizeUploadId(clientUploadId) || newHtmlUploadId();
+    } catch (err) {
+      return textResult(`Error: ${err?.message ?? String(err)}`, true);
+    }
     const form = new FormData();
     form.append("html", html);
     form.append("source", source ?? "agent");
+    form.append("client_upload_id", uploadId);
     for (const a of assets) {
       const bytes = Buffer.from(a.base64, "base64");
       form.append(
@@ -1545,7 +1922,7 @@ server.registerTool(
     const headers = await getAuthHeaders();
     const res = await fetch(`${getBaseUrl()}${htmlUrl(dealId, documentSlug)}`, {
       method: "PUT",
-      headers, // let fetch set multipart Content-Type with boundary
+      headers: { ...headers, "X-Llama-Upload-Id": uploadId }, // let fetch set multipart Content-Type with boundary
       body: form,
     });
     const body = await res.json().catch(() => ({}));
@@ -1595,11 +1972,12 @@ server.registerPrompt(
       "skills_search, and skills_read.",
   },
   async () => {
-    // Gate the briefing behind a /api/me check so unauthenticated MCP
-    // clients can't harvest internal workflow / command surface just by
-    // requesting the prompt. Mirrors the CLI gate in bin/llama.mjs.
+    // Gate the briefing behind authenticated Command runtime. The server-owned
+    // /api/agent/briefing contract is canonical; bundled AGENT_BRIEFING.md is
+    // only a rollout/offline fallback for authenticated users.
     const headers = await getAuthHeaders();
     let stub = null;
+    let briefing = null;
     if (Object.keys(headers).length === 0) {
       stub =
         "Llama Ventures team onboarding requires credentials.\n\n" +
@@ -1610,19 +1988,28 @@ server.registerPrompt(
         "Founder / external visitor: use the `pitch_*` tools — no token required.";
     } else {
       try {
-        await request("GET", "/api/me");
+        const params = new URLSearchParams({ clientVersion: PKG_VERSION });
+        const body = await request("GET", `/api/agent/briefing?${params}`);
+        briefing = body?.briefing || null;
       } catch (err) {
-        stub =
-          "Llama Ventures team onboarding requires valid credentials. " +
-          "Server rejected the credentials we sent. Re-mint at " +
-          "https://command.llamaventures.vc/settings/tokens.";
+        const msg = err?.message || "";
+        if (msg.includes("Error[UNAUTHORIZED]") || msg.includes("Error[NO_AUTH]")) {
+          stub =
+            "Llama Ventures team onboarding requires valid credentials. " +
+            "Server rejected the credentials we sent. Re-mint at " +
+            "https://command.llamaventures.vc/settings/tokens.";
+        } else {
+          briefing =
+            "Warning: server agent briefing unavailable; using bundled fallback.\n\n" +
+            readBriefing();
+        }
       }
     }
     return {
       messages: [
         {
           role: "user",
-          content: { type: "text", text: stub ?? readBriefing() },
+          content: { type: "text", text: stub ?? briefing ?? readBriefing() },
         },
       ],
     };