negotium 0.2.9 → 0.2.11

package/dist/runtime/src/agents/mcp-tools/inline-assets.ts

@@ -0,0 +1,193 @@
+/**
+ * Inline local file references in an HTML document as data URIs.
+ *
+ * A published snippet is a single file with no asset directory, so a
+ * generated document that points at `./chart.png` would render a broken
+ * image. Rewriting those references into `data:` URIs keeps the snippet
+ * self-contained without giving the store a second lifecycle to manage.
+ *
+ * Only references that resolve to an existing local file are touched.
+ * Remote URLs, `data:`/`blob:` URIs, protocol-relative URLs and fragments
+ * are left exactly as written.
+ *
+ * The scanner is regex-based rather than a full HTML parse. That is a
+ * deliberate tradeoff for machine-generated documents: it handles the
+ * attribute shapes models actually emit, and anything it fails to match is
+ * simply left alone rather than corrupted.
+ */
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { extname, isAbsolute, resolve } from "node:path";
+
+const MIME_BY_EXT: Record<string, string> = {
+  ".apng": "image/apng",
+  ".avif": "image/avif",
+  ".bmp": "image/bmp",
+  ".css": "text/css",
+  ".gif": "image/gif",
+  ".ico": "image/x-icon",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".mp3": "audio/mpeg",
+  ".mp4": "video/mp4",
+  ".otf": "font/otf",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".ttf": "font/ttf",
+  ".wav": "audio/wav",
+  ".webm": "video/webm",
+  ".webp": "image/webp",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+};
+
+export interface InlineOptions {
+  /** Directory that relative references resolve against. */
+  baseDir: string;
+  /** Skip any single asset larger than this. */
+  maxAssetBytes: number;
+  /** Stop inlining once the document would exceed this. */
+  maxTotalBytes: number;
+}
+
+export interface InlineReport {
+  html: string;
+  inlined: { ref: string; bytes: number }[];
+  /** Looked like a local file but nothing was there — likely a broken image. */
+  unresolved: string[];
+  /** Existed but was left as-is; the document would have grown too large. */
+  skipped: { ref: string; bytes: number; reason: "asset-too-large" | "document-too-large" }[];
+}
+
+/** Remote URL, data/blob URI, protocol-relative URL, or bare fragment. */
+function isNonLocal(ref: string): boolean {
+  return /^(?:[a-z][a-z0-9+.-]*:|\/\/|#)/i.test(ref.trim());
+}
+
+/** `./chart.png?v=2#frag` → `./chart.png` */
+function stripSuffix(ref: string): string {
+  return ref.replace(/[?#].*$/, "");
+}
+
+export function inlineLocalAssets(html: string, options: InlineOptions): InlineReport {
+  const { baseDir, maxAssetBytes, maxTotalBytes } = options;
+
+  const inlined: InlineReport["inlined"] = [];
+  const unresolved: string[] = [];
+  const skipped: InlineReport["skipped"] = [];
+
+  // Same file referenced twice should only be read (and counted) once.
+  const cache = new Map<string, string | null>();
+  let budget = maxTotalBytes - Buffer.byteLength(html, "utf-8");
+
+  /** Returns the data URI for a reference, or null to leave it untouched. */
+  function toDataUri(rawRef: string): string | null {
+    const ref = rawRef.trim();
+    if (!ref || isNonLocal(ref)) return null;
+
+    const cached = cache.get(ref);
+    if (cached !== undefined) return cached;
+
+    const relPath = stripSuffix(ref);
+    if (!relPath) return null;
+
+    const abs = isAbsolute(relPath) ? relPath : resolve(baseDir, relPath);
+
+    let bytes: number;
+    try {
+      if (!existsSync(abs) || !statSync(abs).isFile()) {
+        unresolved.push(ref);
+        cache.set(ref, null);
+        return null;
+      }
+      bytes = statSync(abs).size;
+    } catch {
+      unresolved.push(ref);
+      cache.set(ref, null);
+      return null;
+    }
+
+    if (bytes > maxAssetBytes) {
+      skipped.push({ ref, bytes, reason: "asset-too-large" });
+      cache.set(ref, null);
+      return null;
+    }
+
+    // base64 costs ~4/3 of the raw bytes; check against the remaining budget
+    // before reading so an oversized asset never lands in memory twice.
+    const encodedCost = Math.ceil(bytes / 3) * 4;
+    if (encodedCost > budget) {
+      skipped.push({ ref, bytes, reason: "document-too-large" });
+      cache.set(ref, null);
+      return null;
+    }
+
+    let uri: string;
+    try {
+      const mime = MIME_BY_EXT[extname(abs).toLowerCase()] ?? "application/octet-stream";
+      uri = `data:${mime};base64,${readFileSync(abs).toString("base64")}`;
+    } catch {
+      unresolved.push(ref);
+      cache.set(ref, null);
+      return null;
+    }
+
+    budget -= uri.length;
+    inlined.push({ ref, bytes });
+    cache.set(ref, uri);
+    return uri;
+  }
+
+  /** `a.png 1x, b.png 2x` — rewrite each candidate, keep its descriptor. */
+  function rewriteSrcset(value: string): string {
+    return value
+      .split(",")
+      .map((candidate) => {
+        const trimmed = candidate.trim();
+        if (!trimmed) return candidate;
+        const [url, ...descriptor] = trimmed.split(/\s+/);
+        const uri = url ? toDataUri(url) : null;
+        if (!uri) return candidate;
+        return [uri, ...descriptor].join(" ");
+      })
+      .join(", ");
+  }
+
+  let out = html;
+
+  // src="..." on img/script/source/video/audio/iframe, and poster="..."
+  out = out.replace(
+    /(\b(?:src|poster)\s*=\s*)(["'])([^"']*)\2/gi,
+    (match, prefix: string, quote: string, ref: string) => {
+      const uri = toDataUri(ref);
+      return uri ? `${prefix}${quote}${uri}${quote}` : match;
+    },
+  );
+
+  // srcset="a.png 1x, b.png 2x"
+  out = out.replace(
+    /(\bsrcset\s*=\s*)(["'])([^"']*)\2/gi,
+    (match, prefix: string, quote: string, value: string) => {
+      const rewritten = rewriteSrcset(value);
+      return rewritten === value ? match : `${prefix}${quote}${rewritten}${quote}`;
+    },
+  );
+
+  // <link href="style.css"> / icons — but never <a href>.
+  out = out.replace(/<link\b[^>]*>/gi, (tag) =>
+    tag.replace(
+      /(\bhref\s*=\s*)(["'])([^"']*)\2/i,
+      (match, prefix: string, quote: string, ref: string) => {
+        const uri = toDataUri(ref);
+        return uri ? `${prefix}${quote}${uri}${quote}` : match;
+      },
+    ),
+  );
+
+  // CSS url(...) in <style> blocks and style="" attributes.
+  out = out.replace(/url\(\s*(["']?)([^"')]+)\1\s*\)/gi, (match, quote: string, ref: string) => {
+    const uri = toDataUri(ref);
+    return uri ? `url(${quote}${uri}${quote})` : match;
+  });
+
+  return { html: out, inlined, unresolved, skipped };
+}

package/dist/runtime/src/agents/mcp-tools/publish-html.ts

@@ -0,0 +1,183 @@
+/**
+ * `publish_html` — hand the user a public link to a rendered HTML document.
+ *
+ * This sits beside `show_html`: both exist to show rendered HTML rather than
+ * raw markup, so both are gated by the same `visualTools` capability. They
+ * differ only in delivery. `show_html` paints a sandboxed in-app panel, which
+ * blocks network requests and cannot be opened outside the app; publishing
+ * returns an ordinary URL that survives the turn and can be shared.
+ *
+ * Requires a snippet backend (`NEGOTIUM_SNIPPETS_API_URL`). The tool is left
+ * out of the catalog entirely when none is configured, so a deployment
+ * without one never advertises a link it cannot mint.
+ */
+import { z } from "zod";
+import { errorResult, type SharedMcpTool, textResult } from "#agents/mcp-tools/common";
+import { inlineLocalAssets } from "#agents/mcp-tools/inline-assets";
+import { SNIPPETS_API_URL } from "#platform/config";
+
+const REQUEST_TIMEOUT_MS = 30_000;
+/** Keep in step with the snippet service's own body limit. */
+export const MAX_PUBLISHED_BYTES = 10 * 1024 * 1024;
+export const MAX_PUBLISHED_ASSET_BYTES = 5 * 1024 * 1024;
+
+export interface PublishHtmlContext {
+  /** Directory that relative asset paths resolve against (the agent's cwd). */
+  cwd?: string;
+}
+
+type SnippetResponse = {
+  ok: boolean;
+  url?: string;
+  snippetId?: string;
+  expiresAt?: string;
+  error?: string;
+};
+
+export function formatPublishBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)}KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
+}
+
+/** Accept a full snippet URL or a bare id, return the id. */
+export function parseSnippetId(input: string): string | null {
+  const trimmed = input.trim();
+  const fromUrl = trimmed.match(/\/snippets\/([A-Za-z0-9-]+)/)?.[1];
+  const id = fromUrl ?? trimmed;
+  return /^[A-Za-z0-9-]+$/.test(id) ? id : null;
+}
+
+async function snippetRequest(
+  baseUrl: string,
+  path: string,
+  init: RequestInit = {},
+): Promise<SnippetResponse> {
+  try {
+    const response = await fetch(`${baseUrl}${path}`, {
+      ...init,
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+    });
+    const body = (await response.json().catch(() => null)) as SnippetResponse | null;
+    if (body) return body;
+    return { ok: false, error: `snippet service returned ${response.status}` };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "snippet service unreachable";
+    return { ok: false, error: message };
+  }
+}
+
+/**
+ * Build the publish tools, or `[]` when no snippet backend is configured.
+ * `ctx` may be a getter so a long-lived server picks up the current turn's cwd.
+ */
+export function createPublishHtmlToolDefinitions(
+  ctx: PublishHtmlContext | (() => PublishHtmlContext),
+  options: { apiUrl?: string } = {},
+): SharedMcpTool[] {
+  const apiUrl = (options.apiUrl ?? SNIPPETS_API_URL)?.replace(/\/+$/, "");
+  if (!apiUrl) return [];
+  const getCtx = typeof ctx === "function" ? ctx : () => ctx;
+
+  return [
+    {
+      name: "publish_html",
+      description: [
+        "Publish an HTML document and return a public, shareable https link that",
+        "stays live for 72 hours. Use this when the user should be able to open,",
+        "keep, or send the result — a report, dashboard, or styled table — rather",
+        "than only glance at it in the side panel.",
+        "Pass a complete standalone document and inline the CSS and JS.",
+        "For charts and diagrams prefer inline <svg>: it stays sharp at any zoom",
+        "and is far smaller than an image file.",
+        "Images may be remote URLs, data: URIs, or paths to local files you",
+        "created — local files are embedded automatically, so the page keeps",
+        "working after your workspace is gone.",
+      ].join(" "),
+      schema: {
+        html: z
+          .string()
+          .describe("Complete standalone HTML document to publish. Inline the CSS and JS."),
+        base_dir: z
+          .string()
+          .optional()
+          .describe(
+            "Directory that relative image paths resolve against. Defaults to the working directory.",
+          ),
+      },
+      async handler(input: { html?: string; base_dir?: string }) {
+        const html = input?.html ?? "";
+        if (!html.trim()) return errorResult("html is empty — provide an HTML document.");
+
+        const baseDir = input.base_dir?.trim() || getCtx().cwd || process.cwd();
+        const report = inlineLocalAssets(html, {
+          baseDir,
+          maxAssetBytes: MAX_PUBLISHED_ASSET_BYTES,
+          maxTotalBytes: MAX_PUBLISHED_BYTES,
+        });
+
+        const bytes = Buffer.byteLength(report.html, "utf-8");
+        if (bytes > MAX_PUBLISHED_BYTES) {
+          return errorResult(
+            `Document is ${formatPublishBytes(bytes)} after embedding images, over the ${formatPublishBytes(MAX_PUBLISHED_BYTES)} limit. Use fewer or smaller images, or switch charts to inline <svg>.`,
+          );
+        }
+
+        const result = await snippetRequest(apiUrl, "/snippets", {
+          method: "POST",
+          headers: { "content-type": "text/html; charset=utf-8" },
+          body: report.html,
+        });
+        if (!result.ok || !result.url) {
+          return errorResult(result.error ?? "Failed to publish.");
+        }
+
+        // Surface asset problems here so a broken image is visible now rather
+        // than only in the user's browser.
+        const notes: string[] = [];
+        if (report.inlined.length > 0) {
+          const total = report.inlined.reduce((sum, a) => sum + a.bytes, 0);
+          notes.push(
+            `Embedded ${report.inlined.length} local file(s), ${formatPublishBytes(total)}.`,
+          );
+        }
+        if (report.unresolved.length > 0) {
+          notes.push(
+            `WARNING — these look like local files but were not found, so they will render broken: ${report.unresolved.join(", ")}. Check the paths (relative to ${baseDir}) and republish.`,
+          );
+        }
+        for (const s of report.skipped) {
+          notes.push(
+            s.reason === "asset-too-large"
+              ? `WARNING — ${s.ref} is ${formatPublishBytes(s.bytes)}, over the ${formatPublishBytes(MAX_PUBLISHED_ASSET_BYTES)} per-file limit, and was left as a broken link.`
+              : `WARNING — ${s.ref} was left out because the document hit the ${formatPublishBytes(MAX_PUBLISHED_BYTES)} limit.`,
+          );
+        }
+
+        const payload = {
+          url: result.url,
+          snippetId: result.snippetId,
+          expiresAt: result.expiresAt,
+          sizeBytes: bytes,
+          ...(report.inlined.length > 0 ? { embeddedFiles: report.inlined.length } : {}),
+        };
+        return textResult([JSON.stringify(payload, null, 2), ...notes].join("\n\n"));
+      },
+    },
+    {
+      name: "unpublish_html",
+      description:
+        "Delete a previously published HTML document before its 72-hour expiry. Accepts the URL returned by publish_html, or its id.",
+      schema: {
+        snippet: z.string().describe("URL returned by publish_html, or the bare id."),
+      },
+      async handler(input: { snippet?: string }) {
+        const id = parseSnippetId(input?.snippet ?? "");
+        if (!id) return errorResult("Could not read a published document id from that value.");
+        const result = await snippetRequest(apiUrl, `/snippets/${id}`, { method: "DELETE" });
+        if (!result.ok) return errorResult(result.error ?? "Failed to delete.");
+        return textResult(`Published document ${id} deleted.`);
+      },
+    },
+  ];
+}

package/dist/runtime/src/agents/public-helpers.ts

@@ -54,6 +54,10 @@ export {
   normalizeAskUserChoices,
   normalizeAskUserQuestionInput,
 } from "#agents/mcp-tools/ask-user";
+export {
+  createPublishHtmlToolDefinitions,
+  type PublishHtmlContext,
+} from "#agents/mcp-tools/publish-html";
 export {
   createSelfConfigRuntime,
   createSelfConfigToolDefinitionsForCore,

package/dist/runtime/src/mcp-runtime-host.ts

@@ -1,6 +1,7 @@
 /** Stable core surface used by the embedded runtime MCP endpoint. */
 export { createAskUserToolDefinition } from "#agents/mcp-tools/ask-user";
 export { errorResult, textResult } from "#agents/mcp-tools/common";
+export { createPublishHtmlToolDefinitions } from "#agents/mcp-tools/publish-html";
 export type { SelfConfigContext } from "#agents/mcp-tools/self-config";
 export { createSelfConfigToolDefinitions } from "#agents/mcp-tools/self-config";
 export {

package/dist/runtime/src/platform/config.ts

@@ -153,6 +153,18 @@ export function resolveBrowserRsBin(envValue?: string): string | undefined {
   }
 }
 
+/**
+ * Backend that stores documents published by `publish_html` and serves them
+ * at `<base>/snippets/<id>`. Unset means the deployment has nowhere to
+ * publish, and the publish tools are omitted from the catalog rather than
+ * offering a link that cannot be minted.
+ */
+export const SNIPPETS_API_URL = (
+  envText("NEGOTIUM_SNIPPETS_API_URL") ??
+  envText("SNIPPETS_API_URL") ??
+  ""
+).replace(/\/+$/, "");
+
 export const BROWSER_RS_BIN = resolveBrowserRsBin(envText("NEGOTIUM_BROWSER_RS_BIN"));
 
 // Managed Browser.rs terminates MCP transports and security policy itself.

package/dist/runtime/src/version.ts

@@ -1 +1 @@
-export const NEGOTIUM_VERSION = "0.2.9";
+export const NEGOTIUM_VERSION = "0.2.11";

package/dist/runtime-helpers.js

@@ -494,6 +494,7 @@ function resolveBrowserRsBin(envValue) {
     return;
   }
 }
+var SNIPPETS_API_URL = (envText("NEGOTIUM_SNIPPETS_API_URL") ?? envText("SNIPPETS_API_URL") ?? "").replace(/\/+$/, "");
 var BROWSER_RS_BIN = resolveBrowserRsBin(envText("NEGOTIUM_BROWSER_RS_BIN"));
 function resolveBrowserMcpBin(envValue) {
   const override = envValue?.trim();
@@ -1132,4 +1133,4 @@ export {
   CLAUDE_EFFORT_VALUES
 };
 
-//# debugId=078B7BFBF513B96264756E2164756E21
+//# debugId=842C00B02967857064756E2164756E21