@yagni-app/code-staging 0.1.0-staging.1002.1 → 0.1.0-staging.1009.1

package/dist/extension/index.d.ts

@@ -1,5 +1,6 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { runInitPass as defaultRunInitPass } from "./initPass.js";
+import { fetchMcpServers as defaultFetchMcpServers } from "./mcpTools.js";
 import { type FlushOutcome, type SpoolClientOpts } from "./spool.js";
 import { type TokenProvider } from "./tokenProvider.js";
 import { type ContextBrief, type ModelEntry } from "./config.js";
@@ -35,6 +36,12 @@ export interface RegisterYagniDeps {
         getToken: () => string | undefined;
         fetchImpl?: typeof fetch;
     }) => Promise<ContextBrief | null>;
+    /**
+     * Workspace MCP server list seam (YAG-446). The default hits
+     * `/api/yagni-code/mcp/servers` and is fail-soft: older backends and
+     * un-rescoped tokens yield `[]`, never a startup error.
+     */
+    fetchMcpServers?: typeof defaultFetchMcpServers;
     /**
      * The CLI init pass (Onramp Door B). Injectable so tests assert it fires on a
      * fresh-workspace first-run and is skipped otherwise, without a network or disk.

package/dist/extension/index.js

@@ -10,9 +10,10 @@ import { BRAND_NAME, brandSystemPrompt, buildMastheadString } from "./branding.j
 import { registerCostCommand } from "./costHud.js";
 import { isFreshWorkspace, runInitPass as defaultRunInitPass } from "./initPass.js";
 import { isInitDone as defaultIsInitDone, markInitDone as defaultMarkInitDone } from "./initDone.js";
+import { fetchMcpServers as defaultFetchMcpServers, registerMcpCommand, registerMcpTools, } from "./mcpTools.js";
 import { registerGoCommand } from "./pipeline/goCommand.js";
 import { registerGoCompareCommand } from "./pipeline/goCompareCommand.js";
-import { registerPermissionGate } from "./permission.js";
+import { DEFAULT_PERMISSION_POLICY, registerPermissionGate } from "./permission.js";
 import { registerSubagents } from "./subagents.js";
 import { registerTodos } from "./todos.js";
 import { registerDecisionCommands } from "./decisions.js";
@@ -103,10 +104,36 @@ export async function registerYagni(pi, deps = {}) {
     const decisionCapture = evalMode ? undefined : makeDecisionCapture(decisionClientOpts);
     if (!evalMode)
         registerDecisionCommands(pi, decisionClientOpts);
+    // Workspace MCP servers (YAG-446): register one tool per enabled server
+    // tool, executing through the backend proxy, plus the /mcp listing
+    // command. Fail-soft fetch (older backend / un-rescoped token → no MCP
+    // tools); skipped in eval mode like the other external-side-effect tools.
+    const fetchMcp = deps.fetchMcpServers ?? defaultFetchMcpServers;
+    const mcpServers = evalMode
+        ? []
+        : await fetchMcp({ baseUrl, getToken: getTokenFn, fetchImpl: authedFetch });
+    const { mutatingToolNames: mcpMutatingTools } = registerMcpTools(pi, mcpServers, { baseUrl, getToken: getTokenFn, fetchImpl: authedFetch });
+    registerMcpCommand(pi, mcpServers, { baseUrl });
     // P3 + W4: interactive permission tiers + plan mode via /mode, now with a
     // session bless store (three-way review-mode select) and a capture hook that
     // drafts a decision on "don't ask again". Default auto, so still additive.
+    // Mutating MCP tools join write/edit/bash in the gate policy: plan mode
+    // holds them, review mode confirms them.
     registerPermissionGate(pi, {
+        ...(mcpMutatingTools.length > 0
+            ? {
+                policy: {
+                    planBlockTools: [
+                        ...DEFAULT_PERMISSION_POLICY.planBlockTools,
+                        ...mcpMutatingTools,
+                    ],
+                    reviewConfirmTools: [
+                        ...DEFAULT_PERMISSION_POLICY.reviewConfirmTools,
+                        ...mcpMutatingTools,
+                    ],
+                },
+            }
+            : {}),
         onBlessRemember: decisionCapture
             ? (ctx, info) => decisionCapture.captureFromBless(ctx, info)
             : undefined,

package/dist/extension/mcpTools.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Workspace MCP servers in YAGNI Code (YAG-446).
+ *
+ * The workspace's registered MCP servers (Connections → MCP Servers) are
+ * the config source: at session start we fetch the list from the backend
+ * and register one pi tool per enabled server tool, named with the same
+ * `mcp_<slug>__<tool>` wire shape the backend executor parses. Calls
+ * execute THROUGH the backend (`POST /api/yagni-code/mcp/call`), so
+ * credentials never reach this machine and the backend's egress guard,
+ * autonomy gate, per-user credential policy, and audit trail all apply.
+ *
+ * Everything here is fail-soft against an older backend or an
+ * un-rescoped token: a 403/404/network failure on the list fetch means
+ * no MCP tools and no startup error.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+export interface McpToolInfo {
+    name: string;
+    description: string | null;
+    inputSchema: unknown;
+    riskClass: string;
+}
+export interface McpServerInfo {
+    slug: string;
+    name: string;
+    tools: McpToolInfo[];
+    viewerCredential: {
+        source: "user" | "workspace";
+    };
+}
+export interface McpClientOpts {
+    baseUrl: string;
+    getToken: () => string | undefined;
+    fetchImpl?: typeof fetch;
+}
+export declare function mcpWireToolName(slug: string, tool: string): string;
+/**
+ * Fetch the workspace's MCP servers. Fail-soft by design: any non-OK
+ * response (older backend without the endpoints, token minted before the
+ * `yagni_code:mcp` scope existed) or transport error returns `[]`.
+ */
+export declare function fetchMcpServers(opts: McpClientOpts): Promise<McpServerInfo[]>;
+/**
+ * Register every reachable MCP tool. Returns the wire names of MUTATING
+ * tools so the caller can extend the permission-gate policy — plan mode
+ * holds them, review mode confirms them, exactly like write/edit/bash.
+ */
+export declare function registerMcpTools(pi: ExtensionAPI, servers: McpServerInfo[], opts: McpClientOpts): {
+    mutatingToolNames: string[];
+};
+/** Render the /mcp listing (pure, for tests). */
+export declare function renderMcpListing(servers: McpServerInfo[], baseUrl: string): string;
+/** Wire the `/mcp` command: list servers, tools, and credential status. */
+export declare function registerMcpCommand(pi: ExtensionAPI, servers: McpServerInfo[], opts: {
+    baseUrl: string;
+}): void;
+//# sourceMappingURL=mcpTools.d.ts.map

package/dist/extension/mcpTools.js

@@ -0,0 +1,132 @@
+import { Type } from "typebox";
+import { friendlyFetchError, METERED_POST_FETCH_POLICY, resilientFetch } from "./resilientFetch.js";
+export function mcpWireToolName(slug, tool) {
+    return `mcp_${slug}__${tool}`;
+}
+/**
+ * Fetch the workspace's MCP servers. Fail-soft by design: any non-OK
+ * response (older backend without the endpoints, token minted before the
+ * `yagni_code:mcp` scope existed) or transport error returns `[]`.
+ */
+export async function fetchMcpServers(opts) {
+    try {
+        const res = await resilientFetch(`${opts.baseUrl}/api/yagni-code/mcp/servers`, {
+            method: "GET",
+            headers: { authorization: `Bearer ${opts.getToken() ?? ""}` },
+        }, { fetchImpl: opts.fetchImpl });
+        if (!res.ok)
+            return [];
+        const data = (await res.json());
+        if (!Array.isArray(data.servers))
+            return [];
+        return data.servers;
+    }
+    catch {
+        return [];
+    }
+}
+function schemaFor(tool) {
+    const schema = tool.inputSchema;
+    if (schema !== null &&
+        typeof schema === "object" &&
+        !Array.isArray(schema) &&
+        Object.keys(schema).length > 0) {
+        // MCP inputSchemas are plain JSON Schema objects, which is exactly what
+        // TypeBox schemas are at runtime — pass the server's schema through so
+        // the model sees real parameter shapes.
+        return schema;
+    }
+    return Type.Object({}, { additionalProperties: true });
+}
+function makeMcpTool(server, tool, opts) {
+    const wireName = mcpWireToolName(server.slug, tool.name);
+    return {
+        name: wireName,
+        label: `${server.name}: ${tool.name}`,
+        description: `${tool.description ?? `MCP tool ${tool.name}`} ` +
+            `(MCP server "${server.name}", risk: ${tool.riskClass}; runs through YAGNI)`,
+        parameters: schemaFor(tool),
+        async execute(_toolCallId, params, signal) {
+            const res = await resilientFetch(`${opts.baseUrl}/api/yagni-code/mcp/call`, {
+                method: "POST",
+                headers: {
+                    "content-type": "application/json",
+                    authorization: `Bearer ${opts.getToken() ?? ""}`,
+                },
+                body: JSON.stringify({
+                    slug: server.slug,
+                    tool: tool.name,
+                    args: params ?? {},
+                }),
+            }, { fetchImpl: opts.fetchImpl, signal, policy: METERED_POST_FETCH_POLICY });
+            if (!res.ok) {
+                throw new Error(await friendlyFetchError(wireName, res));
+            }
+            const result = (await res.json());
+            if (!result.success) {
+                const suffix = result.errorCode === "user_credential_required"
+                    ? ` Bind your token at ${opts.baseUrl}/services/mcp.`
+                    : "";
+                throw new Error(`${result.error ?? "MCP tool call failed"}${suffix}`);
+            }
+            const text = typeof result.result === "string"
+                ? result.result
+                : JSON.stringify(result.result ?? null, null, 2);
+            return {
+                content: [{ type: "text", text }],
+                details: { riskClass: tool.riskClass },
+            };
+        },
+    };
+}
+/**
+ * Register every reachable MCP tool. Returns the wire names of MUTATING
+ * tools so the caller can extend the permission-gate policy — plan mode
+ * holds them, review mode confirms them, exactly like write/edit/bash.
+ */
+export function registerMcpTools(pi, servers, opts) {
+    const mutatingToolNames = [];
+    for (const server of servers) {
+        for (const tool of server.tools) {
+            pi.registerTool(makeMcpTool(server, tool, opts));
+            if (tool.riskClass !== "read_only") {
+                mutatingToolNames.push(mcpWireToolName(server.slug, tool.name));
+            }
+        }
+    }
+    return { mutatingToolNames };
+}
+/** Render the /mcp listing (pure, for tests). */
+export function renderMcpListing(servers, baseUrl) {
+    if (servers.length === 0) {
+        return [
+            "No MCP servers connected for this workspace.",
+            `An admin can register one under Connections: ${baseUrl}/services/mcp`,
+        ].join("\n");
+    }
+    const lines = ["Workspace MCP servers:"];
+    for (const server of servers) {
+        const mutating = server.tools.filter((t) => t.riskClass !== "read_only").length;
+        const credential = server.viewerCredential.source === "user"
+            ? "connected as you"
+            : "workspace credential";
+        lines.push(`  ${server.name} (${server.slug}) — ${server.tools.length} tool${server.tools.length === 1 ? "" : "s"}` +
+            `${mutating > 0 ? ` (${mutating} mutating)` : ""} · ${credential}`);
+        for (const tool of server.tools) {
+            lines.push(`    ${mcpWireToolName(server.slug, tool.name)} [${tool.riskClass}]`);
+        }
+    }
+    lines.push(`Bind a personal token (writes carry your authority): ${baseUrl}/services/mcp`);
+    return lines.join("\n");
+}
+/** Wire the `/mcp` command: list servers, tools, and credential status. */
+export function registerMcpCommand(pi, servers, opts) {
+    pi.registerCommand("mcp", {
+        description: "List this workspace's MCP servers, their tools, and your credential status.",
+        handler: async (_args, ctx) => {
+            if (ctx.hasUI)
+                ctx.ui.notify(renderMcpListing(servers, opts.baseUrl), "info");
+        },
+    });
+}
+//# sourceMappingURL=mcpTools.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "0.1.0-staging.1002.1",
+  "version": "0.1.0-staging.1009.1",
   "description": "YAGNI Code: a terminal coding agent that already knows your company. One YAGNI login routes the model and grounds the agent in your team's context.",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "YAGNI, Inc. <jack@yagni.app> (https://yagni.app)",
@@ -38,5 +38,5 @@
     "@earendil-works/pi-tui": "0.83.0",
     "typebox": "^1.1.38"
   },
-  "yagniSourceSha": "b173c9b46d20c3399724503b72e2d83b65f3dedb"
+  "yagniSourceSha": "fb42dd685b7ca9834b2861f48493f4ed6fd1caaa"
 }