@bivy/bivy 0.5.1-staging.60 → 0.5.1-staging.61

package/bin/bivy.mjs

@@ -145,6 +145,7 @@ const attachEntry = path.join(repoRoot, packaged ? "dist/attach.js" : "src/attac
 const relayAttachEntry = path.join(repoRoot, packaged ? "dist/relay-attach.js" : "src/relay-attach.ts");
 const execEntry = path.join(repoRoot, packaged ? "dist/exec.js" : "src/exec.ts");
 const mcpProxyEntry = path.join(repoRoot, packaged ? "dist/harness/mcp-proxy-cli.js" : "src/harness/mcp-proxy-cli.ts");
+const mcpServeEntry = path.join(repoRoot, packaged ? "dist/harness/mcp-serve-cli.js" : "src/harness/mcp-serve-cli.ts");
 const qrEntry = path.join(repoRoot, "public", "qr.js");
 const tsxCli = packaged ? "" : path.join(repoRoot, "node_modules", "tsx", "dist", "cli.mjs");
 const nodeBin = process.execPath;
@@ -4360,6 +4361,13 @@ An agent's own --help passes through, e.g. 'bivy run claude --help'.`);
       // agent's cwd so relative server commands resolve.
       await run(nodeBin, [...nodeScriptArgs(mcpProxyEntry), ...args], { cwd: process.cwd(), env: process.env });
       break;
+    case "mcp-serve":
+      // Bivy-owned MCP server (exposes attach_to_chat and future chat tools).
+      // Injected into a non-SDK agent's MCP config so the agent discovers the
+      // tool; like mcp-proxy its stdin/stdout ARE the JSON-RPC stream, so emit
+      // nothing else here and inherit stdio verbatim.
+      await run(nodeBin, [...nodeScriptArgs(mcpServeEntry), ...args], { cwd: process.cwd(), env: process.env });
+      break;
     case "help":
     case "-h":
     case "--help":

package/dist/harness/mcp-config-formats.js

@@ -15,6 +15,33 @@
 // exact original bytes on session end regardless. Pure string→string, unit-tested
 // in test/harness-mcp-formats.test.ts.
 import { PROXY_MARKER } from "./mcp-config.js";
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** True when a TOML config already declares `[mcp_servers.<name>]`. */
+export function hasTomlServer(content, name) {
+    return new RegExp(`^\\s*\\[mcp_servers\\.${escapeRegExp(name)}\\]\\s*$`, "m").test(content);
+}
+/**
+ * Append a `[mcp_servers.<name>]` table to a Codex TOML config (the reverse of
+ * routeThroughProxy's rewrite — this ADDS Bivy's own server rather than wrapping
+ * the agent's). Idempotent: returns `inserted: false` untouched when a table of
+ * that name already exists. Env is written as an inline table; string values are
+ * TOML-escaped via JSON.stringify (safe for the ASCII paths/ids we stamp).
+ */
+export function insertTomlServer(content, name, spec) {
+    if (hasTomlServer(content, name))
+        return { content, inserted: false };
+    const block = [`[mcp_servers.${name}]`, `command = ${JSON.stringify(spec.command)}`, `args = ${tomlStringArray(spec.args ?? [])}`];
+    if (spec.env && Object.keys(spec.env).length) {
+        const pairs = Object.entries(spec.env).map(([k, v]) => `${k} = ${JSON.stringify(v)}`);
+        block.push(`env = { ${pairs.join(", ")} }`);
+    }
+    // Separate from prior content with a blank line; keep a trailing newline.
+    const base = content.length === 0 || content.endsWith("\n") ? content : `${content}\n`;
+    const sep = base.length > 0 && !base.endsWith("\n\n") ? "\n" : "";
+    return { content: `${base}${sep}${block.join("\n")}\n`, inserted: true };
+}
 function proxyArgs(launcher, server, command, origArgs) {
     return [...(launcher.argsPrefix ?? []), PROXY_MARKER, "--server", server, "--", command, ...origArgs];
 }

package/dist/harness/mcp-config.js

@@ -85,6 +85,30 @@ export function parseProxiedArgs(args) {
     const tail = args.slice(sep + 1);
     return { server, command: tail[0], args: tail.slice(1) };
 }
+// ---------------------------------------------------------------------------
+// Bivy-owned tools server — the mirror of the proxy above. routeThroughProxy
+// wraps the agent's OWN servers; this ADDS a `bivy` server (run via `bivy
+// mcp-serve`) so the agent discovers Bivy's chat tools (attach_to_chat, …) in
+// its own tool list. Session id + node URL ride in its env so the tool can post
+// back to the right session.
+/** The server spec that launches `bivy mcp-serve` for a session. */
+export function bivyToolsServerSpec(opts) {
+    const env = { BIVY_SESSION_ID: opts.sessionId };
+    if (opts.endpoint)
+        env.BIVY_MCP_ENDPOINT = opts.endpoint;
+    return { command: opts.bivyCommand ?? "bivy", args: ["mcp-serve"], env };
+}
+/**
+ * Insert the Bivy tools server under `mcpServers.<name>` (default "bivy").
+ * Idempotent: an existing entry of that name is left untouched (returns
+ * `added: false`), so a re-inject or a user's own `bivy` server never doubles up.
+ */
+export function withBivyToolsServer(config, spec, name = "bivy") {
+    const servers = config.mcpServers ?? {};
+    if (servers[name])
+        return { config, added: false };
+    return { config: { ...config, mcpServers: { ...servers, [name]: spec } }, added: true };
+}
 /** JSON MCP-config file candidates for an agent, most-specific (safest) first. */
 export function agentMcpConfigTargets(agentId, ctx) {
     const ws = (...parts) => nodePath.join(ctx.workspace, ...parts);

package/dist/harness/mcp-inject.js

@@ -14,8 +14,8 @@
 // FS + network channels. Unit-tested in test/harness-mcp-inject.test.ts.
 import fs from "node:fs";
 import path from "node:path";
-import { agentMcpConfigTargets, routeThroughProxy, } from "./mcp-config.js";
-import { injectTomlMcp, injectYamlMcp } from "./mcp-config-formats.js";
+import { agentMcpConfigTargets, bivyToolsServerSpec, routeThroughProxy, withBivyToolsServer, } from "./mcp-config.js";
+import { injectTomlMcp, injectYamlMcp, insertTomlServer } from "./mcp-config-formats.js";
 /** The proxy launcher Bivy injects — `bivy mcp-proxy …`. */
 export function bivyProxyLauncher(bivyCommand = "bivy") {
     return { command: bivyCommand, argsPrefix: ["mcp-proxy"] };
@@ -110,6 +110,82 @@ export function injectMcpConfigFile(filePath, launcher) {
         },
     };
 }
+/**
+ * Add the `bivy` tools server (attach_to_chat …) to an agent's MCP config so the
+ * agent DISCOVERS it as a tool. Unlike the proxy inject (which only rewrites
+ * servers a file already has), this CREATES the config when absent so an agent
+ * that ships no MCP config still gets the tool. Handles the most-specific JSON
+ * config (session-local for claude/gemini/opencode/generic) and Codex's TOML
+ * (`~/.codex/config.toml` — Codex has no project-local option). restore() deletes
+ * a file it created and rewrites the exact original bytes of one it modified.
+ * Idempotent (a `bivy` server already present is a no-op, so concurrent sessions
+ * sharing a global config don't double up). Best-effort; never throws. Goose YAML
+ * is a follow-up.
+ */
+export function injectBivyToolsForSession(agentId, ctx, bivyCommand = "bivy") {
+    const target = agentMcpConfigTargets(agentId, ctx).find((t) => {
+        const ext = path.extname(t).toLowerCase();
+        return ext === ".json" || ext === ".toml";
+    });
+    if (!target)
+        return { injected: [], restore: () => { } };
+    const spec = bivyToolsServerSpec({ sessionId: ctx.sessionId, endpoint: ctx.endpoint, bivyCommand });
+    const ext = path.extname(target).toLowerCase();
+    const existed = fs.existsSync(target);
+    let original;
+    if (existed) {
+        try {
+            original = fs.readFileSync(target, "utf8");
+        }
+        catch {
+            return { injected: [], restore: () => { } };
+        }
+    }
+    let nextContent;
+    if (ext === ".json") {
+        let parsed = {};
+        if (original !== undefined) {
+            try {
+                parsed = JSON.parse(original);
+            }
+            catch {
+                // A config we can't parse is not ours to rewrite — leave it be.
+                return { injected: [], restore: () => { } };
+            }
+        }
+        const { config, added } = withBivyToolsServer(parsed, spec);
+        if (!added)
+            return { injected: [], restore: () => { } };
+        nextContent = `${JSON.stringify(config, null, 2)}\n`;
+    }
+    else {
+        const res = insertTomlServer(original ?? "", "bivy", { command: spec.command ?? bivyCommand, args: spec.args, env: spec.env });
+        if (!res.inserted)
+            return { injected: [], restore: () => { } };
+        nextContent = res.content;
+    }
+    try {
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.writeFileSync(target, nextContent);
+    }
+    catch {
+        return { injected: [], restore: () => { } };
+    }
+    return {
+        injected: [target],
+        restore: () => {
+            try {
+                if (existed && original !== undefined)
+                    fs.writeFileSync(target, original);
+                else
+                    fs.rmSync(target, { force: true });
+            }
+            catch {
+                // Restore is best-effort.
+            }
+        },
+    };
+}
 /**
  * Inject the proxy into every MCP config an agent reads for this session.
  * Returns the injected files and a single restore() covering all of them.

package/dist/harness/mcp-serve-cli.js

@@ -0,0 +1,123 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+// Universal Agent Harness — `bivy mcp-serve` entry point.
+//
+// A Bivy-OWNED stdio MCP server (the mirror of `bivy mcp-proxy`, which wraps the
+// agent's OWN servers). Injected into every non-SDK agent's MCP config at session
+// start (see mcp-inject.ts's injectBivyToolsForSession), it exposes Bivy's chat
+// affordances as first-class tools so ANY agent — codex, gemini, aider, opencode,
+// … — discovers them in its tool list instead of having to be told about a shell
+// command (issue #290). Today it serves one tool, `attach_to_chat`.
+//
+// Claude and Pi already get `attach_to_chat` natively (in-process SDK MCP server /
+// integration ToolProvider); this covers everyone else. The tool just POSTs to the
+// node's existing `POST /api/session/:id/attach` endpoint — the exact plumbing
+// `bivy attach` uses — so it reuses the same workspace confinement, storage, and
+// live broadcast. The session id and node URL arrive via env (BIVY_SESSION_ID /
+// BIVY_MCP_ENDPOINT), stamped into the injected server spec.
+//
+// The attach client is factored out and unit-tested (test/harness-mcp-serve.test.ts)
+// with an injected fetch; the process/transport wiring is thin.
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+const DEFAULT_ENDPOINT = "http://127.0.0.1:4317";
+/** The tools this server advertises, in MCP `tools/list` shape. */
+export const BIVY_MCP_TOOLS = [
+    {
+        name: "attach_to_chat",
+        description: "Send a file or image from the session workspace into the chat the user is reading. The person you're " +
+            "talking to is in a chat UI: they cannot see files you only write to disk, and the chat cannot load workspace " +
+            "paths or remote image URLs. Use this to show them a report, screenshot, chart, or any file they asked for. An " +
+            "image renders inline; any other file shows as a downloadable chip. The path must be inside the session " +
+            "workspace. Prefer this over pasting large file contents, describing where a file lives, or markdown image " +
+            "syntax (which will not render).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the file to send, inside the session workspace (absolute, or relative to it)." },
+                caption: { type: "string", description: "Optional short note shown with the attachment." },
+            },
+            required: ["path"],
+            additionalProperties: false,
+        },
+    },
+];
+/**
+ * Perform an `attach_to_chat` call by POSTing to the node's attach endpoint,
+ * which confines the path to the workspace, stores the bytes, and broadcasts the
+ * chip. Never throws — every failure is returned as `{ isError: true, text }` so
+ * the agent gets an actionable message instead of a broken tool.
+ */
+export async function runAttachToChat(endpoint, sessionId, args, fetchImpl, token) {
+    if (!sessionId)
+        return { isError: true, text: "No active Bivy session to attach to (BIVY_SESSION_ID is not set)." };
+    const filePath = typeof args.path === "string" ? args.path.trim() : "";
+    if (!filePath)
+        return { isError: true, text: "Provide a `path` to a file inside the session workspace." };
+    const caption = typeof args.caption === "string" ? args.caption : undefined;
+    const base = endpoint.replace(/\/+$/, "");
+    const headers = { "content-type": "application/json" };
+    if (token)
+        headers.authorization = `Bearer ${token}`;
+    let res;
+    try {
+        res = await fetchImpl(`${base}/api/session/${encodeURIComponent(sessionId)}/attach`, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({ path: filePath, caption }),
+        });
+    }
+    catch (error) {
+        return { isError: true, text: `Could not reach the Bivy node to attach the file: ${error instanceof Error ? error.message : String(error)}` };
+    }
+    const body = (await res.json().catch(() => ({})));
+    if (!res.ok || body?.ok === false) {
+        return { isError: true, text: `Attach failed: ${body?.error || `node returned ${res.status}`}` };
+    }
+    const name = body?.name || filePath;
+    return { isError: false, text: `Attached ${name} to the chat as ${body?.kind === "image" ? "an inline image" : "a downloadable file"}. The user can see it now.` };
+}
+/** Build the Bivy MCP `Server` with tools/list + tools/call handlers wired. */
+export function createBivyMcpServer(deps = {}) {
+    const endpoint = deps.endpoint ?? process.env.BIVY_MCP_ENDPOINT ?? DEFAULT_ENDPOINT;
+    const sessionId = deps.sessionId ?? process.env.BIVY_SESSION_ID ?? process.env.BIVY_MCP_SESSION ?? "";
+    const token = deps.token ?? process.env.BIVY_MCP_TOKEN ?? undefined;
+    const fetchImpl = deps.fetchImpl ?? globalThis.fetch;
+    const server = new Server({ name: "bivy", version: "1.0.0" }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: BIVY_MCP_TOOLS }));
+    server.setRequestHandler(CallToolRequestSchema, async (req) => {
+        if (req.params.name !== "attach_to_chat") {
+            return { isError: true, content: [{ type: "text", text: `Unknown tool: ${req.params.name}` }] };
+        }
+        const result = await runAttachToChat(endpoint, sessionId, (req.params.arguments ?? {}), fetchImpl, token);
+        return { isError: result.isError, content: [{ type: "text", text: result.text }] };
+    });
+    return server;
+}
+/** Connect the Bivy MCP server to stdio and serve until the stream closes. */
+export async function runMcpServeCli(deps = {}) {
+    const server = createBivyMcpServer(deps);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // Resolves when the transport closes (agent disconnects / process is killed).
+    await new Promise((resolve) => transport.onclose = resolve);
+}
+// Run when invoked directly (via `bivy mcp-serve` → tsx this file). Emit nothing
+// to stdout except JSON-RPC — the transport owns stdin/stdout.
+const invokedDirectly = (() => {
+    try {
+        return Boolean(process.argv[1]) && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+    }
+    catch {
+        return false;
+    }
+})();
+if (invokedDirectly) {
+    void runMcpServeCli().catch((error) => {
+        process.stderr.write(`bivy mcp-serve: ${error instanceof Error ? error.message : String(error)}\n`);
+        process.exit(1);
+    });
+}

package/dist/server.js

@@ -55,7 +55,7 @@ import { evictToCap, dirSizeBytes } from "./harness/cache-evict.js";
 import { checkDiskAdmission } from "./harness/disk-admission.js";
 import { sandboxTier, setConfiguredSandboxTier, normalizeSandboxTier } from "./harness/sandbox.js";
 import { setConfiguredAutoAttachToolImages } from "./harness/tool-image-attachments.js";
-import { injectMcpProxyForSession } from "./harness/mcp-inject.js";
+import { injectMcpProxyForSession, injectBivyToolsForSession } from "./harness/mcp-inject.js";
 import { parseRepo, inferGitHubRepoFromWorkspace, isSharedCloneRoot, resolveGitHubToken, cloneOrUpdateRepo, resolveDefaultBaseRef, resolveBranchBaseRef, fetchOrigin } from "./repo-workspace.js";
 import { configureGitAuth, writeGitCredentialEndpoint } from "./git-auth.js";
 import { GitHubTaskPoller, resolveGitHubTaskConfig, buildTaskPrompt, buildResumePrompt, buildInteractiveResumePrompt, DEFAULT_ISSUE_INSTRUCTIONS, parseBivyDirectives, commitAll, pushBranch, mergeBaseIntoBranch, completeMerge, abortMerge, findOpenPullRequestForBranch, findPullRequestsForBranch, findMergedPullRequestForBranch, issueBranchName, getPullRequest, commentIssue, listOpenLabelledIssues, selectActionableIssues, getIssue, getIssueCommentBody, addLabel, removeLabel, announcePickup, } from "./github-tasks.js";
@@ -7438,6 +7438,36 @@ async function createSession(workspace = defaultWorkspace, sessionFile, opts = {
             // Injection is best-effort; never block session creation.
         }
     }
+    // Bivy-owned tools (attach_to_chat, …): make them discoverable to non-SDK
+    // agents by adding a `bivy` server (run via `bivy mcp-serve`) to the agent's
+    // config. Default-on (not gated on BIVY_MCP_PROXY) — it only ADDS a safe,
+    // session-scoped, restored capability the agent already has via env, so the
+    // chat can receive files. Claude/Pi expose these natively (in-process SDK MCP
+    // server / integration ToolProvider), so the tool-interception runtimes are
+    // skipped to avoid a duplicate registration.
+    if (!rt.capabilities.toolInterception) {
+        try {
+            const res = injectBivyToolsForSession(rt.id, {
+                workspace: sessionWorkspace,
+                home: os.homedir(),
+                sessionId,
+                endpoint: process.env.BIVY_MCP_ENDPOINT,
+            });
+            if (res.injected.length) {
+                const prev = record.mcpRestore;
+                record.mcpRestore = () => { try {
+                    res.restore();
+                }
+                finally {
+                    prev?.();
+                } };
+                console.log(`MCP tools: added bivy server to ${res.injected.length} config(s) for session ${sessionId}`);
+            }
+        }
+        catch {
+            // Best-effort; never block session creation.
+        }
+    }
     rememberSession(record);
     rememberWorkspace(sessionWorkspace);
     attachSessionListeners(record);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.5.1-staging.60",
+  "version": "0.5.1-staging.61",
   "type": "module",
   "license": "FSL-1.1-ALv2",
   "description": "Run coding agents on machines you own. Source-available, self-hostable agent workspace.",