bazilion 0.3.0 → 0.4.0

package/dist/migrations/0007_mcp_servers.sql

@@ -0,0 +1,30 @@
+-- MCP (Model Context Protocol) servers.
+--
+-- Each row is one configured server the daemon connects to as an MCP client.
+-- Tools discovered on it (`tools/list`) are namespaced `mcp__<name>__<tool>`
+-- and injected into agent turns. v0.4.0 scopes servers globally — every agent
+-- sees the tools of every enabled server.
+--
+-- Transports:
+--   stdio — local subprocess (`command` + JSON `args`); inherits the daemon's
+--           merged secrets env, so a server needing e.g. GITHUB_TOKEN picks it
+--           up from the normal secrets table.
+--   http  — Streamable-HTTP endpoint at `url`.
+--   sse   — SSE endpoint at `url`.
+--
+-- Bearer auth for http/sse is NOT stored here: the token lives in the encrypted
+-- `secrets` table under key `MCP_TOKEN_<id>`; `has_auth` records whether one is
+-- set so the UI/API can show it without decrypting.
+
+CREATE TABLE IF NOT EXISTS mcp_servers (
+  id          TEXT PRIMARY KEY,
+  name        TEXT NOT NULL UNIQUE,
+  transport   TEXT NOT NULL CHECK (transport IN ('stdio','http','sse')),
+  command     TEXT,
+  args        TEXT NOT NULL DEFAULT '[]',
+  url         TEXT,
+  has_auth    INTEGER NOT NULL DEFAULT 0,
+  enabled     INTEGER NOT NULL DEFAULT 1,
+  created_at  INTEGER NOT NULL,
+  updated_at  INTEGER NOT NULL
+);

package/dist/worker.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // ../daemon/src/runtime/worker/entry.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 import { join as join14 } from "path";
 
 // ../daemon/src/core/agent/delete.ts
@@ -419,6 +419,50 @@ var SERVICES = [
       }
     ]
   },
+  {
+    id: "browser",
+    displayName: "Browser Automation",
+    category: "service",
+    group: "Browser",
+    hint: "Playwright-driven browser tools (navigate, snapshot, click, screenshot). Run `pnpm exec playwright install chromium` once.",
+    fields: [
+      {
+        envVar: "BROWSER_ENABLED",
+        kind: "config",
+        label: "Enable browser tools",
+        placeholder: "true",
+        description: "Expose the browser_* tools to agents (true/false). Default true."
+      },
+      {
+        envVar: "BROWSER_HEADLESS",
+        kind: "config",
+        label: "Headless",
+        placeholder: "true",
+        description: "Run Chromium headless (true/false). Default true."
+      },
+      {
+        envVar: "BROWSER_ALLOW_PRIVATE_NETWORK",
+        kind: "config",
+        label: "Allow private network",
+        placeholder: "false",
+        description: "Permit the browser to reach loopback/private IPs (SSRF guard off). Default false \u2014 only enable for local dev."
+      },
+      {
+        envVar: "BROWSER_IDLE_MS",
+        kind: "config",
+        label: "Idle timeout (ms)",
+        placeholder: "900000",
+        description: "Close an idle browser session after this many ms. Default 900000 (15 min)."
+      },
+      {
+        envVar: "BROWSER_MAX_SESSIONS",
+        kind: "config",
+        label: "Max concurrent sessions",
+        placeholder: "4",
+        description: "Cap on simultaneously-open browser sessions (LRU-evicted). Default 4."
+      }
+    ]
+  },
   // --- External integrations (chat bridges, etc) ---
   // Each integration has its own dedicated /config/integrations/* page with
   // workflow-specific UI (preflight health, setup wizard, …). The fields
@@ -476,17 +520,20 @@ var CONFIG_KEYS = [
 ];
 var CONFIG_KEY_SET = new Set(CONFIG_KEYS);
 
-// ../daemon/src/core/repos/messages.ts
+// ../daemon/src/core/repos/mcpServers.ts
 import { randomUUID as randomUUID2 } from "crypto";
 
+// ../daemon/src/core/repos/messages.ts
+import { randomUUID as randomUUID3 } from "crypto";
+
 // ../daemon/src/core/repos/secrets.ts
 import { createCipheriv, createDecipheriv, pbkdf2Sync, randomBytes } from "crypto";
 
 // ../daemon/src/core/repos/triggers.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 
 // ../daemon/src/core/repos/webTokens.ts
-import { createHash, randomBytes as randomBytes2, randomUUID as randomUUID4 } from "crypto";
+import { createHash, randomBytes as randomBytes2, randomUUID as randomUUID5 } from "crypto";
 
 // ../daemon/src/core/secrets.ts
 import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
@@ -666,7 +713,16 @@ function translatePiEvent(e) {
       if (e.isError) {
         return [{ type: "tool_error", id: e.toolCallId, name: e.toolName, error: text }];
       }
-      return [{ type: "tool_result", id: e.toolCallId, name: e.toolName, result: text }];
+      const images = extractToolResultImages(e.result);
+      return [
+        {
+          type: "tool_result",
+          id: e.toolCallId,
+          name: e.toolName,
+          result: text,
+          ...images.length > 0 ? { images } : {}
+        }
+      ];
     }
     default:
       return [];
@@ -697,6 +753,20 @@ function extractToolResultText(result) {
   }
   return out;
 }
+function extractToolResultImages(result) {
+  const r = result;
+  if (!r?.content) return [];
+  const out = [];
+  for (const block of r.content) {
+    if (block.type === "image") {
+      const b = block;
+      if (typeof b.data === "string" && typeof b.mimeType === "string") {
+        out.push({ data: b.data, mimeType: b.mimeType });
+      }
+    }
+  }
+  return out;
+}
 function stringifyContent(content) {
   if (typeof content === "string") return content;
   if (!Array.isArray(content)) return "";
@@ -711,7 +781,13 @@ function piMessagesToProviderView(messages) {
   for (const m of messages) {
     switch (m.role) {
       case "user": {
-        out.push({ role: "user", content: stringifyContent(m.content) });
+        const content = m.content;
+        const images = extractToolResultImages({ content });
+        out.push({
+          role: "user",
+          content: stringifyContent(content),
+          ...images.length > 0 ? { images } : {}
+        });
         break;
       }
       case "assistant": {
@@ -725,11 +801,13 @@ function piMessagesToProviderView(messages) {
       }
       case "toolResult": {
         const tr = m;
+        const images = extractToolResultImages({ content: tr.content });
         out.push({
           role: "tool",
           content: stringifyContent(tr.content),
           toolCallId: tr.toolCallId,
-          toolName: tr.toolName
+          toolName: tr.toolName,
+          ...images.length > 0 ? { images } : {}
         });
         break;
       }
@@ -741,8 +819,8 @@ function piMessagesToProviderView(messages) {
 }
 
 // ../daemon/src/runtime/pi/session.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync5, readdirSync as readdirSync7, statSync as statSync5 } from "fs";
-import { basename as basename2, join as join13 } from "path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync5, readdirSync as readdirSync7, statSync as statSync6 } from "fs";
+import { basename as basename3, join as join13 } from "path";
 import {
   AuthStorage,
   createAgentSession,
@@ -922,8 +1000,195 @@ function bootstrapTool(agentDir) {
   };
 }
 
+// ../daemon/src/runtime/tools/browser.ts
+var REF_DESC = 'Element ref from the latest browser_snapshot, e.g. "e5".';
+function browserTools(host, agentId) {
+  const proxy = (name, action, description, properties, required = []) => ({
+    def: {
+      name,
+      description,
+      parameters: { type: "object", properties, required, additionalProperties: false }
+    },
+    invoke: (args) => host.invoke(agentId, action, args)
+  });
+  return [
+    proxy(
+      "browser_navigate",
+      "navigate",
+      "Open a URL in the browser and return an accessibility snapshot of the loaded page. Starts a persistent browser session that survives across turns (cookies/logins carry over).",
+      { url: { type: "string", description: "Absolute URL to navigate to." } },
+      ["url"]
+    ),
+    proxy(
+      "browser_snapshot",
+      "snapshot",
+      'Capture the current page as an accessibility tree (YAML) with [ref=eN] element references. This is the primary way to "see" the page \u2014 prefer it over screenshots. Use the refs with browser_click/type/etc.',
+      {}
+    ),
+    proxy(
+      "browser_click",
+      "click",
+      "Click an element identified by its snapshot ref. Returns a fresh snapshot.",
+      { ref: { type: "string", description: REF_DESC } },
+      ["ref"]
+    ),
+    proxy(
+      "browser_type",
+      "type",
+      "Type text into an input/textarea identified by its ref. Set submit=true to press Enter afterwards. Returns a fresh snapshot.",
+      {
+        ref: { type: "string", description: REF_DESC },
+        text: { type: "string", description: "Text to type into the field." },
+        submit: { type: "boolean", description: "Press Enter after typing." }
+      },
+      ["ref", "text"]
+    ),
+    proxy(
+      "browser_hover",
+      "hover",
+      "Hover the pointer over an element identified by its ref. Returns a fresh snapshot.",
+      { ref: { type: "string", description: REF_DESC } },
+      ["ref"]
+    ),
+    proxy(
+      "browser_select",
+      "select",
+      "Select option(s) in a <select> element identified by its ref.",
+      {
+        ref: { type: "string", description: REF_DESC },
+        values: {
+          type: "array",
+          items: { type: "string" },
+          description: "Option values to select."
+        }
+      },
+      ["ref", "values"]
+    ),
+    proxy(
+      "browser_fill_form",
+      "fill_form",
+      "Fill multiple form fields in one call. Each field is { ref, value }.",
+      {
+        fields: {
+          type: "array",
+          description: "Fields to fill.",
+          items: {
+            type: "object",
+            properties: {
+              ref: { type: "string", description: REF_DESC },
+              value: { type: "string" }
+            },
+            required: ["ref", "value"]
+          }
+        }
+      },
+      ["fields"]
+    ),
+    proxy(
+      "browser_press_key",
+      "press_key",
+      'Press a keyboard key (e.g. "Enter", "Escape", "ArrowDown", "Control+A").',
+      { key: { type: "string", description: "Key or chord to press." } },
+      ["key"]
+    ),
+    proxy(
+      "browser_go_back",
+      "go_back",
+      "Navigate back to the previous page in history. Returns a fresh snapshot.",
+      {}
+    ),
+    proxy(
+      "browser_tabs",
+      "tabs",
+      'Manage tabs. op="list" lists open tabs; "new" opens a tab (optional url); "select" focuses tab at index; "close" closes tab at index (defaults to active).',
+      {
+        op: { type: "string", enum: ["list", "new", "select", "close"] },
+        index: { type: "number", description: "Tab index for select/close." },
+        url: { type: "string", description: "URL to open for op=new." }
+      },
+      ["op"]
+    ),
+    proxy(
+      "browser_take_screenshot",
+      "take_screenshot",
+      "Take a PNG screenshot of the current page (returned as an image). Use only for visual verification or canvas/pixel content the accessibility snapshot cannot represent \u2014 prefer browser_snapshot for interaction.",
+      { full_page: { type: "boolean", description: "Capture the full scrollable page." } }
+    ),
+    proxy(
+      "browser_console",
+      "console",
+      "Return recent browser console messages (logs, warnings, errors).",
+      {}
+    ),
+    proxy(
+      "browser_network",
+      "network",
+      "Return recent network requests issued by the page (method, status, URL).",
+      {}
+    )
+  ];
+}
+
+// ../daemon/src/runtime/tools/deliver-file.ts
+import { readFileSync as readFileSync8, statSync as statSync4 } from "fs";
+import { basename as basename2, extname, isAbsolute, resolve as resolve3 } from "path";
+var MAX_DELIVER_BYTES = 25 * 1024 * 1024;
+var MIME = {
+  ".pdf": "application/pdf",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".csv": "text/csv",
+  ".json": "application/json",
+  ".html": "text/html",
+  ".zip": "application/zip",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp"
+};
+function deliverFileTool(cwd, sink) {
+  return {
+    def: {
+      name: "deliver_file",
+      description: "Send a file from your workspace to the user so they can download it (web), receive it as a document (Telegram), or save it (CLI). Use this to deliver reports, exports, or any artifact you produced. Max 25 MB.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "Path to the file, relative to your workspace or absolute."
+          }
+        },
+        required: ["path"],
+        additionalProperties: false
+      }
+    },
+    async invoke(args) {
+      const p = String(args.path ?? "");
+      if (!p) throw new Error("deliver_file: path is required");
+      const abs = isAbsolute(p) ? p : resolve3(cwd, p);
+      let size;
+      try {
+        size = statSync4(abs).size;
+      } catch {
+        throw new Error(`deliver_file: no such file: ${p}`);
+      }
+      if (size > MAX_DELIVER_BYTES) {
+        throw new Error(
+          `deliver_file: "${basename2(abs)}" is too large (${(size / 1024 / 1024).toFixed(1)} MB > 25 MB)`
+        );
+      }
+      const name = basename2(abs);
+      const mimeType = MIME[extname(abs).toLowerCase()] ?? "application/octet-stream";
+      sink({ name, mimeType, data: readFileSync8(abs).toString("base64") });
+      return `Delivered "${name}" (${mimeType}) to the user.`;
+    }
+  };
+}
+
 // ../daemon/src/runtime/tools/home.ts
-import { readdirSync as readdirSync6, readFileSync as readFileSync8, statSync as statSync4, writeFileSync as writeFileSync5 } from "fs";
+import { readdirSync as readdirSync6, readFileSync as readFileSync9, statSync as statSync5, writeFileSync as writeFileSync5 } from "fs";
 import { join as join12 } from "path";
 var HOME_FILES_READABLE = [
   "IDENTITY.md",
@@ -963,7 +1228,7 @@ function homeTools(agentDir) {
         }
         const path = join12(agentDir, file);
         try {
-          return readFileSync8(path, "utf8");
+          return readFileSync9(path, "utf8");
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
           throw new Error(`home_read: could not read ${file}: ${msg}`);
@@ -1007,7 +1272,7 @@ function homeTools(agentDir) {
         for (const file of HOME_FILES_READABLE) {
           const path = join12(agentDir, file);
           try {
-            const s = statSync4(path);
+            const s = statSync5(path);
             entries.push(`${file} (${s.size}b)`);
           } catch {
           }
@@ -1028,6 +1293,18 @@ function homeTools(agentDir) {
   ];
 }
 
+// ../daemon/src/runtime/tools/mcp.ts
+function mcpProxyTools(host, tools) {
+  return tools.map((t) => ({
+    def: {
+      name: t.toolName,
+      description: t.description,
+      parameters: t.inputSchema
+    },
+    invoke: (args) => host.invoke(t.serverId, t.rawName, args)
+  }));
+}
+
 // ../daemon/src/runtime/tools/memory.ts
 function memoryTools(memory) {
   return [
@@ -1853,14 +2130,20 @@ function ourToolToPiTool(h) {
     description: h.def.description,
     parameters: Type2.Unsafe(h.def.parameters),
     async execute(_toolCallId, params) {
-      const text = await h.invoke(params);
+      const out = await h.invoke(params);
       return {
-        content: [{ type: "text", text }],
+        content: toPiContent(out),
         details: {}
       };
     }
   };
 }
+function toPiContent(out) {
+  if (typeof out === "string") return [{ type: "text", text: out }];
+  return out.map(
+    (p) => p.type === "text" ? { type: "text", text: p.text } : { type: "image", data: p.data, mimeType: p.mimeType }
+  );
+}
 function createBazilionCustomTools(opts) {
   const handlers = [
     ...memoryTools(opts.memory),
@@ -1874,13 +2157,35 @@ function createBazilionCustomTools(opts) {
   if (opts.userMdHost) {
     handlers.push(...userMdTools(opts.userMdHost, opts.agent.group.id));
   }
+  if (opts.browserHost) {
+    handlers.push(...browserTools(opts.browserHost, opts.agent.agent.id));
+  }
+  if (opts.mcpHost && opts.mcpTools && opts.mcpTools.length > 0) {
+    handlers.push(...mcpProxyTools(opts.mcpHost, opts.mcpTools));
+  }
+  if (opts.fileSink) {
+    handlers.push(deliverFileTool(opts.agent.group.path, opts.fileSink));
+  }
   return handlers.map(ourToolToPiTool);
 }
 
 // ../daemon/src/runtime/pi/session.ts
 var BUILTIN_TOOL_NAMES = ["read", "bash", "edit", "write", "grep", "find", "ls"];
 async function createBazilionSession(opts) {
-  const { agent, paths, env, memory, enabledProviders, messagingHost, userMdHost, refreshApiKey } = opts;
+  const {
+    agent,
+    paths,
+    env,
+    memory,
+    enabledProviders,
+    messagingHost,
+    userMdHost,
+    browserHost,
+    mcpHost,
+    mcpTools,
+    fileSink,
+    refreshApiKey
+  } = opts;
   const { providerName, modelId } = splitModelString(agent.model);
   if (enabledProviders.size > 0 && !enabledProviders.has(providerName)) {
     throw new Error(`${providerName} provider is disabled \u2014 enable it on the /config page`);
@@ -1927,7 +2232,17 @@ async function createBazilionSession(opts) {
   const bazilionPrompt = buildSystemPrompt(agent);
   const resourceLoader = createBazilionResourceLoader(bazilionPrompt);
   await resourceLoader.reload();
-  const customTools = createBazilionCustomTools({ agent, memory, messagingHost, userMdHost, env });
+  const customTools = createBazilionCustomTools({
+    agent,
+    memory,
+    messagingHost,
+    userMdHost,
+    browserHost,
+    mcpHost,
+    mcpTools,
+    fileSink,
+    env
+  });
   const allowedTools = [...BUILTIN_TOOL_NAMES, ...customTools.map((t) => t.name)];
   const { session } = await createAgentSession({
     cwd,
@@ -2063,7 +2378,7 @@ function findMostRecent(sessionDir) {
     if (!entry.endsWith(".jsonl")) continue;
     const path = join13(sessionDir, entry);
     try {
-      const s = statSync5(path);
+      const s = statSync6(path);
       if (!newest || s.mtimeMs > newest.mtimeMs) newest = { path, mtimeMs: s.mtimeMs };
     } catch {
     }
@@ -2105,10 +2420,10 @@ function createIpcClient() {
     if (!process.send) {
       return Promise.reject(new Error("worker: no IPC channel \u2014 daemon must spawn with stdio:ipc"));
     }
-    const id = randomUUID5();
+    const id = randomUUID6();
     const message = { type: "rpc", id, method, args };
-    return new Promise((resolve3, reject) => {
-      pending.set(id, { resolve: (v) => resolve3(v), reject });
+    return new Promise((resolve4, reject) => {
+      pending.set(id, { resolve: (v) => resolve4(v), reject });
       process.send?.(message, void 0, void 0, (err) => {
         if (err) {
           pending.delete(id);
@@ -2135,6 +2450,16 @@ function createIpcUserMdHost(call) {
     write: (groupId, content, ifMatch) => call("userMdWrite", { groupId, content, ifMatch })
   };
 }
+function createIpcBrowserHost(call) {
+  return {
+    invoke: (agentId, action, args) => call("browserInvoke", { agentId, action, args })
+  };
+}
+function createIpcMcpHost(call) {
+  return {
+    invoke: (serverId, toolName, args) => call("mcpInvoke", { serverId, toolName, args })
+  };
+}
 function isIpcReply(msg) {
   if (!msg || typeof msg !== "object") return false;
   const m = msg;
@@ -2157,13 +2482,15 @@ async function main() {
   };
   process.on("SIGTERM", onSignal);
   process.on("SIGINT", onSignal);
-  const { agent, message, enabledProviders, apiKey } = await readInput();
+  const { agent, message, enabledProviders, apiKey, browserEnabled, mcpTools, images } = await readInput();
   const paths = resolvePaths();
   const memory = qmdBackend(join14(agent.group.path, "memory"));
   await memory.init();
   const ipcCall = createIpcClient();
   const messagingHost = createIpcMessagingHost(ipcCall);
   const userMdHost = createIpcUserMdHost(ipcCall);
+  const browserHost = browserEnabled ? createIpcBrowserHost(ipcCall) : void 0;
+  const mcpHost = mcpTools && mcpTools.length > 0 ? createIpcMcpHost(ipcCall) : void 0;
   const { session, dispose } = await createBazilionSession({
     agent,
     paths,
@@ -2172,7 +2499,12 @@ async function main() {
     enabledProviders: new Set(enabledProviders),
     messagingHost,
     userMdHost,
-    apiKey
+    apiKey,
+    browserHost,
+    mcpHost,
+    mcpTools,
+    // deliver_file emits a `file` event straight onto our stdout frame stream.
+    fileSink: (f) => emit({ kind: "event", event: { type: "file", ...f } })
   });
   abortSession = () => {
     void session.abort();
@@ -2183,7 +2515,12 @@ async function main() {
     }
   });
   try {
-    await session.prompt(message);
+    const promptImages = (images ?? []).map((img) => ({
+      type: "image",
+      data: img.data,
+      mimeType: img.mimeType
+    }));
+    await session.prompt(message, promptImages.length > 0 ? { images: promptImages } : void 0);
     await session.agent.waitForIdle();
     emit({
       kind: "done",