google-stitch-mcp 0.3.2

package/dist/services/gcloud/spec.d.ts

@@ -0,0 +1,408 @@
+import { z } from 'zod';
+export declare const EnsureGcloudInputSchema: z.ZodObject<{
+    minVersion: z.ZodDefault<z.ZodString>;
+    forceLocal: z.ZodDefault<z.ZodBoolean>;
+    useSystemGcloud: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    minVersion: string;
+    forceLocal: boolean;
+    useSystemGcloud?: boolean | undefined;
+}, {
+    minVersion?: string | undefined;
+    forceLocal?: boolean | undefined;
+    useSystemGcloud?: boolean | undefined;
+}>;
+export type EnsureGcloudInput = z.infer<typeof EnsureGcloudInputSchema>;
+export declare const AuthenticateInputSchema: z.ZodObject<{
+    skipIfActive: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    skipIfActive: boolean;
+}, {
+    skipIfActive?: boolean | undefined;
+}>;
+export type AuthenticateInput = z.infer<typeof AuthenticateInputSchema>;
+export declare const ListProjectsInputSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodNumber>;
+    filter: z.ZodOptional<z.ZodString>;
+    sortBy: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    filter?: string | undefined;
+    limit?: number | undefined;
+    sortBy?: string | undefined;
+}, {
+    filter?: string | undefined;
+    limit?: number | undefined;
+    sortBy?: string | undefined;
+}>;
+export type ListProjectsInput = z.infer<typeof ListProjectsInputSchema>;
+export declare const SetProjectInputSchema: z.ZodObject<{
+    projectId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    projectId: string;
+}, {
+    projectId: string;
+}>;
+export type SetProjectInput = z.infer<typeof SetProjectInputSchema>;
+export declare const GcloudErrorCode: z.ZodEnum<["DOWNLOAD_FAILED", "EXTRACTION_FAILED", "VERSION_CHECK_FAILED", "INVALID_VERSION", "AUTH_FAILED", "ADC_FAILED", "PROJECT_LIST_FAILED", "PROJECT_SET_FAILED", "COMMAND_NOT_FOUND", "UNKNOWN_ERROR"]>;
+export type GcloudErrorCodeType = z.infer<typeof GcloudErrorCode>;
+export declare const GcloudInstallDataSchema: z.ZodObject<{
+    version: z.ZodString;
+    location: z.ZodEnum<["system", "bundled"]>;
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    version: string;
+    location: "system" | "bundled";
+}, {
+    path: string;
+    version: string;
+    location: "system" | "bundled";
+}>;
+export declare const GcloudSuccess: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        version: z.ZodString;
+        location: z.ZodEnum<["system", "bundled"]>;
+        path: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        version: string;
+        location: "system" | "bundled";
+    }, {
+        path: string;
+        version: string;
+        location: "system" | "bundled";
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: true;
+    data: {
+        path: string;
+        version: string;
+        location: "system" | "bundled";
+    };
+}, {
+    success: true;
+    data: {
+        path: string;
+        version: string;
+        location: "system" | "bundled";
+    };
+}>;
+export declare const GcloudFailure: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["DOWNLOAD_FAILED", "EXTRACTION_FAILED", "VERSION_CHECK_FAILED", "INVALID_VERSION", "AUTH_FAILED", "ADC_FAILED", "PROJECT_LIST_FAILED", "PROJECT_SET_FAILED", "COMMAND_NOT_FOUND", "UNKNOWN_ERROR"]>;
+        message: z.ZodString;
+        suggestion: z.ZodOptional<z.ZodString>;
+        recoverable: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        code: "UNKNOWN_ERROR" | "DOWNLOAD_FAILED" | "EXTRACTION_FAILED" | "VERSION_CHECK_FAILED" | "INVALID_VERSION" | "AUTH_FAILED" | "ADC_FAILED" | "PROJECT_LIST_FAILED" | "PROJECT_SET_FAILED" | "COMMAND_NOT_FOUND";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    }, {
+        code: "UNKNOWN_ERROR" | "DOWNLOAD_FAILED" | "EXTRACTION_FAILED" | "VERSION_CHECK_FAILED" | "INVALID_VERSION" | "AUTH_FAILED" | "ADC_FAILED" | "PROJECT_LIST_FAILED" | "PROJECT_SET_FAILED" | "COMMAND_NOT_FOUND";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "DOWNLOAD_FAILED" | "EXTRACTION_FAILED" | "VERSION_CHECK_FAILED" | "INVALID_VERSION" | "AUTH_FAILED" | "ADC_FAILED" | "PROJECT_LIST_FAILED" | "PROJECT_SET_FAILED" | "COMMAND_NOT_FOUND";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    };
+}, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "DOWNLOAD_FAILED" | "EXTRACTION_FAILED" | "VERSION_CHECK_FAILED" | "INVALID_VERSION" | "AUTH_FAILED" | "ADC_FAILED" | "PROJECT_LIST_FAILED" | "PROJECT_SET_FAILED" | "COMMAND_NOT_FOUND";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    };
+}>;
+export type GcloudResult = z.infer<typeof GcloudSuccess> | z.infer<typeof GcloudFailure>;
+export declare const AuthDataSchema: z.ZodObject<{
+    account: z.ZodString;
+    type: z.ZodEnum<["user", "adc"]>;
+}, "strip", z.ZodTypeAny, {
+    type: "user" | "adc";
+    account: string;
+}, {
+    type: "user" | "adc";
+    account: string;
+}>;
+export declare const AuthSuccess: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        account: z.ZodString;
+        type: z.ZodEnum<["user", "adc"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "user" | "adc";
+        account: string;
+    }, {
+        type: "user" | "adc";
+        account: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: true;
+    data: {
+        type: "user" | "adc";
+        account: string;
+    };
+}, {
+    success: true;
+    data: {
+        type: "user" | "adc";
+        account: string;
+    };
+}>;
+export declare const AuthFailure: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["DOWNLOAD_FAILED", "EXTRACTION_FAILED", "VERSION_CHECK_FAILED", "INVALID_VERSION", "AUTH_FAILED", "ADC_FAILED", "PROJECT_LIST_FAILED", "PROJECT_SET_FAILED", "COMMAND_NOT_FOUND", "UNKNOWN_ERROR"]>;
+        message: z.ZodString;
+        suggestion: z.ZodOptional<z.ZodString>;
+        recoverable: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        code: "UNKNOWN_ERROR" | "DOWNLOAD_FAILED" | "EXTRACTION_FAILED" | "VERSION_CHECK_FAILED" | "INVALID_VERSION" | "AUTH_FAILED" | "ADC_FAILED" | "PROJECT_LIST_FAILED" | "PROJECT_SET_FAILED" | "COMMAND_NOT_FOUND";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    }, {
+        code: "UNKNOWN_ERROR" | "DOWNLOAD_FAILED" | "EXTRACTION_FAILED" | "VERSION_CHECK_FAILED" | "INVALID_VERSION" | "AUTH_FAILED" | "ADC_FAILED" | "PROJECT_LIST_FAILED" | "PROJECT_SET_FAILED" | "COMMAND_NOT_FOUND";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "DOWNLOAD_FAILED" | "EXTRACTION_FAILED" | "VERSION_CHECK_FAILED" | "INVALID_VERSION" | "AUTH_FAILED" | "ADC_FAILED" | "PROJECT_LIST_FAILED" | "PROJECT_SET_FAILED" | "COMMAND_NOT_FOUND";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    };
+}, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "DOWNLOAD_FAILED" | "EXTRACTION_FAILED" | "VERSION_CHECK_FAILED" | "INVALID_VERSION" | "AUTH_FAILED" | "ADC_FAILED" | "PROJECT_LIST_FAILED" | "PROJECT_SET_FAILED" | "COMMAND_NOT_FOUND";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    };
+}>;
+export type AuthResult = z.infer<typeof AuthSuccess> | z.infer<typeof AuthFailure>;
+export declare const ProjectSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    name: z.ZodString;
+    projectNumber: z.ZodOptional<z.ZodString>;
+    createTime: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    projectId: string;
+    projectNumber?: string | undefined;
+    createTime?: string | undefined;
+}, {
+    name: string;
+    projectId: string;
+    projectNumber?: string | undefined;
+    createTime?: string | undefined;
+}>;
+export declare const ProjectListSuccess: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        projects: z.ZodArray<z.ZodObject<{
+            projectId: z.ZodString;
+            name: z.ZodString;
+            projectNumber: z.ZodOptional<z.ZodString>;
+            createTime: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            projectId: string;
+            projectNumber?: string | undefined;
+            createTime?: string | undefined;
+        }, {
+            name: string;
+            projectId: string;
+            projectNumber?: string | undefined;
+            createTime?: string | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        projects: {
+            name: string;
+            projectId: string;
+            projectNumber?: string | undefined;
+            createTime?: string | undefined;
+        }[];
+    }, {
+        projects: {
+            name: string;
+            projectId: string;
+            projectNumber?: string | undefined;
+            createTime?: string | undefined;
+        }[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: true;
+    data: {
+        projects: {
+            name: string;
+            projectId: string;
+            projectNumber?: string | undefined;
+            createTime?: string | undefined;
+        }[];
+    };
+}, {
+    success: true;
+    data: {
+        projects: {
+            name: string;
+            projectId: string;
+            projectNumber?: string | undefined;
+            createTime?: string | undefined;
+        }[];
+    };
+}>;
+export declare const ProjectListFailure: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["DOWNLOAD_FAILED", "EXTRACTION_FAILED", "VERSION_CHECK_FAILED", "INVALID_VERSION", "AUTH_FAILED", "ADC_FAILED", "PROJECT_LIST_FAILED", "PROJECT_SET_FAILED", "COMMAND_NOT_FOUND", "UNKNOWN_ERROR"]>;
+        message: z.ZodString;
+        suggestion: z.ZodOptional<z.ZodString>;
+        recoverable: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        code: "UNKNOWN_ERROR" | "DOWNLOAD_FAILED" | "EXTRACTION_FAILED" | "VERSION_CHECK_FAILED" | "INVALID_VERSION" | "AUTH_FAILED" | "ADC_FAILED" | "PROJECT_LIST_FAILED" | "PROJECT_SET_FAILED" | "COMMAND_NOT_FOUND";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    }, {
+        code: "UNKNOWN_ERROR" | "DOWNLOAD_FAILED" | "EXTRACTION_FAILED" | "VERSION_CHECK_FAILED" | "INVALID_VERSION" | "AUTH_FAILED" | "ADC_FAILED" | "PROJECT_LIST_FAILED" | "PROJECT_SET_FAILED" | "COMMAND_NOT_FOUND";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "DOWNLOAD_FAILED" | "EXTRACTION_FAILED" | "VERSION_CHECK_FAILED" | "INVALID_VERSION" | "AUTH_FAILED" | "ADC_FAILED" | "PROJECT_LIST_FAILED" | "PROJECT_SET_FAILED" | "COMMAND_NOT_FOUND";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    };
+}, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "DOWNLOAD_FAILED" | "EXTRACTION_FAILED" | "VERSION_CHECK_FAILED" | "INVALID_VERSION" | "AUTH_FAILED" | "ADC_FAILED" | "PROJECT_LIST_FAILED" | "PROJECT_SET_FAILED" | "COMMAND_NOT_FOUND";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    };
+}>;
+export type ProjectListResult = z.infer<typeof ProjectListSuccess> | z.infer<typeof ProjectListFailure>;
+export declare const ProjectSetSuccess: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        projectId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        projectId: string;
+    }, {
+        projectId: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: true;
+    data: {
+        projectId: string;
+    };
+}, {
+    success: true;
+    data: {
+        projectId: string;
+    };
+}>;
+export declare const ProjectSetFailure: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["DOWNLOAD_FAILED", "EXTRACTION_FAILED", "VERSION_CHECK_FAILED", "INVALID_VERSION", "AUTH_FAILED", "ADC_FAILED", "PROJECT_LIST_FAILED", "PROJECT_SET_FAILED", "COMMAND_NOT_FOUND", "UNKNOWN_ERROR"]>;
+        message: z.ZodString;
+        suggestion: z.ZodOptional<z.ZodString>;
+        recoverable: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        code: "UNKNOWN_ERROR" | "DOWNLOAD_FAILED" | "EXTRACTION_FAILED" | "VERSION_CHECK_FAILED" | "INVALID_VERSION" | "AUTH_FAILED" | "ADC_FAILED" | "PROJECT_LIST_FAILED" | "PROJECT_SET_FAILED" | "COMMAND_NOT_FOUND";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    }, {
+        code: "UNKNOWN_ERROR" | "DOWNLOAD_FAILED" | "EXTRACTION_FAILED" | "VERSION_CHECK_FAILED" | "INVALID_VERSION" | "AUTH_FAILED" | "ADC_FAILED" | "PROJECT_LIST_FAILED" | "PROJECT_SET_FAILED" | "COMMAND_NOT_FOUND";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "DOWNLOAD_FAILED" | "EXTRACTION_FAILED" | "VERSION_CHECK_FAILED" | "INVALID_VERSION" | "AUTH_FAILED" | "ADC_FAILED" | "PROJECT_LIST_FAILED" | "PROJECT_SET_FAILED" | "COMMAND_NOT_FOUND";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    };
+}, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "DOWNLOAD_FAILED" | "EXTRACTION_FAILED" | "VERSION_CHECK_FAILED" | "INVALID_VERSION" | "AUTH_FAILED" | "ADC_FAILED" | "PROJECT_LIST_FAILED" | "PROJECT_SET_FAILED" | "COMMAND_NOT_FOUND";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    };
+}>;
+export type ProjectSetResult = z.infer<typeof ProjectSetSuccess> | z.infer<typeof ProjectSetFailure>;
+export interface GcloudService {
+    /**
+     * Ensure gcloud is installed and meets minimum version requirements
+     */
+    ensureInstalled(input: EnsureGcloudInput): Promise<GcloudResult>;
+    /**
+     * Authenticate user with gcloud
+     */
+    authenticate(input: AuthenticateInput): Promise<AuthResult>;
+    /**
+     * Authenticate application default credentials
+     */
+    authenticateADC(input: AuthenticateInput): Promise<AuthResult>;
+    /**
+     * List user's projects
+     */
+    listProjects(input: ListProjectsInput): Promise<ProjectListResult>;
+    /**
+     * Set the active project
+     */
+    setProject(input: SetProjectInput): Promise<ProjectSetResult>;
+    /**
+     * Get access token for API requests
+     */
+    getAccessToken(): Promise<string | null>;
+    /**
+     * Install beta components
+     */
+    installBetaComponents(): Promise<{
+        success: boolean;
+        error?: {
+            message: string;
+        };
+    }>;
+    /**
+     * Check if Application Default Credentials (ADC) exist.
+     */
+    hasADC(): Promise<boolean>;
+    /**
+    /**
+     * Get the active project ID.
+     */
+    getProjectId(): Promise<string | null>;
+    /**
+     * Get the active user account.
+     */
+    getActiveAccount(): Promise<string | null>;
+}

package/dist/services/mcp-client/MockStitchMCPClient.d.ts

@@ -0,0 +1,7 @@
+import { StitchMCPClient } from './client.js';
+export declare class MockStitchMCPClient extends StitchMCPClient {
+    private mockScreens;
+    constructor(mockScreens: any[]);
+    connect(): Promise<void>;
+    callTool<T>(name: string, args: Record<string, any>): Promise<T>;
+}

package/dist/services/mcp-client/client.d.ts

@@ -0,0 +1,79 @@
+import { type StitchConfig, type StitchMCPClientSpec } from './spec.js';
+/**
+ * A robust, authenticated driver for the Stitch MCP Server.
+ * Handles auth injection, retries, and transport negotiation.
+ */
+export declare class StitchMCPClient implements StitchMCPClientSpec {
+    name: 'stitch-mcp-client';
+    description: 'Authenticated driver for Stitch MCP Server';
+    private client;
+    private transport;
+    private config;
+    private isConnected;
+    constructor(inputConfig?: Partial<StitchConfig>);
+    /**
+     * Auto-refreshes the Google Access Token via GcloudHandler.
+     * This ensures we use the bundled gcloud with proper CLOUDSDK_CONFIG.
+     */
+    private refreshGcloudToken;
+    /**
+     * Validates the token against Google's tokeninfo endpoint.
+     */
+    private validateToken;
+    /**
+     * Monkey-patches global fetch to ensure headers are ALWAYS present.
+     * This fixes issues where SDK layers might drop headers on redirects or retries.
+     */
+    private installNetworkInterceptor;
+    connect(): Promise<void>;
+    /**
+     * Generic tool caller with type support and error parsing.
+     */
+    callTool<T>(name: string, args: Record<string, any>): Promise<T>;
+    getCapabilities(): Promise<{
+        [x: string]: unknown;
+        tools: {
+            inputSchema: {
+                [x: string]: unknown;
+                type: "object";
+                properties?: Record<string, object> | undefined;
+                required?: string[] | undefined;
+            };
+            name: string;
+            description?: string | undefined;
+            outputSchema?: {
+                [x: string]: unknown;
+                type: "object";
+                properties?: Record<string, object> | undefined;
+                required?: string[] | undefined;
+            } | undefined;
+            annotations?: {
+                title?: string | undefined;
+                readOnlyHint?: boolean | undefined;
+                destructiveHint?: boolean | undefined;
+                idempotentHint?: boolean | undefined;
+                openWorldHint?: boolean | undefined;
+            } | undefined;
+            execution?: {
+                taskSupport?: "optional" | "required" | "forbidden" | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+            icons?: {
+                src: string;
+                mimeType?: string | undefined;
+                sizes?: string[] | undefined;
+                theme?: "light" | "dark" | undefined;
+            }[] | undefined;
+            title?: string | undefined;
+        }[];
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+        nextCursor?: string | undefined;
+    }>;
+    close(): Promise<void>;
+}

package/dist/services/mcp-client/spec.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export declare const StitchConfigSchema: z.ZodObject<{
+    accessToken: z.ZodOptional<z.ZodString>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    baseUrl: z.ZodDefault<z.ZodString>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    baseUrl: string;
+    accessToken?: string | undefined;
+    apiKey?: string | undefined;
+    projectId?: string | undefined;
+    timeout?: number | undefined;
+}, {
+    accessToken?: string | undefined;
+    apiKey?: string | undefined;
+    projectId?: string | undefined;
+    baseUrl?: string | undefined;
+    timeout?: number | undefined;
+}>;
+export type StitchConfig = z.infer<typeof StitchConfigSchema>;
+export interface StitchMCPClientSpec {
+    connect(): Promise<void>;
+    callTool<T>(name: string, args: Record<string, any>): Promise<T>;
+    getCapabilities(): Promise<any>;
+    close(): Promise<void>;
+}

package/dist/services/mcp-config/handler.d.ts

@@ -0,0 +1,13 @@
+import { type McpConfigService, type GenerateConfigInput, type McpConfigResult } from './spec.js';
+export declare class McpConfigHandler implements McpConfigService {
+    generateConfig(input: GenerateConfigInput): Promise<McpConfigResult>;
+    private generateHttpConfig;
+    private generateCursorConfig;
+    private generateAntigravityConfig;
+    private generateVSCodeConfig;
+    private generateClaudeCodeConfig;
+    private generateGeminiCliConfig;
+    private generateOpencodeConfig;
+    private generateStdioConfig;
+    private getInstructionsForClient;
+}

package/dist/services/mcp-config/spec.d.ts

@@ -0,0 +1,108 @@
+import { z } from 'zod';
+export type McpClient = 'antigravity' | 'vscode' | 'cursor' | 'claude-code' | 'gemini-cli' | 'codex' | 'opencode';
+export type TransportType = 'http' | 'stdio';
+export declare const GenerateConfigInputSchema: z.ZodEffects<z.ZodObject<{
+    client: z.ZodEnum<["antigravity", "vscode", "cursor", "claude-code", "gemini-cli", "codex", "opencode"]>;
+    projectId: z.ZodString;
+    accessToken: z.ZodOptional<z.ZodString>;
+    transport: z.ZodDefault<z.ZodEnum<["http", "stdio"]>>;
+    authMode: z.ZodOptional<z.ZodEnum<["oauth", "apiKey"]>>;
+    apiKey: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    projectId: string;
+    client: "cursor" | "antigravity" | "vscode" | "claude-code" | "gemini-cli" | "codex" | "opencode";
+    transport: "http" | "stdio";
+    accessToken?: string | undefined;
+    apiKey?: string | undefined;
+    authMode?: "apiKey" | "oauth" | undefined;
+}, {
+    projectId: string;
+    client: "cursor" | "antigravity" | "vscode" | "claude-code" | "gemini-cli" | "codex" | "opencode";
+    accessToken?: string | undefined;
+    apiKey?: string | undefined;
+    transport?: "http" | "stdio" | undefined;
+    authMode?: "apiKey" | "oauth" | undefined;
+}>, {
+    projectId: string;
+    client: "cursor" | "antigravity" | "vscode" | "claude-code" | "gemini-cli" | "codex" | "opencode";
+    transport: "http" | "stdio";
+    accessToken?: string | undefined;
+    apiKey?: string | undefined;
+    authMode?: "apiKey" | "oauth" | undefined;
+}, {
+    projectId: string;
+    client: "cursor" | "antigravity" | "vscode" | "claude-code" | "gemini-cli" | "codex" | "opencode";
+    accessToken?: string | undefined;
+    apiKey?: string | undefined;
+    transport?: "http" | "stdio" | undefined;
+    authMode?: "apiKey" | "oauth" | undefined;
+}>;
+export type GenerateConfigInput = z.infer<typeof GenerateConfigInputSchema>;
+export declare const McpConfigErrorCode: z.ZodEnum<["INVALID_CLIENT", "CONFIG_GENERATION_FAILED", "UNKNOWN_ERROR"]>;
+export declare const McpConfigSuccess: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        config: z.ZodString;
+        instructions: z.ZodString;
+        filePath: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        config: string;
+        instructions: string;
+        filePath?: string | undefined;
+    }, {
+        config: string;
+        instructions: string;
+        filePath?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: true;
+    data: {
+        config: string;
+        instructions: string;
+        filePath?: string | undefined;
+    };
+}, {
+    success: true;
+    data: {
+        config: string;
+        instructions: string;
+        filePath?: string | undefined;
+    };
+}>;
+export declare const McpConfigFailure: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["INVALID_CLIENT", "CONFIG_GENERATION_FAILED", "UNKNOWN_ERROR"]>;
+        message: z.ZodString;
+        recoverable: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        code: "UNKNOWN_ERROR" | "CONFIG_GENERATION_FAILED" | "INVALID_CLIENT";
+        message: string;
+        recoverable: boolean;
+    }, {
+        code: "UNKNOWN_ERROR" | "CONFIG_GENERATION_FAILED" | "INVALID_CLIENT";
+        message: string;
+        recoverable: boolean;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "CONFIG_GENERATION_FAILED" | "INVALID_CLIENT";
+        message: string;
+        recoverable: boolean;
+    };
+}, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "CONFIG_GENERATION_FAILED" | "INVALID_CLIENT";
+        message: string;
+        recoverable: boolean;
+    };
+}>;
+export type McpConfigResult = z.infer<typeof McpConfigSuccess> | z.infer<typeof McpConfigFailure>;
+export interface McpConfigService {
+    /**
+     * Generate MCP configuration for specified client
+     */
+    generateConfig(input: GenerateConfigInput): Promise<McpConfigResult>;
+}

package/dist/services/project/handler.d.ts

@@ -0,0 +1,11 @@
+import { type ProjectService, type SelectProjectInput, type ProjectSelectionResult } from './spec.js';
+import { type GcloudService } from '../gcloud/spec.js';
+export declare class ProjectHandler implements ProjectService {
+    private gcloudService;
+    constructor(gcloudService: GcloudService);
+    selectProject(input: SelectProjectInput): Promise<ProjectSelectionResult>;
+    getProjectDetails(input: {
+        projectId: string;
+    }): Promise<ProjectSelectionResult>;
+    private searchAndSelect;
+}