@_davideast/stitch-mcp 0.5.2 → 0.5.3

package/dist/chunk-yjnj35q8.js

@@ -0,0 +1,1495 @@
+import {
+  StitchHandler,
+  createSpinner
+} from "./chunk-psmw9zpa.js";
+import {
+  ConsoleUI,
+  GcloudHandler,
+  execCommand,
+  promptConfirm,
+  promptInput,
+  promptSelect
+} from "./chunk-zakq9pc0.js";
+import {
+  runSteps
+} from "./chunk-f2hq6bfv.js";
+import {
+  icons,
+  theme
+} from "./chunk-kbtqrkwh.js";
+import {
+  __require
+} from "./chunk-9wyra8hs.js";
+
+// src/services/project/handler.ts
+class ProjectHandler {
+  gcloudService;
+  constructor(gcloudService) {
+    this.gcloudService = gcloudService;
+  }
+  async selectProject(input) {
+    try {
+      const projectsResult = await this.gcloudService.listProjects({
+        limit: input.limit,
+        sortBy: "~createTime"
+      });
+      if (!projectsResult.success) {
+        return {
+          success: false,
+          error: {
+            code: "SEARCH_FAILED",
+            message: "Failed to fetch projects",
+            suggestion: "Ensure you are authenticated and have access to GCP projects",
+            recoverable: true
+          }
+        };
+      }
+      const projects = projectsResult.data.projects;
+      if (projects.length === 0) {
+        return {
+          success: false,
+          error: {
+            code: "NO_PROJECTS_FOUND",
+            message: "No projects found in your account",
+            suggestion: "Create a project at https://console.cloud.google.com",
+            recoverable: false
+          }
+        };
+      }
+      const choices = [
+        ...input.allowSearch ? [{ name: theme.gray("\uD83D\uDD0D Search for a project..."), value: "__SEARCH__" }] : [],
+        ...projects.map((p) => ({
+          name: `${p.name} ${theme.gray(`(${p.projectId})`)}`,
+          value: p.projectId
+        }))
+      ];
+      const selected = await promptSelect("Select a project", choices);
+      if (selected === "__SEARCH__") {
+        return await this.searchAndSelect();
+      }
+      const selectedProject = projects.find((p) => p.projectId === selected);
+      if (!selectedProject) {
+        return {
+          success: false,
+          error: {
+            code: "SELECTION_CANCELLED",
+            message: "Project selection failed",
+            recoverable: true
+          }
+        };
+      }
+      return {
+        success: true,
+        data: {
+          projectId: selectedProject.projectId,
+          name: selectedProject.name
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: {
+          code: "UNKNOWN_ERROR",
+          message: error instanceof Error ? error.message : String(error),
+          recoverable: false
+        }
+      };
+    }
+  }
+  async getProjectDetails(input) {
+    try {
+      const projectResult = await this.gcloudService.listProjects({
+        filter: `projectId:${input.projectId}`,
+        limit: 1
+      });
+      if (!projectResult.success) {
+        return {
+          success: false,
+          error: {
+            code: "PROJECT_FETCH_FAILED",
+            message: `Failed to fetch project details: ${projectResult.error.message}`,
+            recoverable: true
+          }
+        };
+      }
+      if (projectResult.data.projects.length === 0) {
+        return {
+          success: false,
+          error: {
+            code: "PROJECT_NOT_FOUND",
+            message: `Project not found: ${input.projectId}`,
+            recoverable: true
+          }
+        };
+      }
+      const project = projectResult.data.projects[0];
+      return {
+        success: true,
+        data: {
+          projectId: project.projectId,
+          name: project.name
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: {
+          code: "UNKNOWN_ERROR",
+          message: error instanceof Error ? error.message : String(error),
+          recoverable: false
+        }
+      };
+    }
+  }
+  async searchAndSelect() {
+    try {
+      const query = await promptInput("Enter project name or ID to search (press Enter)");
+      if (!query.trim()) {
+        return {
+          success: false,
+          error: {
+            code: "SELECTION_CANCELLED",
+            message: "Search cancelled",
+            recoverable: true
+          }
+        };
+      }
+      const searchResult = await this.gcloudService.listProjects({
+        filter: `name:*${query}* OR projectId:*${query}*`,
+        limit: 5
+      });
+      if (!searchResult.success) {
+        return {
+          success: false,
+          error: {
+            code: "SEARCH_FAILED",
+            message: `Search failed: ${searchResult.error.message}`,
+            recoverable: true
+          }
+        };
+      }
+      const projects = searchResult.data.projects;
+      if (projects.length === 0) {
+        const useManual = await promptConfirm(`No projects found matching "${query}". Use "${query}" as project ID?`, false);
+        if (useManual) {
+          return {
+            success: true,
+            data: {
+              projectId: query,
+              name: query
+            }
+          };
+        }
+        return {
+          success: false,
+          error: {
+            code: "NO_PROJECTS_FOUND",
+            message: `No projects found matching "${query}"`,
+            suggestion: "Try a different search term or select from recent projects",
+            recoverable: true
+          }
+        };
+      }
+      const choices = projects.map((p) => ({
+        name: `${p.name} ${theme.gray(`(${p.projectId})`)}`,
+        value: p.projectId
+      }));
+      const selected = await promptSelect(`Search results for "${query}"`, choices);
+      const selectedProject = projects.find((p) => p.projectId === selected);
+      if (!selectedProject) {
+        return {
+          success: false,
+          error: {
+            code: "SELECTION_CANCELLED",
+            message: "Selection cancelled",
+            recoverable: true
+          }
+        };
+      }
+      return {
+        success: true,
+        data: {
+          projectId: selectedProject.projectId,
+          name: selectedProject.name
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: {
+          code: "UNKNOWN_ERROR",
+          message: error instanceof Error ? error.message : String(error),
+          recoverable: false
+        }
+      };
+    }
+  }
+}
+
+// src/services/mcp-config/handler.ts
+class McpConfigHandler {
+  async generateConfig(input) {
+    try {
+      const config = input.transport === "http" ? this.generateHttpConfig(input) : this.generateStdioConfig(input);
+      const configString = config ? JSON.stringify(config, null, 2) : "";
+      const instructions = this.getInstructionsForClient(input.client, configString, input.transport, input.projectId, input.apiKey);
+      return {
+        success: true,
+        data: {
+          config: configString,
+          instructions
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: {
+          code: "CONFIG_GENERATION_FAILED",
+          message: error instanceof Error ? error.message : String(error),
+          recoverable: false
+        }
+      };
+    }
+  }
+  generateHttpConfig(input) {
+    switch (input.client) {
+      case "cursor":
+        return this.generateCursorConfig(input.projectId, input.apiKey);
+      case "antigravity":
+        return this.generateAntigravityConfig(input.projectId, input.apiKey);
+      case "vscode":
+        return this.generateVSCodeConfig(input.projectId, input.apiKey);
+      case "claude-code":
+        return this.generateClaudeCodeConfig();
+      case "gemini-cli":
+        return this.generateGeminiCliConfig();
+      case "codex":
+        return null;
+      case "opencode":
+        return this.generateOpencodeConfig(input.apiKey);
+    }
+  }
+  generateCursorConfig(projectId, apiKey) {
+    const headers = apiKey ? { "X-Goog-Api-Key": apiKey } : {
+      Authorization: "Bearer <YOUR_ACCESS_TOKEN>",
+      "X-Goog-User-Project": projectId
+    };
+    return {
+      mcpServers: {
+        stitch: {
+          url: "https://stitch.googleapis.com/mcp",
+          headers
+        }
+      }
+    };
+  }
+  generateAntigravityConfig(projectId, apiKey) {
+    const headers = apiKey ? { "X-Goog-Api-Key": apiKey } : {
+      Authorization: "Bearer <YOUR_ACCESS_TOKEN>",
+      "X-Goog-User-Project": projectId
+    };
+    return {
+      mcpServers: {
+        stitch: {
+          serverUrl: "https://stitch.googleapis.com/mcp",
+          headers
+        }
+      }
+    };
+  }
+  generateVSCodeConfig(projectId, apiKey) {
+    if (apiKey) {
+      return {
+        servers: {
+          stitch: {
+            type: "http",
+            url: "https://stitch.googleapis.com/mcp",
+            headers: {
+              Accept: "application/json",
+              "X-Goog-Api-Key": apiKey
+            }
+          }
+        }
+      };
+    }
+    return {
+      inputs: [
+        {
+          type: "promptString",
+          id: "stitch-access-token",
+          description: "Google Cloud Access Token (run: gcloud auth print-access-token)",
+          password: true
+        }
+      ],
+      servers: {
+        stitch: {
+          type: "http",
+          url: "https://stitch.googleapis.com/mcp",
+          headers: {
+            Authorization: "Bearer ${input:stitch-access-token}",
+            "X-Goog-User-Project": projectId
+          }
+        }
+      }
+    };
+  }
+  generateClaudeCodeConfig() {
+    return null;
+  }
+  generateGeminiCliConfig() {
+    return null;
+  }
+  generateOpencodeConfig(apiKey) {
+    const headers = apiKey ? { "X-Goog-Api-Key": apiKey } : {
+      Authorization: "Bearer $STITCH_ACCESS_TOKEN",
+      "X-Goog-User-Project": "$GOOGLE_CLOUD_PROJECT"
+    };
+    return {
+      $schema: "https://opencode.ai/config.json",
+      mcp: {
+        stitch: {
+          type: "remote",
+          url: "https://stitch.googleapis.com/mcp",
+          headers
+        }
+      }
+    };
+  }
+  generateStdioConfig(input) {
+    if (input.client === "claude-code" || input.client === "gemini-cli" || input.client === "codex") {
+      return null;
+    }
+    const env = {};
+    if (!input.apiKey) {
+      env.STITCH_PROJECT_ID = input.projectId;
+    } else {
+      env.STITCH_API_KEY = input.apiKey;
+    }
+    if (input.client === "vscode") {
+      return {
+        servers: {
+          stitch: {
+            type: "stdio",
+            command: "npx",
+            args: ["@_davideast/stitch-mcp", "proxy"],
+            env
+          }
+        }
+      };
+    }
+    if (input.client === "opencode") {
+      return {
+        $schema: "https://opencode.ai/config.json",
+        mcp: {
+          stitch: {
+            type: "local",
+            command: ["npx", "@_davideast/stitch-mcp", "proxy"],
+            environment: env
+          }
+        }
+      };
+    }
+    return {
+      mcpServers: {
+        stitch: {
+          command: "npx",
+          args: ["@_davideast/stitch-mcp", "proxy"],
+          env
+        }
+      }
+    };
+  }
+  getInstructionsForClient(client, config, transport, projectId, apiKey) {
+    const baseInstructions = `
+${theme.blue("MCP Configuration Generated")}
+
+${config}
+`;
+    const transportNote = transport === "stdio" ? `
+${theme.yellow("Note:")} This uses the proxy server. Keep it running with:
+  npx @_davideast/stitch-mcp proxy
+` : "";
+    const tokenHint = transport === "http" && !apiKey ? `
+${theme.yellow("To get your access token, run:")}
+` + `  CLOUDSDK_CONFIG=~/.stitch-mcp/config ~/.stitch-mcp/google-cloud-sdk/bin/gcloud auth print-access-token
+` + `
+${theme.yellow("Important:")} Replace ${theme.blue("<YOUR_ACCESS_TOKEN>")} in the config with the token from the command above.
+` + `Access tokens expire after 1 hour. Consider using ${theme.blue("stdio")} transport for automatic refresh.
+` : "";
+    const vscodeTokenHint = transport === "http" && !apiKey ? `
+${theme.yellow("To get your access token, run:")}
+` + `  CLOUDSDK_CONFIG=~/.stitch-mcp/config ~/.stitch-mcp/google-cloud-sdk/bin/gcloud auth print-access-token
+` + `
+${theme.yellow("Important:")} When prompted, paste the token from the command above.
+` + `Access tokens expire after 1 hour. Consider using ${theme.blue("stdio")} transport for automatic refresh.
+` : "";
+    switch (client) {
+      case "antigravity":
+        if (transport === "stdio") {
+          return baseInstructions + transportNote + `
+${theme.green("Next Steps for Antigravity:")}
+` + `1. In the Agent Panel, click the three dots in the top right
+` + `2. Select "MCP Servers" → "Manage MCP Servers"
+` + `3. Select "View raw config" and add the above configuration
+` + `4. Restart Antigravity to load the configuration
+`;
+        }
+        return baseInstructions + tokenHint + `
+${theme.green("Next Steps for Antigravity:")}
+` + `1. In the Agent Panel, click the three dots in the top right
+` + `2. Select "MCP Servers" → "Manage MCP Servers"
+` + `3. Select "View raw config" and add the above configuration
+` + `4. Restart Antigravity to load the configuration
+`;
+      case "vscode":
+        if (transport === "stdio") {
+          return baseInstructions + `
+${theme.green("Next Steps for VSCode:")}
+` + `1. Open the Command Palette (Ctrl+Shift+P or Cmd+Shift+P)
+` + `2. Run "MCP: Open User Configuration" or "MCP: Open Workspace Folder Configuration"
+` + `3. Add the above configuration to the mcp.json file
+` + `4. VS Code will automatically start the proxy server when needed
+`;
+        }
+        return baseInstructions + vscodeTokenHint + `
+${theme.green("Next Steps for VSCode:")}
+` + `1. Open the Command Palette (Ctrl+Shift+P or Cmd+Shift+P)
+` + `2. Run "MCP: Open User Configuration" or "MCP: Open Workspace Folder Configuration"
+` + `3. Add the above configuration to the mcp.json file
+` + (apiKey ? "" : `4. When prompted, paste the access token from the command above
+`) + `5. Restart VS Code or run "MCP: List Servers" to start the server
+`;
+      case "cursor":
+        if (transport === "stdio") {
+          return baseInstructions + transportNote + `
+${theme.green("Next Steps for Cursor:")}
+` + `1. Create a .cursor/mcp.json file in your project root
+` + `2. Add the above configuration to the file
+` + `3. Restart Cursor to load the configuration
+`;
+        }
+        return baseInstructions + tokenHint + `
+${theme.green("Next Steps for Cursor:")}
+` + `1. Create a .cursor/mcp.json file in your project root
+` + `2. Add the above configuration to the file
+` + `3. Restart Cursor to load the configuration
+`;
+      case "claude-code":
+        if (transport === "stdio") {
+          let envHint = "";
+          if (apiKey) {
+            envHint = `${theme.blue(`  -e STITCH_API_KEY=${apiKey} \\`)}
+`;
+          } else if (projectId) {
+            envHint = `${theme.blue(`  -e STITCH_PROJECT_ID=${projectId} \\`)}
+`;
+          }
+          return transportNote + `
+${theme.green("Setup Claude Code:")}
+
+` + `Run the following command to add the Stitch MCP server:
+
+` + `${theme.blue("claude mcp add stitch \\")}
+` + envHint + `${theme.blue("  -- npx @_davideast/stitch-mcp proxy")}`;
+        } else {
+          if (apiKey) {
+            return `
+${theme.green("Setup Claude Code:")}
+
+` + `Run the following command to add the Stitch MCP server:
+
+` + `${theme.blue("claude mcp add stitch \\")}
+` + `${theme.blue("  --transport http https://stitch.googleapis.com/mcp \\")}
+` + `${theme.blue(`  --header "X-Goog-Api-Key: ${apiKey}" \\`)}
+` + `${theme.blue("  -s user")}
+
+` + `${theme.yellow("Note:")} -s user saves to $HOME/.claude.json, use -s project for ./.mcp.json
+`;
+          }
+          return tokenHint + `
+${theme.green("Setup Claude Code:")}
+
+` + `Run the following command to add the Stitch MCP server:
+
+` + `${theme.blue("claude mcp add stitch \\")}
+` + `${theme.blue("  --transport http https://stitch.googleapis.com/mcp \\")}
+` + `${theme.blue('  --header "Authorization: Bearer <YOUR_ACCESS_TOKEN>" \\')}
+` + `${theme.blue(`  --header "X-Goog-User-Project: ${projectId}" \\`)}
+` + `${theme.blue("  -s user")}
+
+` + `${theme.yellow("Note:")} -s user saves to $HOME/.claude.json, use -s project for ./.mcp.json
+`;
+        }
+      case "gemini-cli":
+        return transportNote + `
+${theme.green("Setup Gemini CLI:")}
+
+` + `Install the Stitch extension for the Gemini CLI:
+
+` + `${theme.blue("gemini extensions install https://github.com/gemini-cli-extensions/stitch")}
+`;
+      case "codex": {
+        const isHttp = transport === "http";
+        let configBlock;
+        if (isHttp) {
+          if (apiKey) {
+            configBlock = [
+              "[mcp_servers.stitch]",
+              'url = "https://stitch.googleapis.com/mcp"',
+              "",
+              "[mcp_servers.stitch.env_http_headers]",
+              `X-Goog-Api-Key = "${apiKey}"`
+            ].join(`
+`);
+          } else {
+            configBlock = [
+              "[mcp_servers.stitch]",
+              'url = "https://stitch.googleapis.com/mcp"',
+              'bearer_token_env_var = "STITCH_ACCESS_TOKEN"',
+              "",
+              "[mcp_servers.stitch.env_http_headers]",
+              'X-Goog-User-Project = "GOOGLE_CLOUD_PROJECT"'
+            ].join(`
+`);
+          }
+        } else {
+          if (apiKey) {
+            configBlock = [
+              "[mcp_servers.stitch]",
+              'command = "npx"',
+              'args = ["@_davideast/stitch-mcp", "proxy"]',
+              "",
+              "[mcp_servers.stitch.env]",
+              `STITCH_API_KEY = "${apiKey}"`
+            ].join(`
+`);
+          } else {
+            configBlock = [
+              "[mcp_servers.stitch]",
+              'command = "npx"',
+              'args = ["@_davideast/stitch-mcp", "proxy"]',
+              "",
+              "[mcp_servers.stitch.env]",
+              `STITCH_PROJECT_ID = "${projectId}"`
+            ].join(`
+`);
+          }
+        }
+        const note = isHttp && !apiKey ? `${theme.yellow("Note:")} Direct mode requires a valid access token in ${theme.blue("STITCH_ACCESS_TOKEN")} and a project id in ${theme.blue("GOOGLE_CLOUD_PROJECT")}.
+` : `${theme.yellow("Note:")} Proxy mode handles token refresh automatically.
+`;
+        return `
+${theme.green("Setup Codex CLI:")}
+
+` + `Add this to ${theme.blue("~/.codex/config.toml")}:
+
+` + `${configBlock}
+
+` + note;
+      }
+      case "opencode": {
+        const fileName = transport === "http" ? "opencode.json" : "opencode.json";
+        return baseInstructions + transportNote + `
+${theme.green("Setup OpenCode:")}
+
+` + `1. Add the above configuration to ${theme.blue(fileName)} in your project root
+` + `2. If using HTTP transport, OpenCode will automatically handle OAuth when you first use the MCP server
+` + `3. If using STDIO transport, make sure the proxy server is running with:
+` + `   ${theme.blue("npx @_davideast/stitch-mcp proxy")}
+
+` + `${theme.gray("Note:")} You can now use Stitch tools by adding "use the stitch tool" to your prompts.
+`;
+      }
+      default:
+        return baseInstructions + transportNote + `
+${theme.yellow("Add this configuration to your MCP client.")}
+`;
+    }
+  }
+}
+
+// src/ui/checklist/handler.ts
+var STATE_ICONS = {
+  PENDING: "○",
+  IN_PROGRESS: "▸",
+  COMPLETE: "✓",
+  SKIPPED: "−",
+  FAILED: "✗"
+};
+
+class ChecklistUIHandler {
+  config;
+  states = new Map;
+  lastOutputLines = 0;
+  initialize(config) {
+    this.config = config;
+    this.states.clear();
+    const initItem = (item) => {
+      this.states.set(item.id, { state: "PENDING" });
+      item.children?.forEach(initItem);
+    };
+    config.items.forEach(initItem);
+  }
+  updateItem(input) {
+    const current = this.states.get(input.itemId);
+    if (!current) {
+      return {
+        success: false,
+        error: {
+          code: "ITEM_NOT_FOUND",
+          message: `Item "${input.itemId}" not found`,
+          recoverable: false
+        }
+      };
+    }
+    const previousState = current.state;
+    this.states.set(input.itemId, {
+      state: input.state,
+      detail: input.detail,
+      reason: input.reason
+    });
+    return {
+      success: true,
+      data: {
+        itemId: input.itemId,
+        previousState,
+        newState: input.state
+      }
+    };
+  }
+  render() {
+    try {
+      const lines = [];
+      const { completed, total, percent } = this.getProgress();
+      lines.push(`\uD83E\uDDF5 ${this.config.title}`);
+      lines.push("");
+      this.config.items.forEach((item, idx) => {
+        const state = this.states.get(item.id);
+        const icon = STATE_ICONS[state.state];
+        const color = this.getStateColor(state.state);
+        let line = `  ${color(icon)}  ${idx + 1}. ${item.label}`;
+        if (state.detail) {
+          line += ` ${theme.gray("·")} ${state.detail}`;
+        }
+        lines.push(line);
+        if (state.reason) {
+          lines.push(`     └─ ${theme.gray(state.reason)}`);
+        }
+      });
+      if (this.config.showProgress) {
+        lines.push("");
+        const barWidth = 40;
+        const filled = Math.round(percent / 100 * barWidth);
+        const bar = "━".repeat(filled) + "─".repeat(barWidth - filled);
+        lines.push(`  ${bar} ${percent}%`);
+      }
+      return {
+        success: true,
+        data: {
+          output: lines.join(`
+`),
+          completedCount: completed,
+          totalCount: total,
+          percentComplete: percent
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: {
+          code: "RENDER_FAILED",
+          message: error instanceof Error ? error.message : String(error),
+          recoverable: false
+        }
+      };
+    }
+  }
+  print(options) {
+    if (options?.clearPrevious && this.lastOutputLines > 0) {
+      process.stdout.write(`\x1B[${this.lastOutputLines}A\x1B[0J`);
+    }
+    const result = this.render();
+    if (result.success) {
+      console.log(result.data.output);
+      this.lastOutputLines = result.data.output.split(`
+`).length;
+    }
+  }
+  getProgress() {
+    const total = this.states.size;
+    let completed = 0;
+    this.states.forEach((state) => {
+      if (state.state === "COMPLETE" || state.state === "SKIPPED") {
+        completed++;
+      }
+    });
+    return {
+      completed,
+      total,
+      percent: Math.round(completed / total * 100)
+    };
+  }
+  isComplete() {
+    for (const state of this.states.values()) {
+      if (state.state === "PENDING" || state.state === "IN_PROGRESS") {
+        return false;
+      }
+    }
+    return true;
+  }
+  getStateColor(state) {
+    switch (state) {
+      case "COMPLETE":
+        return theme.green;
+      case "SKIPPED":
+        return theme.gray;
+      case "FAILED":
+        return theme.red;
+      case "IN_PROGRESS":
+        return theme.yellow;
+      default:
+        return theme.gray;
+    }
+  }
+}
+
+// src/commands/init/steps/ClientSelectionStep.ts
+class ClientSelectionStep {
+  id = "mcp-client";
+  name = "Select MCP client";
+  async shouldRun(context) {
+    return true;
+  }
+  async run(context) {
+    if (context.input.client) {
+      try {
+        context.mcpClient = this.resolveMcpClient(context.input.client);
+        return {
+          success: true,
+          detail: context.mcpClient,
+          status: "SKIPPED",
+          reason: "Set via --client flag"
+        };
+      } catch (e) {
+        return {
+          success: false,
+          error: e instanceof Error ? e : new Error(String(e))
+        };
+      }
+    }
+    context.mcpClient = await context.ui.promptMcpClient();
+    return {
+      success: true,
+      detail: context.mcpClient
+    };
+  }
+  resolveMcpClient(input) {
+    const map = {
+      antigravity: "antigravity",
+      agy: "antigravity",
+      vscode: "vscode",
+      vsc: "vscode",
+      cursor: "cursor",
+      cur: "cursor",
+      "claude-code": "claude-code",
+      cc: "claude-code",
+      "gemini-cli": "gemini-cli",
+      gcli: "gemini-cli",
+      codex: "codex",
+      cdx: "codex",
+      opencode: "opencode",
+      opc: "opencode"
+    };
+    const normalized = input.trim().toLowerCase();
+    const client = map[normalized];
+    if (!client) {
+      throw new Error(`Invalid client '${input}'. Supported: antigravity (agy), vscode (vsc), cursor (cur), claude-code (cc), gemini-cli (gcli), codex (cdx), opencode (opc)`);
+    }
+    return client;
+  }
+}
+
+// src/commands/init/steps/AuthModeStep.ts
+import fs from "node:fs";
+import path from "node:path";
+
+class AuthModeStep {
+  id = "authentication-mode";
+  name = "Select Authentication Mode";
+  async shouldRun(context) {
+    return true;
+  }
+  async run(context) {
+    const authMode = await context.ui.promptAuthMode();
+    context.authMode = authMode;
+    if (authMode === "apiKey") {
+      const storage = await context.ui.promptApiKeyStorage();
+      if (storage === "config") {
+        context.apiKey = await context.ui.promptApiKey();
+      } else if (storage === "skip") {
+        context.apiKey = "YOUR-API-KEY";
+      } else if (storage === ".env") {
+        const inputKey = await context.ui.promptApiKey();
+        context.apiKey = "YOUR-API-KEY";
+        const envPath = path.join(process.cwd(), ".env");
+        const envContent = `
+STITCH_API_KEY=${inputKey}
+`;
+        try {
+          await fs.promises.writeFile(envPath, envContent, { flag: "a", mode: 384 });
+          const gitignorePath = path.join(process.cwd(), ".gitignore");
+          try {
+            const gitignoreContent = await fs.promises.readFile(gitignorePath, "utf8");
+            if (!gitignoreContent.includes(".env")) {
+              await fs.promises.appendFile(gitignorePath, `
+.env
+`);
+            }
+          } catch (err) {
+            if (err.code === "ENOENT") {
+              await fs.promises.writeFile(gitignorePath, `.env
+`);
+            } else {
+              throw err;
+            }
+          }
+        } catch (e) {
+          context.ui.warn(`Warning: Failed to update .env or .gitignore: ${e instanceof Error ? e.message : String(e)}`);
+        }
+      }
+      return {
+        success: true,
+        detail: "API Key",
+        status: "COMPLETE"
+      };
+    }
+    return {
+      success: true,
+      detail: "OAuth",
+      status: "COMPLETE"
+    };
+  }
+}
+
+// src/commands/init/steps/GcloudInstallStep.ts
+class GcloudInstallStep {
+  id = "gcloud-cli";
+  name = "Install Google Cloud CLI";
+  async shouldRun(context) {
+    return context.authMode !== "apiKey";
+  }
+  async run(context) {
+    if (context.authMode === "apiKey") {
+      return { success: true, status: "SKIPPED", reason: "Not required for API Key" };
+    }
+    const gcloudResult = await context.gcloudService.ensureInstalled({
+      minVersion: "400.0.0",
+      forceLocal: context.input.local
+    });
+    if (!gcloudResult.success) {
+      return {
+        success: false,
+        error: new Error(gcloudResult.error.message),
+        detail: gcloudResult.error.message
+      };
+    }
+    return {
+      success: true,
+      detail: `v${gcloudResult.data.version} (${gcloudResult.data.location})`
+    };
+  }
+}
+
+// src/platform/environment.ts
+import fs2 from "node:fs";
+function detectWSL() {
+  try {
+    const procVersion = fs2.readFileSync("/proc/version", "utf8").toLowerCase();
+    return procVersion.includes("microsoft") || procVersion.includes("wsl");
+  } catch {
+    return false;
+  }
+}
+function detectSSH() {
+  return Boolean(process.env.SSH_CLIENT || process.env.SSH_TTY || process.env.SSH_CONNECTION);
+}
+function detectDocker() {
+  try {
+    return fs2.existsSync("/.dockerenv");
+  } catch {
+    return false;
+  }
+}
+function detectCloudShell() {
+  return Boolean(process.env.CLOUD_SHELL);
+}
+function detectDisplay() {
+  return Boolean(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
+}
+function detectEnvironment() {
+  const isWSL = detectWSL();
+  const isSSH = detectSSH();
+  const isDocker = detectDocker();
+  const isCloudShell = detectCloudShell();
+  const hasDisplay = detectDisplay();
+  let needsNoBrowser = false;
+  let reason;
+  if (isWSL) {
+    needsNoBrowser = true;
+    reason = "WSL detected - browser redirect to localhost may not work";
+  } else if (isSSH && !hasDisplay) {
+    needsNoBrowser = true;
+    reason = "SSH session without display forwarding";
+  } else if (isDocker) {
+    needsNoBrowser = true;
+    reason = "Docker container detected";
+  } else if (isCloudShell) {
+    needsNoBrowser = true;
+    reason = "Cloud Shell detected";
+  } else if (!hasDisplay) {
+    needsNoBrowser = true;
+    reason = "No display detected (headless environment)";
+  }
+  return {
+    isWSL,
+    isSSH,
+    isDocker,
+    isCloudShell,
+    hasDisplay,
+    needsNoBrowser,
+    reason
+  };
+}
+
+// src/commands/init/steps/AuthStep.ts
+import path2 from "node:path";
+class AuthStep {
+  id = "authentication";
+  name = "Authenticate with Google";
+  async shouldRun(context) {
+    return context.authMode !== "apiKey";
+  }
+  async run(context) {
+    if (context.authMode === "apiKey") {
+      return { success: true, status: "SKIPPED", reason: "Using API Key" };
+    }
+    const env = detectEnvironment();
+    if (env.needsNoBrowser && env.reason) {
+      context.ui.warn(`
+  ⚠ ${env.reason}`);
+      context.ui.log(`  If browser auth fails, copy the URL from terminal and open manually.
+`);
+    }
+    const existingAccount = await context.gcloudService.getActiveAccount();
+    const hasADC = await context.gcloudService.hasADC();
+    if (existingAccount && hasADC) {
+      context.authAccount = existingAccount;
+      return {
+        success: true,
+        detail: existingAccount,
+        status: "SKIPPED",
+        reason: "Already authenticated"
+      };
+    }
+    const gcloudInfo = await context.gcloudService.ensureInstalled({
+      minVersion: "400.0.0",
+      forceLocal: context.input.local
+    });
+    if (!gcloudInfo.success)
+      return { success: false, error: new Error("Gcloud not found") };
+    const isBundled = gcloudInfo.data.location === "bundled";
+    const gcloudBinDir = path2.dirname(gcloudInfo.data.path);
+    let configPrefix = "";
+    if (isBundled) {
+      const configPath = path2.dirname(gcloudBinDir) + "/../config";
+      configPrefix = `CLOUDSDK_CONFIG="${configPath}"`;
+      context.ui.warn(`
+Configure gcloud PATH
+`);
+      context.ui.log(`  Open a NEW terminal tab/window and run this command:
+`);
+      context.ui.log(theme.cyan(`  export PATH="${gcloudBinDir}:$PATH"
+`));
+      try {
+        const { default: clipboard } = await import("./chunk-kad4d9sf.js");
+        await clipboard.write(`export PATH="${gcloudBinDir}:$PATH"`);
+        context.ui.log(theme.gray("  (copied to clipboard)"));
+      } catch {}
+      await context.ui.promptConfirm("Press Enter when complete", true);
+    }
+    if (!existingAccount) {
+      context.ui.warn(`
+Authenticate with Google Cloud
+`);
+      context.ui.log(theme.cyan(`  ${configPrefix} gcloud auth login
+`));
+      await context.ui.promptConfirm("Press Enter when complete", true);
+    }
+    if (!hasADC) {
+      context.ui.warn(`
+Authorize Application Default Credentials
+`);
+      context.ui.log(theme.cyan(`  ${configPrefix} gcloud auth application-default login
+`));
+      await context.ui.promptConfirm("Press Enter when complete", true);
+    }
+    const verifyAccount = await context.gcloudService.getActiveAccount();
+    if (!verifyAccount) {
+      return {
+        success: false,
+        error: new Error("No authenticated account found after setup"),
+        detail: "No account found",
+        errorCode: "AUTH_FAILED"
+      };
+    }
+    context.authAccount = verifyAccount;
+    return {
+      success: true,
+      detail: verifyAccount
+    };
+  }
+}
+
+// src/commands/init/steps/TransportStep.ts
+class TransportStep {
+  id = "connection-method";
+  name = "Choose connection method";
+  async shouldRun(context) {
+    return true;
+  }
+  async run(context) {
+    if (context.input.transport) {
+      context.transport = this.resolveTransport(context.input.transport);
+      const transportLabel2 = context.transport === "http" ? "Direct" : "Proxy";
+      return {
+        success: true,
+        detail: transportLabel2,
+        status: "SKIPPED",
+        reason: "Set via --transport flag"
+      };
+    }
+    context.transport = await context.ui.promptTransportType(context.authMode);
+    const transportLabel = context.transport === "http" ? "Direct" : "Proxy";
+    return {
+      success: true,
+      detail: transportLabel
+    };
+  }
+  resolveTransport(input) {
+    const normalized = input.trim().toLowerCase();
+    if (normalized === "http")
+      return "http";
+    if (normalized === "stdio")
+      return "stdio";
+    throw new Error(`Invalid transport '${input}'. Supported: http, stdio`);
+  }
+}
+
+// src/commands/init/steps/ProjectSelectStep.ts
+class ProjectSelectStep {
+  id = "project-selection";
+  name = "Select Google Cloud project";
+  async shouldRun(context) {
+    return context.authMode !== "apiKey";
+  }
+  async run(context) {
+    if (context.authMode === "apiKey") {
+      return { success: true, status: "SKIPPED", reason: "Not required for API Key" };
+    }
+    let projectResult = null;
+    const activeProjectId = await context.gcloudService.getProjectId();
+    if (activeProjectId) {
+      const detailsResult = await context.projectService.getProjectDetails({ projectId: activeProjectId });
+      if (detailsResult.success) {
+        const useActive = context.input.defaults || context.input.autoVerify ? true : await context.ui.promptConfirm(`Use active project: ${detailsResult.data.name} (${detailsResult.data.projectId})?`, true);
+        if (useActive) {
+          projectResult = detailsResult;
+        }
+      }
+    }
+    if (!projectResult) {
+      projectResult = await context.projectService.selectProject({
+        allowSearch: true,
+        limit: 5
+      });
+    }
+    if (!projectResult.success) {
+      const error = projectResult.error || { message: "Unknown error" };
+      return { success: false, error: new Error(error.message) };
+    }
+    const setProjectResult = await context.gcloudService.setProject({
+      projectId: projectResult.data.projectId
+    });
+    if (!setProjectResult.success) {
+      const error = setProjectResult.error || { message: "Unknown error" };
+      return { success: false, error: new Error(error.message) };
+    }
+    context.projectId = projectResult.data.projectId;
+    return {
+      success: true,
+      detail: context.projectId
+    };
+  }
+}
+
+// src/commands/init/steps/IamApiStep.ts
+class IamApiStep {
+  id = "iam-and-api";
+  name = "Configure IAM & enable API";
+  async shouldRun(context) {
+    return context.authMode !== "apiKey";
+  }
+  async run(context) {
+    if (context.authMode === "apiKey") {
+      return { success: true, status: "SKIPPED", reason: "Not required for API Key" };
+    }
+    if (!context.projectId || !context.authAccount) {
+      return { success: false, error: new Error("Project ID or Auth Account missing") };
+    }
+    const hasIAMRole = await context.stitchService.checkIAMRole({
+      projectId: context.projectId,
+      userEmail: context.authAccount
+    });
+    if (!hasIAMRole) {
+      const shouldConfigureIam = context.input.autoVerify || await context.ui.promptConfirm("Add the required IAM role to your account?", true);
+      if (shouldConfigureIam) {
+        await context.stitchService.configureIAM({
+          projectId: context.projectId,
+          userEmail: context.authAccount
+        });
+      }
+    }
+    await context.gcloudService.installBetaComponents();
+    const isApiEnabled = await context.stitchService.checkAPIEnabled({
+      projectId: context.projectId
+    });
+    if (!isApiEnabled) {
+      await context.stitchService.enableAPI({
+        projectId: context.projectId
+      });
+    }
+    context.accessToken = await context.gcloudService.getAccessToken() || undefined;
+    if (!context.accessToken) {
+      return { success: false, error: new Error("Could not obtain access token") };
+    }
+    return { success: true, detail: "Ready" };
+  }
+}
+
+// src/commands/init/steps/ConfigStep.ts
+import fs3 from "node:fs";
+import os from "node:os";
+import path3 from "node:path";
+
+class ConfigStep {
+  id = "mcp-config";
+  name = "Generate MCP configuration";
+  async shouldRun(context) {
+    return true;
+  }
+  async run(context) {
+    if (context.mcpClient === "gemini-cli") {
+      await this.setupGeminiExtension(context);
+    }
+    const configResult = await context.mcpConfigService.generateConfig({
+      client: context.mcpClient,
+      projectId: context.projectId || "ignored-project-id",
+      accessToken: context.accessToken,
+      transport: context.transport,
+      authMode: context.authMode,
+      apiKey: context.apiKey
+    });
+    if (!configResult.success) {
+      const error = configResult.error || { message: "Unknown error" };
+      return { success: false, error: new Error(error.message) };
+    }
+    context.instructions = configResult.data.instructions;
+    context.finalConfig = configResult.data.config;
+    return { success: true, detail: "Generated" };
+  }
+  async setupGeminiExtension(context) {
+    const spinner = createSpinner();
+    const extensionPath = path3.join(os.homedir(), ".gemini", "extensions", "Stitch", "gemini-extension.json");
+    let isInstalled = false;
+    try {
+      await fs3.promises.access(extensionPath);
+      isInstalled = true;
+    } catch {
+      isInstalled = false;
+    }
+    if (isInstalled) {
+      spinner.succeed("Stitch extension is already installed");
+    } else {
+      context.ui.log(theme.gray("  > gemini extensions install https://github.com/gemini-cli-extensions/stitch"));
+      const shouldInstall = await context.ui.promptConfirm("Run this command?", true);
+      if (shouldInstall) {
+        spinner.start("Installing Stitch extension...");
+        const installResult = await execCommand(["gemini", "extensions", "install", "https://github.com/gemini-cli-extensions/stitch"]);
+        if (!installResult.success) {
+          spinner.fail("Failed to install Stitch extension");
+          context.ui.log(theme.red(`  Error: ${installResult.stderr || installResult.error}`));
+          context.ui.log(theme.gray("  Attempting to configure existing extension..."));
+        } else {
+          spinner.succeed("Extension installed");
+        }
+      }
+    }
+    spinner.start("Configuring extension...");
+    try {
+      await fs3.promises.access(extensionPath);
+    } catch {
+      spinner.fail("Extension configuration file not found");
+      context.ui.log(theme.gray(`  Expected path: ${extensionPath}`));
+      return;
+    }
+    try {
+      const content = await fs3.promises.readFile(extensionPath, "utf8");
+      const config = JSON.parse(content);
+      if (!config.mcpServers?.stitch) {
+        spinner.fail("Invalid extension configuration format detected");
+        return;
+      }
+      if (context.transport === "stdio") {
+        const env = {
+          PATH: process.env.PATH || ""
+        };
+        if (context.apiKey) {
+          env.STITCH_API_KEY = context.apiKey;
+        } else {
+          env.STITCH_PROJECT_ID = context.projectId;
+        }
+        config.mcpServers.stitch = {
+          command: "npx",
+          args: ["@_davideast/stitch-mcp", "proxy"],
+          env
+        };
+        await fs3.promises.writeFile(extensionPath, JSON.stringify(config, null, 4));
+        const successMsg = context.apiKey ? "Stitch extension configured for STDIO with API Key" : `Stitch extension configured for STDIO: Project ID set to ${theme.blue(context.projectId)}`;
+        spinner.succeed(successMsg);
+      } else {
+        const existingHeaders = config.mcpServers.stitch.headers || {};
+        if (context.apiKey) {
+          config.mcpServers.stitch = {
+            url: "https://stitch.googleapis.com/mcp",
+            headers: {
+              ...existingHeaders,
+              "X-Goog-Api-Key": context.apiKey
+            }
+          };
+          delete config.mcpServers.stitch.headers["Authorization"];
+          delete config.mcpServers.stitch.headers["X-Goog-User-Project"];
+          await fs3.promises.writeFile(extensionPath, JSON.stringify(config, null, 4));
+          spinner.succeed(`Stitch extension configured for HTTP with API Key`);
+        } else {
+          config.mcpServers.stitch = {
+            url: "https://stitch.googleapis.com/mcp",
+            headers: {
+              Authorization: "Bearer $STITCH_ACCESS_TOKEN",
+              ...existingHeaders,
+              "X-Goog-User-Project": context.projectId
+            }
+          };
+          await fs3.promises.writeFile(extensionPath, JSON.stringify(config, null, 4));
+          spinner.succeed(`Stitch extension configured for HTTP: Project ID set to ${theme.blue(context.projectId)}`);
+        }
+      }
+      context.ui.log(theme.gray(`  File: ${extensionPath}`));
+    } catch (e) {
+      spinner.fail("Failed to update extension configuration");
+      context.ui.log(theme.red(`  Error: ${e instanceof Error ? e.message : String(e)}`));
+    }
+  }
+}
+
+// src/commands/init/steps/TestConnectionStep.ts
+class TestConnectionStep {
+  id = "connection-test";
+  name = "Test connection";
+  async shouldRun(context) {
+    return context.authMode === "oauth";
+  }
+  async run(context) {
+    if (context.authMode !== "oauth") {
+      return { success: true, status: "SKIPPED", reason: "Not supported for API Key yet" };
+    }
+    if (!context.accessToken) {
+      return { success: false, status: "SKIPPED", reason: "No access token" };
+    }
+    const testResult = await context.stitchService.testConnection({
+      projectId: context.projectId,
+      accessToken: context.accessToken
+    });
+    if (!testResult.success) {
+      const error = testResult.error || { message: "Unknown error", suggestion: "" };
+      context.ui.log(theme.red(`
+  ${icons.error} Error: ${error.message}`));
+      context.ui.warn(`  ${error.suggestion}`);
+      return {
+        success: false,
+        detail: error.message,
+        error: new Error(error.message)
+      };
+    }
+    return { success: true, detail: `${testResult.data.statusCode} OK` };
+  }
+}
+
+// src/commands/init/handler.ts
+class InitHandler {
+  gcloudService;
+  mcpConfigService;
+  projectService;
+  stitchService;
+  ui;
+  checklist;
+  steps;
+  constructor(gcloudService, mcpConfigService, projectService, stitchService, ui) {
+    this.gcloudService = gcloudService || new GcloudHandler;
+    this.mcpConfigService = mcpConfigService || new McpConfigHandler;
+    this.projectService = projectService || new ProjectHandler(this.gcloudService);
+    this.stitchService = stitchService || new StitchHandler;
+    this.checklist = new ChecklistUIHandler;
+    this.ui = ui || new ConsoleUI;
+    this.steps = [
+      new ClientSelectionStep,
+      new AuthModeStep,
+      new GcloudInstallStep,
+      new AuthStep,
+      new TransportStep,
+      new ProjectSelectStep,
+      new IamApiStep,
+      new ConfigStep,
+      new TestConnectionStep
+    ];
+  }
+  async execute(input) {
+    this.checklist.initialize({
+      title: "Stitch MCP Setup",
+      items: this.steps.map((s) => ({ id: s.id, label: s.name })),
+      showProgress: true,
+      animationDelayMs: 100
+    });
+    if (!input.json)
+      console.log(`
+${theme.blue("\uD83E\uDDF5 Stitch MCP Setup")}
+`);
+    const context = {
+      input,
+      ui: this.ui,
+      gcloudService: this.gcloudService,
+      mcpConfigService: this.mcpConfigService,
+      projectService: this.projectService,
+      stitchService: this.stitchService
+    };
+    try {
+      const { stoppedAt } = await runSteps(this.steps, context, {
+        onBeforeStep: (step) => {
+          if (!input.json)
+            this.updateStep(step.id, "IN_PROGRESS");
+        },
+        onAfterStep: (step, result2) => {
+          if (!result2.success) {
+            const message = result2.error?.message || result2.detail || "Failed";
+            if (!input.json)
+              this.updateStep(step.id, "FAILED", message);
+            return true;
+          }
+          const status = result2.status || "COMPLETE";
+          if (!input.json)
+            this.updateStep(step.id, status, result2.detail, result2.reason);
+          return false;
+        },
+        onSkippedStep: (step) => {
+          if (!input.json)
+            this.updateStep(step.id, "SKIPPED", "Not required");
+        }
+      });
+      if (stoppedAt) {
+        const message = stoppedAt.result.error?.message || stoppedAt.result.detail || "Failed";
+        return {
+          success: false,
+          error: {
+            code: stoppedAt.result.errorCode || "UNKNOWN_ERROR",
+            message,
+            recoverable: true
+          }
+        };
+      }
+      const result = {
+        success: true,
+        data: {
+          projectId: context.projectId || "ignored",
+          mcpConfig: context.finalConfig || "",
+          instructions: context.instructions || ""
+        }
+      };
+      if (input.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return result;
+      }
+      const { percent } = this.checklist.getProgress();
+      const barWidth = 40;
+      const filled = Math.round(percent / 100 * barWidth);
+      const bar = "━".repeat(filled) + "─".repeat(barWidth - filled);
+      console.log(`
+  ${bar} ${percent}%`);
+      if (this.checklist.isComplete()) {
+        console.log(`
+${theme.green("\uD83C\uDF89 Setup complete!")}
+`);
+      }
+      if (context.instructions) {
+        console.log(context.instructions);
+      }
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        error: {
+          code: "UNKNOWN_ERROR",
+          message: error instanceof Error ? error.message : String(error),
+          recoverable: false
+        }
+      };
+    }
+  }
+  updateStep(stepId, state, detail, reason) {
+    this.checklist.updateItem({ itemId: stepId, state, detail, reason });
+    if (state !== "IN_PROGRESS") {
+      const step = this.steps.find((s) => s.id === stepId);
+      this.printStepResult(stepId, step?.name || stepId, state, detail, reason);
+    }
+  }
+  printStepResult(stepId, label, state, detail, reason) {
+    const stepIndex = this.steps.findIndex((s) => s.id === stepId);
+    const stepNum = stepIndex + 1;
+    const icons2 = {
+      PENDING: "○",
+      IN_PROGRESS: "▸",
+      COMPLETE: "✓",
+      SKIPPED: "−",
+      FAILED: "✗"
+    };
+    const icon = icons2[state];
+    const colors = {
+      PENDING: theme.gray,
+      IN_PROGRESS: theme.yellow,
+      COMPLETE: theme.green,
+      SKIPPED: theme.gray,
+      FAILED: theme.red
+    };
+    const color = colors[state];
+    let line = `  ${color(icon)}  ${stepNum}. ${label}`;
+    if (detail) {
+      line += ` ${theme.gray("·")} ${detail}`;
+    }
+    console.log(line);
+    if (reason) {
+      console.log(`     └─ ${theme.gray(reason)}`);
+    }
+  }
+}
+
+export { ProjectHandler, McpConfigHandler, InitHandler };
+
+//# debugId=D9F76D12D96878B564756E2164756E21