@_davideast/stitch-mcp 0.5.2 → 0.5.3

package/dist/chunk-9ggfw78s.js

@@ -0,0 +1,19 @@
+import {
+  SiteBuilder
+} from "./chunk-4p1wfk3t.js";
+import"./chunk-krfqppg2.js";
+import"./chunk-yvzzrczy.js";
+import"./chunk-w8q7nsm7.js";
+import"./chunk-f1kjn6cd.js";
+import"./chunk-4jwmvjb4.js";
+import"./chunk-6gw9apqb.js";
+import"./chunk-a5xra9jn.js";
+import"./chunk-nq68kghz.js";
+import"./chunk-hc7sdwmn.js";
+import"./chunk-3sfn889r.js";
+import"./chunk-9wyra8hs.js";
+export {
+  SiteBuilder
+};
+
+//# debugId=1C4BD3D870A3482964756E2164756E21

package/dist/chunk-9ggfw78s.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "1C4BD3D870A3482964756E2164756E21",
+  "names": []
+}

package/dist/chunk-9nyyn1hn.js

@@ -0,0 +1,125 @@
+import {
+  JSONRPCMessageSchema,
+  StitchProxy
+} from "./chunk-a1mk24q9.js";
+import"./chunk-c6ge431q.js";
+import"./chunk-9wyra8hs.js";
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
+import process2 from "node:process";
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
+class ReadBuffer {
+  append(chunk) {
+    this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
+  }
+  readMessage() {
+    if (!this._buffer) {
+      return null;
+    }
+    const index = this._buffer.indexOf(`
+`);
+    if (index === -1) {
+      return null;
+    }
+    const line = this._buffer.toString("utf8", 0, index).replace(/\r$/, "");
+    this._buffer = this._buffer.subarray(index + 1);
+    return deserializeMessage(line);
+  }
+  clear() {
+    this._buffer = undefined;
+  }
+}
+function deserializeMessage(line) {
+  return JSONRPCMessageSchema.parse(JSON.parse(line));
+}
+function serializeMessage(message) {
+  return JSON.stringify(message) + `
+`;
+}
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
+class StdioServerTransport {
+  constructor(_stdin = process2.stdin, _stdout = process2.stdout) {
+    this._stdin = _stdin;
+    this._stdout = _stdout;
+    this._readBuffer = new ReadBuffer;
+    this._started = false;
+    this._ondata = (chunk) => {
+      this._readBuffer.append(chunk);
+      this.processReadBuffer();
+    };
+    this._onerror = (error) => {
+      this.onerror?.(error);
+    };
+  }
+  async start() {
+    if (this._started) {
+      throw new Error("StdioServerTransport already started! If using Server class, note that connect() calls start() automatically.");
+    }
+    this._started = true;
+    this._stdin.on("data", this._ondata);
+    this._stdin.on("error", this._onerror);
+  }
+  processReadBuffer() {
+    while (true) {
+      try {
+        const message = this._readBuffer.readMessage();
+        if (message === null) {
+          break;
+        }
+        this.onmessage?.(message);
+      } catch (error) {
+        this.onerror?.(error);
+      }
+    }
+  }
+  async close() {
+    this._stdin.off("data", this._ondata);
+    this._stdin.off("error", this._onerror);
+    const remainingDataListeners = this._stdin.listenerCount("data");
+    if (remainingDataListeners === 0) {
+      this._stdin.pause();
+    }
+    this._readBuffer.clear();
+    this.onclose?.();
+  }
+  send(message) {
+    return new Promise((resolve) => {
+      const json = serializeMessage(message);
+      if (this._stdout.write(json)) {
+        resolve();
+      } else {
+        this._stdout.once("drain", resolve);
+      }
+    });
+  }
+}
+
+// src/commands/proxy/handler.ts
+class ProxyCommandHandler {
+  createProxy;
+  createTransport;
+  constructor(deps) {
+    this.createProxy = deps?.createProxy ?? ((opts) => new StitchProxy(opts));
+    this.createTransport = deps?.createTransport ?? (() => new StdioServerTransport);
+  }
+  async execute(input) {
+    try {
+      const proxy = this.createProxy({
+        apiKey: process.env.STITCH_API_KEY
+      });
+      const transport = this.createTransport();
+      await proxy.start(transport);
+      await transport.onclose;
+      return { success: true, data: { status: "running" } };
+    } catch (e) {
+      return { success: false, error: { code: "PROXY_START_ERROR", message: e.message, recoverable: false } };
+    }
+  }
+}
+export {
+  ProxyCommandHandler
+};
+
+//# debugId=1A40EAFC14E573A564756E2164756E21

package/dist/chunk-9nyyn1hn.js.map

@@ -0,0 +1,12 @@
+{
+  "version": 3,
+  "sources": ["../node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js", "../node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js", "../src/commands/proxy/handler.ts"],
+  "sourcesContent": [
+    "import process from 'node:process';\nimport { ReadBuffer, serializeMessage } from '../shared/stdio.js';\n/**\n * Server transport for stdio: this communicates with an MCP client by reading from the current process' stdin and writing to stdout.\n *\n * This transport is only available in Node.js environments.\n */\nexport class StdioServerTransport {\n    constructor(_stdin = process.stdin, _stdout = process.stdout) {\n        this._stdin = _stdin;\n        this._stdout = _stdout;\n        this._readBuffer = new ReadBuffer();\n        this._started = false;\n        // Arrow functions to bind `this` properly, while maintaining function identity.\n        this._ondata = (chunk) => {\n            this._readBuffer.append(chunk);\n            this.processReadBuffer();\n        };\n        this._onerror = (error) => {\n            this.onerror?.(error);\n        };\n    }\n    /**\n     * Starts listening for messages on stdin.\n     */\n    async start() {\n        if (this._started) {\n            throw new Error('StdioServerTransport already started! If using Server class, note that connect() calls start() automatically.');\n        }\n        this._started = true;\n        this._stdin.on('data', this._ondata);\n        this._stdin.on('error', this._onerror);\n    }\n    processReadBuffer() {\n        while (true) {\n            try {\n                const message = this._readBuffer.readMessage();\n                if (message === null) {\n                    break;\n                }\n                this.onmessage?.(message);\n            }\n            catch (error) {\n                this.onerror?.(error);\n            }\n        }\n    }\n    async close() {\n        // Remove our event listeners first\n        this._stdin.off('data', this._ondata);\n        this._stdin.off('error', this._onerror);\n        // Check if we were the only data listener\n        const remainingDataListeners = this._stdin.listenerCount('data');\n        if (remainingDataListeners === 0) {\n            // Only pause stdin if we were the only listener\n            // This prevents interfering with other parts of the application that might be using stdin\n            this._stdin.pause();\n        }\n        // Clear the buffer and notify closure\n        this._readBuffer.clear();\n        this.onclose?.();\n    }\n    send(message) {\n        return new Promise(resolve => {\n            const json = serializeMessage(message);\n            if (this._stdout.write(json)) {\n                resolve();\n            }\n            else {\n                this._stdout.once('drain', resolve);\n            }\n        });\n    }\n}\n//# sourceMappingURL=stdio.js.map",
+    "import { JSONRPCMessageSchema } from '../types.js';\n/**\n * Buffers a continuous stdio stream into discrete JSON-RPC messages.\n */\nexport class ReadBuffer {\n    append(chunk) {\n        this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;\n    }\n    readMessage() {\n        if (!this._buffer) {\n            return null;\n        }\n        const index = this._buffer.indexOf('\\n');\n        if (index === -1) {\n            return null;\n        }\n        const line = this._buffer.toString('utf8', 0, index).replace(/\\r$/, '');\n        this._buffer = this._buffer.subarray(index + 1);\n        return deserializeMessage(line);\n    }\n    clear() {\n        this._buffer = undefined;\n    }\n}\nexport function deserializeMessage(line) {\n    return JSONRPCMessageSchema.parse(JSON.parse(line));\n}\nexport function serializeMessage(message) {\n    return JSON.stringify(message) + '\\n';\n}\n//# sourceMappingURL=stdio.js.map",
+    "import { StitchProxy } from '@google/stitch-sdk';\nimport type { StitchProxy as StitchProxyType } from '@google/stitch-sdk';\nimport { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';\n\ninterface ProxyCommandInput {\n  port?: number;\n  debug?: boolean;\n}\n\ninterface ProxyCommandResult {\n  success: boolean;\n  data?: { status: string };\n  error?: { code: string; message: string; recoverable: boolean };\n}\n\nexport class ProxyCommandHandler {\n  private createProxy: (opts: { apiKey?: string }) => StitchProxyType;\n  private createTransport: () => StdioServerTransport;\n\n  constructor(deps?: {\n    createProxy?: (opts: { apiKey?: string }) => StitchProxyType;\n    createTransport?: () => StdioServerTransport;\n  }) {\n    this.createProxy = deps?.createProxy ?? ((opts) => new StitchProxy(opts));\n    this.createTransport = deps?.createTransport ?? (() => new StdioServerTransport());\n  }\n\n  async execute(input: ProxyCommandInput): Promise<ProxyCommandResult> {\n    try {\n      const proxy = this.createProxy({\n        apiKey: process.env.STITCH_API_KEY,\n      });\n      const transport = this.createTransport();\n      await proxy.start(transport);\n      await transport.onclose;\n      return { success: true, data: { status: 'running' } };\n    } catch (e: any) {\n      return { success: false, error: { code: 'PROXY_START_ERROR', message: e.message, recoverable: false } };\n    }\n  }\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "1A40EAFC14E573A564756E2164756E21",
+  "names": []
+}

package/dist/chunk-9nzbvp6r.js

@@ -0,0 +1,19 @@
+import {
+  DoctorHandler
+} from "./chunk-5zy3et1m.js";
+import"./chunk-psmw9zpa.js";
+import"./chunk-zakq9pc0.js";
+import"./chunk-nq68kghz.js";
+import"./chunk-q6sv0243.js";
+import"./chunk-f2hq6bfv.js";
+import"./chunk-4jygt4d6.js";
+import"./chunk-tz7wnw4s.js";
+import"./chunk-kbtqrkwh.js";
+import"./chunk-3sfn889r.js";
+import"./chunk-c6ge431q.js";
+import"./chunk-9wyra8hs.js";
+export {
+  DoctorHandler
+};
+
+//# debugId=71BB7D9626616D6E64756E2164756E21

package/dist/chunk-9nzbvp6r.js.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "71BB7D9626616D6E64756E2164756E21",
+  "names": []
+}

package/dist/chunk-a0gmbh8e.js

@@ -0,0 +1,415 @@
+import {
+  downloadText
+} from "./chunk-34w2wfyp.js";
+import {
+  fetchWithRetry
+} from "./chunk-6gw9apqb.js";
+import"./chunk-akd997ec.js";
+import {
+  StitchToolClient,
+  stitch
+} from "./chunk-dmrahbs1.js";
+import {
+  pLimit
+} from "./chunk-a5xra9jn.js";
+import {
+  runSteps
+} from "./chunk-f2hq6bfv.js";
+import"./chunk-4jygt4d6.js";
+import"./chunk-tz7wnw4s.js";
+import"./chunk-c6ge431q.js";
+import"./chunk-9wyra8hs.js";
+
+// src/commands/tool/virtual-tools/get-screen-code.ts
+var getScreenCodeTool = {
+  name: "get_screen_code",
+  description: "(Virtual) Retrieves a screen and downloads its HTML code content.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      projectId: {
+        type: "string",
+        description: "Required. The project ID of screen to retrieve."
+      },
+      screenId: {
+        type: "string",
+        description: "Required. The name of screen to retrieve."
+      }
+    },
+    required: ["projectId", "screenId"]
+  },
+  execute: async (client, args, stitch2) => {
+    if (!stitch2)
+      throw new Error("get_screen_code requires a Stitch instance");
+    const { projectId, screenId } = args;
+    const screen = await stitch2.project(projectId).getScreen(screenId);
+    let htmlContent = null;
+    try {
+      const htmlUrl = await screen.getHtml();
+      if (htmlUrl) {
+        htmlContent = await downloadText(htmlUrl);
+      }
+    } catch (e) {
+      console.error(`Error downloading HTML code: ${e}`);
+    }
+    return {
+      screenId: screen.screenId,
+      projectId: screen.projectId,
+      htmlContent
+    };
+  }
+};
+// src/commands/tool/virtual-tools/get-screen-image.ts
+var getScreenImageTool = {
+  name: "get_screen_image",
+  description: "(Virtual) Retrieves a screen and downloads its screenshot image content.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      projectId: {
+        type: "string",
+        description: "Required. The project ID of screen to retrieve."
+      },
+      screenId: {
+        type: "string",
+        description: "Required. The name of screen to retrieve."
+      }
+    },
+    required: ["projectId", "screenId"]
+  },
+  execute: async (client, args, stitch2) => {
+    if (!stitch2)
+      throw new Error("get_screen_image requires a Stitch instance");
+    const { projectId, screenId } = args;
+    const screen = await stitch2.project(projectId).getScreen(screenId);
+    let imageContent = null;
+    try {
+      const imageUrl = await screen.getImage();
+      if (imageUrl) {
+        const response = await fetch(imageUrl);
+        const arrayBuffer = await response.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        imageContent = buffer.toString("base64");
+      }
+    } catch (e) {
+      console.error(`Error downloading screenshot: ${e}`);
+    }
+    return {
+      screenId: screen.screenId,
+      projectId: screen.projectId,
+      imageContent
+    };
+  }
+};
+// src/commands/tool/virtual-tools/build-site.ts
+var buildSiteTool = {
+  name: "build_site",
+  description: "(Virtual) Builds a site from a Stitch project by mapping screens to routes. Returns the design HTML for each page to use as context for code generation.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      projectId: {
+        type: "string",
+        description: "Required. The project ID to build a site from."
+      },
+      routes: {
+        type: "array",
+        description: "Required. Array of screen-to-route mappings.",
+        items: {
+          type: "object",
+          properties: {
+            screenId: {
+              type: "string",
+              description: "The screen ID to use for this route."
+            },
+            route: {
+              type: "string",
+              description: 'The route path (e.g. "/" or "/about").'
+            }
+          },
+          required: ["screenId", "route"]
+        }
+      }
+    },
+    required: ["projectId", "routes"]
+  },
+  execute: async (client, args, stitch2) => {
+    if (!stitch2)
+      throw new Error("build_site requires a Stitch instance");
+    const { projectId, routes } = args;
+    if (!Array.isArray(routes)) {
+      throw new Error("routes must be an array");
+    }
+    if (routes.length === 0) {
+      throw new Error("routes must be a non-empty array");
+    }
+    for (const entry of routes) {
+      if (!entry.screenId || typeof entry.screenId !== "string") {
+        throw new Error('Each route entry must have a "screenId" string');
+      }
+      if (!entry.route || typeof entry.route !== "string") {
+        throw new Error('Each route entry must have a "route" string');
+      }
+    }
+    const routePaths = routes.map((r) => r.route);
+    const uniqueRoutes = new Set(routePaths);
+    if (uniqueRoutes.size !== routePaths.length) {
+      const duplicates = routePaths.filter((r, i) => routePaths.indexOf(r) !== i);
+      throw new Error(`Duplicate route paths found: ${[...new Set(duplicates)].join(", ")}`);
+    }
+    const project = stitch2.project(projectId);
+    const sdkScreens = await project.screens();
+    const screenMap = new Map(sdkScreens.map((s) => [s.screenId, s]));
+    const missingIds = routes.map((r) => r.screenId).filter((id) => !screenMap.has(id));
+    if (missingIds.length > 0) {
+      throw new Error(`Screen IDs not found in project: ${missingIds.join(", ")}`);
+    }
+    const limit = pLimit(3);
+    const htmlContent = new Map;
+    const errors = [];
+    await Promise.all(routes.map((r) => limit(async () => {
+      const screen = screenMap.get(r.screenId);
+      try {
+        const htmlUrl = await screen.getHtml();
+        if (htmlUrl) {
+          const html = await fetchWithRetry(htmlUrl);
+          htmlContent.set(r.screenId, html);
+        } else {
+          htmlContent.set(r.screenId, "");
+        }
+      } catch (e) {
+        errors.push(`${r.screenId}: ${e.message}`);
+      }
+    })));
+    if (errors.length > 0) {
+      throw new Error(`Failed to fetch HTML for screens: ${errors.join("; ")}`);
+    }
+    const pages = routes.map((r) => ({
+      screenId: r.screenId,
+      route: r.route,
+      title: screenMap.get(r.screenId).title ?? r.screenId,
+      html: htmlContent.get(r.screenId)
+    }));
+    return {
+      success: true,
+      pages,
+      message: `Built ${pages.length} page(s) with design HTML`
+    };
+  }
+};
+// src/commands/tool/virtual-tools/list-tools.ts
+var listToolsTool = {
+  name: "list_tools",
+  description: "List all available tools with their descriptions and schemas.",
+  inputSchema: {
+    type: "object",
+    properties: {}
+  },
+  execute: async (client, _args) => {
+    const result = await client.listTools();
+    return result.tools || [];
+  }
+};
+// src/commands/tool/virtual-tools/index.ts
+var virtualTools = [
+  getScreenCodeTool,
+  getScreenImageTool,
+  buildSiteTool,
+  listToolsTool
+];
+
+// src/commands/tool/steps/ListToolsStep.ts
+class ListToolsStep {
+  id = "list-tools";
+  name = "List available tools";
+  async shouldRun(context) {
+    const name = context.input.toolName?.toLowerCase();
+    return !name || name === "list" || name === "listtools" || name === "list_tools";
+  }
+  async run(context) {
+    const result = await context.client.listTools();
+    const serverTools = result.tools || [];
+    const tools = [
+      ...context.virtualTools.map((t) => ({ name: t.name, description: t.description, inputSchema: t.inputSchema, virtual: true })),
+      ...serverTools.map((t) => ({ ...t, virtual: false }))
+    ];
+    context.result = { success: true, data: tools };
+    return { success: true };
+  }
+}
+
+// src/commands/tool/steps/ShowSchemaStep.ts
+class ShowSchemaStep {
+  id = "show-schema";
+  name = "Show tool schema";
+  async shouldRun(context) {
+    return !!context.input.toolName && context.input.toolName !== "list" && context.input.showSchema;
+  }
+  async run(context) {
+    const toolName = context.input.toolName;
+    const result = await context.client.listTools();
+    const serverTools = result.tools || [];
+    const allTools = [...context.virtualTools, ...serverTools];
+    const tool = allTools.find((t) => t.name === toolName);
+    if (!tool) {
+      context.result = { success: false, error: `Tool not found: ${toolName}` };
+      return { success: false, error: new Error(`Tool not found: ${toolName}`) };
+    }
+    context.result = { success: true, data: this.formatSchema(tool) };
+    return { success: true };
+  }
+  formatSchema(tool) {
+    const schema = tool.inputSchema;
+    const args = {};
+    if (schema?.properties) {
+      for (const [key, prop] of Object.entries(schema.properties)) {
+        const required = schema.required?.includes(key) ? "(required)" : "(optional)";
+        args[key] = `${prop.type} ${required}${prop.description ? " - " + prop.description : ""}`;
+      }
+    }
+    return {
+      name: tool.name,
+      description: tool.description,
+      virtual: tool.virtual ?? false,
+      arguments: args,
+      example: this.generateExample(tool)
+    };
+  }
+  generateExample(tool) {
+    const exampleArgs = {};
+    if (tool.inputSchema?.properties) {
+      for (const [key, prop] of Object.entries(tool.inputSchema.properties)) {
+        exampleArgs[key] = prop.type === "string" ? `<${key}>` : `<${prop.type}>`;
+      }
+    }
+    return `stitch-mcp tool ${tool.name} -d '${JSON.stringify(exampleArgs)}'`;
+  }
+}
+
+// src/commands/tool/steps/ParseArgsStep.ts
+class ParseArgsStep {
+  id = "parse-args";
+  name = "Parse tool arguments";
+  async shouldRun(context) {
+    return !!context.input.toolName && context.input.toolName !== "list" && !context.input.showSchema;
+  }
+  async run(context) {
+    let args = {};
+    if (context.input.data) {
+      args = JSON.parse(context.input.data);
+    } else if (context.input.dataFile) {
+      const content = await Bun.file(context.input.dataFile.replace("@", "")).text();
+      args = JSON.parse(content);
+    }
+    context.parsedArgs = args;
+    return { success: true };
+  }
+}
+
+// src/commands/tool/steps/ValidateToolStep.ts
+class ValidateToolStep {
+  id = "validate-tool";
+  name = "Validate tool exists";
+  async shouldRun(context) {
+    return !!context.input.toolName && context.input.toolName !== "list" && !context.input.showSchema && context.parsedArgs !== undefined;
+  }
+  async run(context) {
+    const toolName = context.input.toolName;
+    const result = await context.client.listTools();
+    const serverTools = result.tools || [];
+    const allTools = [...context.virtualTools, ...serverTools];
+    const found = allTools.find((t) => t.name === toolName);
+    if (!found) {
+      const availableNames = allTools.map((t) => t.name).sort();
+      context.result = {
+        success: false,
+        error: `Tool not found: "${toolName}". Use "list_tools" to see available tools.`,
+        data: {
+          requestedTool: toolName,
+          availableTools: availableNames,
+          hint: 'Call "list_tools" to see all available tools with descriptions and schemas.'
+        }
+      };
+      return { success: false, error: new Error(`Tool not found: ${toolName}`) };
+    }
+    return { success: true };
+  }
+}
+
+// src/commands/tool/steps/ExecuteToolStep.ts
+class ExecuteToolStep {
+  id = "execute-tool";
+  name = "Execute tool";
+  async shouldRun(context) {
+    return context.parsedArgs !== undefined;
+  }
+  async run(context) {
+    const toolName = context.input.toolName;
+    const args = context.parsedArgs;
+    const virtualTool = context.virtualTools.find((t) => t.name === toolName);
+    if (virtualTool) {
+      try {
+        const result2 = await virtualTool.execute(context.client, args, context.stitch);
+        context.result = { success: true, data: result2 };
+        return { success: true };
+      } catch (e) {
+        context.result = { success: false, error: `Virtual tool execution failed: ${e.message || String(e)}` };
+        return { success: false, error: e };
+      }
+    }
+    const result = await context.client.callTool(toolName, args);
+    context.result = { success: true, data: result };
+    return { success: true };
+  }
+}
+
+// src/commands/tool/handler.ts
+var deps = {
+  runSteps,
+  ListToolsStep,
+  ShowSchemaStep,
+  ParseArgsStep,
+  ValidateToolStep,
+  ExecuteToolStep
+};
+
+class ToolCommandHandler {
+  client;
+  stitchInstance;
+  tools;
+  steps;
+  constructor(client, tools, stitchInstance) {
+    this.client = client || new StitchToolClient;
+    this.stitchInstance = stitchInstance || stitch;
+    this.tools = tools || virtualTools;
+    this.steps = [
+      new deps.ListToolsStep,
+      new deps.ShowSchemaStep,
+      new deps.ParseArgsStep,
+      new deps.ValidateToolStep,
+      new deps.ExecuteToolStep
+    ];
+  }
+  async execute(input) {
+    const context = {
+      input,
+      client: this.client,
+      stitch: this.stitchInstance,
+      virtualTools: this.tools
+    };
+    try {
+      await deps.runSteps(this.steps, context, {
+        onAfterStep: (_step, _result, ctx) => ctx.result !== undefined
+      });
+    } finally {
+      await this.client.close();
+    }
+    return context.result ?? { success: false, error: "No step produced a result" };
+  }
+}
+export {
+  deps,
+  ToolCommandHandler
+};
+
+//# debugId=7A003C51AFD3BD2C64756E2164756E21