@yagni-app/code-staging 1.0.9-staging.1284.1 → 1.0.9-staging.1288.1

package/dist/extension/mcp/cliConfig.d.ts

@@ -7,6 +7,6 @@
 export { McpServerConfig, McpScope, PLUGIN_MCP_ENV, PROJECT_CONFIG_FILENAME, ScopedMcpServerConfig, expandEnvVarsInString, expandServerEnv, loadMcpServers, mcpConfigPath, readPluginMcpServers, readProjectMcpConfig, readUserMcpConfig, resolveProjectRoot, validateServerConfig, writeUserMcpConfig, } from "./config.js";
 export { ProjectApprovalState, decisionFor, readProjectApproval, recordProjectDecision, resetProjectChoices, undecidedProjectServers, } from "./approval.js";
 export { McpAuthFile, StoredOAuthEntry, deleteStoredOAuthEntry, getServerKey, getStoredOAuthEntry, mcpAuthPath, readMcpAuth, updateStoredOAuthEntry, writeMcpAuth, } from "./authStore.js";
-export { revokeTokensOnRemove } from "./auth.js";
+export { authenticate, revokeTokensOnRemove } from "./auth.js";
 export { probeServer, McpHealthResult, McpHealthStatus } from "./manager.js";
 //# sourceMappingURL=cliConfig.d.ts.map

package/dist/extension/mcp/cliConfig.js

@@ -7,6 +7,6 @@
 export { PLUGIN_MCP_ENV, PROJECT_CONFIG_FILENAME, expandEnvVarsInString, expandServerEnv, loadMcpServers, mcpConfigPath, readPluginMcpServers, readProjectMcpConfig, readUserMcpConfig, resolveProjectRoot, validateServerConfig, writeUserMcpConfig, } from "./config.js";
 export { decisionFor, readProjectApproval, recordProjectDecision, resetProjectChoices, undecidedProjectServers, } from "./approval.js";
 export { deleteStoredOAuthEntry, getServerKey, getStoredOAuthEntry, mcpAuthPath, readMcpAuth, updateStoredOAuthEntry, writeMcpAuth, } from "./authStore.js";
-export { revokeTokensOnRemove } from "./auth.js";
+export { authenticate, revokeTokensOnRemove } from "./auth.js";
 export { probeServer } from "./manager.js";
 //# sourceMappingURL=cliConfig.js.map

package/dist/extension/mcp/config.d.ts

@@ -36,6 +36,8 @@ export interface McpHttpServerConfig {
     url: string;
     headers?: Record<string, string>;
     oauth?: McpOAuthConfig;
+    /** Optional explicit tool names, used by the Worker connection to avoid duplicating existing context tools. */
+    tools?: string[];
 }
 export type McpServerConfig = McpStdioServerConfig | McpHttpServerConfig;
 export interface ScopedMcpServerConfig {

package/dist/extension/mcp/config.js

@@ -267,6 +267,8 @@ export function validateServerConfig(value) {
         return { ok: true };
     }
     if (type === "http" || type === "sse") {
+        if (v["tools"] !== undefined && (!Array.isArray(v["tools"]) || v["tools"].length > 100 || v["tools"].some(name => typeof name !== "string" || name.length === 0 || name.length > 128)))
+            return { ok: false, message: "tools must be an array of up to 100 tool names" };
         if (typeof v["url"] !== "string" || v["url"].length === 0) {
             return { ok: false, message: `${type} server requires a non-empty "url"` };
         }

package/dist/extension/mcp/tools.js

@@ -14,7 +14,11 @@ import { buildMcpToolName } from "./names.js";
 export const MAX_MCP_DESCRIPTION_LENGTH = 2048;
 export async function registerServerTools(pi, manager, serverName, env = process.env) {
     const server = manager.get(serverName);
-    const result = { tools: [], mutatingToolNames: [], warnings: [] };
+    const result = {
+        tools: [],
+        mutatingToolNames: [],
+        warnings: [],
+    };
     if (!server?.client)
         return result;
     let toolList;
@@ -26,7 +30,12 @@ export async function registerServerTools(pi, manager, serverName, env = process
         return result;
     }
     const toolTimeout = toolTimeoutFromEnv(env);
+    const selectedTools = server.config.type === "http" || server.config.type === "sse"
+        ? server.config.tools
+        : undefined;
     for (const tool of toolList.tools ?? []) {
+        if (selectedTools && !selectedTools.includes(tool.name))
+            continue;
         const fullToolName = buildMcpToolName(serverName, tool.name);
         if (!fullToolName) {
             result.warnings.push(`${serverName}: tool "${tool.name}" produced an empty wire name; skipped`);
@@ -45,7 +54,10 @@ export async function registerServerTools(pi, manager, serverName, env = process
                     throw new Error(`MCP server "${serverName}" is not connected (try /mcp reconnect).`);
                 }
                 const args = (params && typeof params === "object" ? params : {});
-                const call = active.client.callTool({ name: tool.name, arguments: args });
+                const call = active.client.callTool({
+                    name: tool.name,
+                    arguments: args,
+                });
                 const settled = toolTimeout
                     ? await withTimeout(call, toolTimeout, `MCP tool call timed out after ${toolTimeout}ms`)
                     : await call;
@@ -53,7 +65,12 @@ export async function registerServerTools(pi, manager, serverName, env = process
             },
         };
         pi.registerTool(definition);
-        result.tools.push({ toolName: fullToolName, serverName, originalName: tool.name, description });
+        result.tools.push({
+            toolName: fullToolName,
+            serverName,
+            originalName: tool.name,
+            description,
+        });
         if (mutating)
             result.mutatingToolNames.push(fullToolName);
     }
@@ -67,6 +84,19 @@ export function capDescription(description) {
 /** Cheap heuristic in the spirit of Claude Code's input-hint check; per-tool annotations arrive via listTools only in newer servers. */
 export function looksMutating(toolName, description) {
     const name = toolName.toLowerCase();
+    if ([
+        "critique_plan",
+        "review_pr",
+        "test_pr",
+        "validate_qa_replay",
+        "accept_qa_replay",
+        "authorize_qa_fork",
+        "engage_worker",
+        "propose_instruction_change",
+        "prepare_review_publication",
+        "resolve_decision",
+    ].includes(name))
+        return true;
     const writeHints = /^(create|add|update|edit|delete|remove|set|write|send|post|put|patch|deploy|publish|close|merge|assign|move|archive|trash|restore)/;
     if (writeHints.test(name))
         return true;
@@ -91,16 +121,49 @@ function schemaFor(inputSchema) {
 }
 function renderCallResult(settled, serverName, toolName) {
     const parts = [];
+    const images = [];
+    let imageBytes = 0;
     for (const item of settled.content ?? []) {
-        if (item && typeof item === "object" && item.type === "text") {
+        if (item &&
+            typeof item === "object" &&
+            item.type === "text") {
             parts.push(String(item.text ?? ""));
         }
+        else if (item &&
+            typeof item === "object" &&
+            "type" in item &&
+            item.type === "image") {
+            const value = item;
+            if (typeof value.data !== "string" ||
+                typeof value.mimeType !== "string" ||
+                !["image/png", "image/jpeg", "image/webp"].includes(value.mimeType) ||
+                value.data.length > 12 * 1024 * 1024 ||
+                images.length >= 8 ||
+                value.data.length % 4 !== 0 ||
+                !/^[A-Za-z0-9+/]*={0,2}$/.test(value.data))
+                throw new Error("MCP image is unsupported or exceeds its limit.");
+            const bytes = Buffer.byteLength(value.data, "base64");
+            imageBytes += bytes;
+            if (!bytes || imageBytes > 8 * 1024 * 1024)
+                throw new Error("MCP image is unsupported or exceeds its limit.");
+            images.push({
+                type: "image",
+                data: value.data,
+                mimeType: value.mimeType,
+            });
+        }
     }
-    const text = parts.join("\n") || "(no text content)";
+    const text = parts.join("\n") ||
+        (images.length
+            ? `Image returned by ${serverName}.${toolName} (untrusted tool content).`
+            : "(no text content)");
     if (settled.isError === true) {
         throw new Error(`MCP tool error from "${serverName}.${toolName}": ${text}`);
     }
-    return { content: [{ type: "text", text }], details: { server: serverName, tool: toolName } };
+    return {
+        content: [{ type: "text", text }, ...images],
+        details: { server: serverName, tool: toolName },
+    };
 }
 function withTimeout(promise, ms, message) {
     return new Promise((resolve, reject) => {

package/dist/mcpCommand.d.ts

@@ -38,6 +38,13 @@ export interface McpDeps {
 }
 /** The structural slice of the extension's mcp config surface this file needs. */
 export interface McpCliModule {
+    authenticate?(serverName: string, config: {
+        type: "http";
+        url: string;
+        tools: string[];
+    }): Promise<{
+        result: "AUTHORIZED";
+    }>;
     loadMcpServers(cwd: string, env: NodeJS.ProcessEnv): McpLoadResult;
     mcpConfigPath(): string;
     PROJECT_CONFIG_FILENAME: string;

package/dist/mcpCommand.js

@@ -21,7 +21,7 @@ import { fileURLToPath } from "node:url";
 import { CLAUDE_PLUGIN_MCP_ENV, claudeCompatArgs } from "./claudeCompat.js";
 import { agentDir } from "./credentials.js";
 import { DISTRIBUTION } from "./distribution.js";
-import { getActiveProfileName } from "./profiles.js";
+import { getActiveProfileName, readActiveProfile } from "./profiles.js";
 export function resolveMcpConfigPath() {
     const bundled = fileURLToPath(new URL("./extension/mcp/cliConfig.js", import.meta.url));
     if (existsSync(bundled))
@@ -55,6 +55,9 @@ Scopes:
   user     available in all your projects (~/.yagni-code/mcp.json)
   project  shared via .mcp.json at the repo root (approval-gated)
 
+Connect YAGNI Workers:
+  ${DISTRIBUTION.commandName} mcp connect-workers   Browser consent for the active environment
+
 Examples:
   ${DISTRIBUTION.commandName} mcp add --transport http sentry https://mcp.sentry.dev/mcp
   ${DISTRIBUTION.commandName} mcp add -e API_KEY=xxx my-server -- npx my-mcp-server
@@ -90,7 +93,10 @@ export function parseMcpArgs(argv) {
             rest.push(...after.slice(i + 1));
             break;
         }
-        if (flag === "s" || flag === "t" || flag === "client-id" || flag === "callback-port") {
+        if (flag === "s" ||
+            flag === "t" ||
+            flag === "client-id" ||
+            flag === "callback-port") {
             if (flag === "s") {
                 scope = scopeFrom(arg);
                 scopeExplicit = true;
@@ -204,11 +210,28 @@ export function parseMcpArgs(argv) {
         }
         rest.push(arg);
     }
-    if (flag === "s" || flag === "t" || flag === "client-id" || flag === "callback-port") {
+    if (flag === "s" ||
+        flag === "t" ||
+        flag === "client-id" ||
+        flag === "callback-port") {
         throw new Error("Missing flag value.");
     }
     const [name, ...commandArgs] = rest;
-    return { subcommand, name, rest, scope, scopeExplicit, transport, transportExplicit, env, headers, commandArgs, clientId, clientSecret, callbackPort };
+    return {
+        subcommand,
+        name,
+        rest,
+        scope,
+        scopeExplicit,
+        transport,
+        transportExplicit,
+        env,
+        headers,
+        commandArgs,
+        clientId,
+        clientSecret,
+        callbackPort,
+    };
 }
 function scopeFrom(value) {
     if (value === "local" || value === "user" || value === "project")
@@ -236,7 +259,11 @@ function describeScopePath(scope, cwd) {
 async function defaultPluginMcpEnv(cwd) {
     try {
         const profile = await getActiveProfileName();
-        const compat = await claudeCompatArgs({ cwd, agentDir: agentDir(profile), interactive: false });
+        const compat = await claudeCompatArgs({
+            cwd,
+            agentDir: agentDir(profile),
+            interactive: false,
+        });
         return compat.env[CLAUDE_PLUGIN_MCP_ENV];
     }
     catch {
@@ -272,6 +299,8 @@ export async function mcpCommand(args, deps = {}) {
         return 1;
     }
     switch (parsed.subcommand) {
+        case "connect-workers":
+            return connectWorkers(mod, parsed, { cwd, stdout, stderr }, deps.env ?? process.env);
         case undefined:
         case "help":
             stdout(USAGE);
@@ -283,18 +312,105 @@ export async function mcpCommand(args, deps = {}) {
         case "remove":
             return mcpRemove(mod, parsed, { cwd, stdout, stderr });
         case "list":
-            return mcpList(mod, { cwd, stdout, stderr, env: await envWithPluginMcp(deps, cwd), probeServer: deps.probeServer });
+            return mcpList(mod, {
+                cwd,
+                stdout,
+                stderr,
+                env: await envWithPluginMcp(deps, cwd),
+                probeServer: deps.probeServer,
+            });
         case "get":
-            return mcpGet(mod, parsed, { cwd, stdout, stderr, env: await envWithPluginMcp(deps, cwd), probeServer: deps.probeServer });
+            return mcpGet(mod, parsed, {
+                cwd,
+                stdout,
+                stderr,
+                env: await envWithPluginMcp(deps, cwd),
+                probeServer: deps.probeServer,
+            });
         case "reset-project-choices":
             return mcpResetChoices(mod, { cwd, stdout, stderr });
         case "add-from-claude":
-            return mcpAddFromClaude(mod, parsed, { cwd, stdout, stderr, home: deps.home ?? homedir() });
+            return mcpAddFromClaude(mod, parsed, {
+                cwd,
+                stdout,
+                stderr,
+                home: deps.home ?? homedir(),
+            });
         default:
             stderr(`Unknown mcp subcommand "${parsed.subcommand}".\n${USAGE}`);
             return 1;
     }
 }
+const WORKER_TOOL_NAMES = [
+    "get_context",
+    "create_team",
+    "engage_worker",
+    "critique_plan",
+    "review_pr",
+    "test_pr",
+    "get_qa_evidence",
+    "get_qa_replay",
+    "validate_qa_replay",
+    "accept_qa_replay",
+    "authorize_qa_fork",
+    "list_work",
+    "get_work",
+    "add_feedback",
+    "propose_instruction_change",
+    "prepare_review_publication",
+    "resolve_decision",
+];
+async function connectWorkers(mod, parsed, io, env) {
+    if (parsed.rest.length ||
+        parsed.scopeExplicit ||
+        parsed.transportExplicit ||
+        Object.keys(parsed.headers).length ||
+        Object.keys(parsed.env).length ||
+        parsed.clientId ||
+        parsed.clientSecret ||
+        parsed.callbackPort) {
+        io.stderr("Usage: yagni mcp connect-workers (uses your active environment and private user configuration)\n");
+        return 1;
+    }
+    try {
+        if (!mod.authenticate)
+            throw new Error("Update YAGNI Code to connect Workers");
+        const profile = await readActiveProfile(env);
+        const url = new URL("/mcp", profile.baseUrl);
+        if (url.username ||
+            url.password ||
+            (url.protocol !== "https:" &&
+                !(url.protocol === "http:" &&
+                    ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))))
+            throw new Error("Worker connections require HTTPS or a local development server");
+        const config = {
+            type: "http",
+            url: url.href,
+            tools: WORKER_TOOL_NAMES,
+        };
+        const { file, errors } = mod.readUserMcpConfig();
+        if (errors.length)
+            throw new Error("Fix the existing MCP configuration before connecting Workers");
+        const previous = file
+            .mcpServers?.["yagni-workers"];
+        if (previous && JSON.stringify(previous) !== JSON.stringify(config))
+            throw new Error("An existing yagni-workers connection uses different settings. Remove it with yagni mcp remove yagni-workers before reconnecting");
+        const shadow = mod
+            .loadMcpServers(io.cwd, env)
+            .servers.find((server) => server.name === "yagni-workers" && server.scope !== "user");
+        if (shadow)
+            throw new Error("A project or local yagni-workers entry would override this connection. Remove that entry before connecting");
+        io.stdout("Opening YAGNI in your browser. Choose your workspace and permissions; paid Worker requests use that workspace's balance.\n");
+        await mod.authenticate("yagni-workers", config);
+        writeServerToScope(mod, "yagni-workers", config, "user", io.cwd);
+        io.stdout("Workers connected. Start a new YAGNI Code session to use them; /mcp shows connection status.\n");
+        return 0;
+    }
+    catch {
+        io.stderr("Worker connection did not complete. Check your environment and existing yagni-workers configuration, then retry browser consent.\n");
+        return 1;
+    }
+}
 function mcpAdd(mod, parsed, io) {
     const { name, rest } = parsed;
     const commandOrUrl = rest[1];
@@ -308,7 +424,9 @@ function mcpAdd(mod, parsed, io) {
         serverConfig = {
             type: parsed.transport,
             url: commandOrUrl,
-            ...(Object.keys(parsed.headers).length > 0 ? { headers: parsed.headers } : {}),
+            ...(Object.keys(parsed.headers).length > 0
+                ? { headers: parsed.headers }
+                : {}),
             ...(oauthBlock(parsed) ? { oauth: oauthBlock(parsed) } : {}),
         };
     }
@@ -398,18 +516,29 @@ function readClientSecret(io) {
 function validateConfigShape(config) {
     const type = config["type"];
     if (type === undefined || type === "stdio") {
-        if (typeof config["command"] !== "string" || config["command"].length === 0) {
-            return { ok: false, message: 'stdio server requires a non-empty "command"' };
+        if (typeof config["command"] !== "string" ||
+            config["command"].length === 0) {
+            return {
+                ok: false,
+                message: 'stdio server requires a non-empty "command"',
+            };
         }
         return { ok: true };
     }
     if (type === "http" || type === "sse") {
-        if (typeof config["url"] !== "string" || config["url"].length === 0) {
-            return { ok: false, message: `${type} server requires a non-empty "url"` };
+        if (typeof config["url"] !== "string" ||
+            config["url"].length === 0) {
+            return {
+                ok: false,
+                message: `${type} server requires a non-empty "url"`,
+            };
         }
         return { ok: true };
     }
-    return { ok: false, message: 'unknown "type" — expected stdio, http, or sse' };
+    return {
+        ok: false,
+        message: 'unknown "type" — expected stdio, http, or sse',
+    };
 }
 function writeServerToScope(mod, name, config, scope, cwd) {
     if (scope === "project") {
@@ -584,7 +713,9 @@ async function mcpGet(mod, parsed, io) {
     else {
         io.stdout(`  Type: stdio\n`);
         io.stdout(`  Command: ${config["command"]}\n`);
-        const args = Array.isArray(config["args"]) ? config["args"] : [];
+        const args = Array.isArray(config["args"])
+            ? config["args"]
+            : [];
         if (args.length > 0)
             io.stdout(`  Args: ${args.join(" ")}\n`);
         for (const [key, value] of Object.entries(config["env"] ?? {})) {
@@ -610,7 +741,9 @@ function printOAuthDetail(mod, name, config, stdout) {
     const cfg = config;
     const oauth = cfg["oauth"] ?? {};
     const clientId = typeof oauth["clientId"] === "string" ? oauth["clientId"] : undefined;
-    const callbackPort = typeof oauth["callbackPort"] === "number" ? oauth["callbackPort"] : undefined;
+    const callbackPort = typeof oauth["callbackPort"] === "number"
+        ? oauth["callbackPort"]
+        : undefined;
     const stored = mod.getStoredOAuthEntry(name, config);
     if (clientId || callbackPort || stored?.clientSecret) {
         stdout(`  OAuth: client_id ${clientId ? "configured" : "(DCR)"}, client_secret ${stored?.clientSecret ? "configured" : "not set"}${callbackPort ? `, callback_port ${callbackPort}` : ""}\n`);
@@ -642,10 +775,20 @@ async function mcpList(mod, io) {
         return 0;
     }
     const lines = [];
-    const byScope = { user: [], project: [], local: [], plugin: [] };
+    const byScope = {
+        user: [],
+        project: [],
+        local: [],
+        plugin: [],
+    };
     for (const s of servers)
         (byScope[s.scope] ??= []).push(s);
-    const labels = { local: "Local", project: "Project", user: "User", plugin: "Plugin" };
+    const labels = {
+        local: "Local",
+        project: "Project",
+        user: "User",
+        plugin: "Plugin",
+    };
     for (const scope of ["local", "project", "user", "plugin"]) {
         const group = byScope[scope];
         if (!group?.length)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yagni-app/code-staging",
-  "version": "1.0.9-staging.1284.1",
+  "version": "1.0.9-staging.1288.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)",
@@ -58,5 +58,5 @@
     "turndown": "^7.2.4",
     "typebox": "^1.3.15"
   },
-  "yagniSourceSha": "286c10887150e0d8d4abf763d44c780830a7710e"
+  "yagniSourceSha": "8afdf669270c6b0b2cd82437939af8d18427f1c6"
 }