@_davideast/stitch-mcp 0.4.0 → 0.5.0

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

@@ -5,12 +5,12 @@ export declare const StartProxyInputSchema: z.ZodObject<{
     debug: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     transport: "stdio" | "sse";
-    debug?: boolean | undefined;
     port?: number | undefined;
-}, {
     debug?: boolean | undefined;
-    port?: number | undefined;
+}, {
     transport?: "stdio" | "sse" | undefined;
+    port?: number | undefined;
+    debug?: boolean | undefined;
 }>;
 export type StartProxyInput = z.infer<typeof StartProxyInputSchema>;
 export declare const ProxyErrorCode: z.ZodEnum<["START_FAILED", "TRANSPORT_ERROR", "AUTH_REFRESH_FAILED", "UNKNOWN_ERROR"]>;

package/dist/services/stitch/api.d.ts

@@ -0,0 +1,10 @@
+import { type APIEnableResult, type EnableAPIInput } from './spec.js';
+import type { GcloudExecutor } from '../gcloud/core.js';
+export declare class StitchApiService {
+    private executor;
+    constructor(executor: GcloudExecutor);
+    enableAPI(input: EnableAPIInput): Promise<APIEnableResult>;
+    checkAPIEnabled(input: {
+        projectId: string;
+    }): Promise<boolean>;
+}

package/dist/services/stitch/connection.d.ts

@@ -0,0 +1,5 @@
+import { type ConnectionTestResult, type TestConnectionInput, type TestConnectionWithApiKeyInput } from './spec.js';
+export declare class StitchConnectionService {
+    testConnectionWithApiKey(input: TestConnectionWithApiKeyInput): Promise<ConnectionTestResult>;
+    testConnection(input: TestConnectionInput): Promise<ConnectionTestResult>;
+}

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

@@ -1,8 +1,10 @@
 import { type StitchService, type ConfigureIAMInput, type EnableAPIInput, type TestConnectionInput, type TestConnectionWithApiKeyInput, type IAMConfigResult, type APIEnableResult, type ConnectionTestResult } from './spec.js';
 export declare class StitchHandler implements StitchService {
-    private getGcloudEnv;
-    private gcloudBinaryPromise;
-    private getGcloudBinary;
+    private executor;
+    private iamService;
+    private apiService;
+    private connectionService;
+    constructor();
     configureIAM(input: ConfigureIAMInput): Promise<IAMConfigResult>;
     enableAPI(input: EnableAPIInput): Promise<APIEnableResult>;
     checkIAMRole(input: {

package/dist/services/stitch/iam.d.ts

@@ -0,0 +1,11 @@
+import { type IAMConfigResult, type ConfigureIAMInput } from './spec.js';
+import type { GcloudExecutor } from '../gcloud/core.js';
+export declare class StitchIamService {
+    private executor;
+    constructor(executor: GcloudExecutor);
+    configureIAM(input: ConfigureIAMInput): Promise<IAMConfigResult>;
+    checkIAMRole(input: {
+        projectId: string;
+        userEmail: string;
+    }): Promise<boolean>;
+}

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

@@ -22,11 +22,11 @@ export declare const TestConnectionInputSchema: z.ZodObject<{
     projectId: z.ZodString;
     accessToken: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    accessToken: string;
     projectId: string;
-}, {
     accessToken: string;
+}, {
     projectId: string;
+    accessToken: string;
 }>;
 export type TestConnectionInput = z.infer<typeof TestConnectionInputSchema>;
 export declare const TestConnectionWithApiKeyInputSchema: z.ZodObject<{
@@ -178,30 +178,30 @@ export declare const ConnectionTestSuccess: z.ZodObject<{
         url: z.ZodString;
         response: z.ZodOptional<z.ZodAny>;
     }, "strip", z.ZodTypeAny, {
-        url: string;
         connected: boolean;
         statusCode: number;
+        url: string;
         response?: any;
     }, {
-        url: string;
         connected: boolean;
         statusCode: number;
+        url: string;
         response?: any;
     }>;
 }, "strip", z.ZodTypeAny, {
     success: true;
     data: {
-        url: string;
         connected: boolean;
         statusCode: number;
+        url: string;
         response?: any;
     };
 }, {
     success: true;
     data: {
-        url: string;
         connected: boolean;
         statusCode: number;
+        url: string;
         response?: any;
     };
 }>;

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

@@ -8,15 +8,15 @@ export declare const ViewInputSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     projects: boolean;
     name?: string | undefined;
-    sourceScreen?: string | undefined;
     project?: string | undefined;
     screen?: string | undefined;
+    sourceScreen?: string | undefined;
 }, {
-    projects?: boolean | undefined;
     name?: string | undefined;
-    sourceScreen?: string | undefined;
+    projects?: boolean | undefined;
     project?: string | undefined;
     screen?: string | undefined;
+    sourceScreen?: string | undefined;
 }>;
 export type ViewInput = z.infer<typeof ViewInputSchema>;
 export declare const ViewErrorCode: z.ZodEnum<["INVALID_ARGS", "FETCH_FAILED", "UNKNOWN_ERROR"]>;
@@ -37,25 +37,25 @@ export declare const ViewFailure: z.ZodObject<{
         message: z.ZodString;
         recoverable: z.ZodBoolean;
     }, "strip", z.ZodTypeAny, {
-        code: "INVALID_ARGS" | "FETCH_FAILED" | "UNKNOWN_ERROR";
+        code: "UNKNOWN_ERROR" | "INVALID_ARGS" | "FETCH_FAILED";
         message: string;
         recoverable: boolean;
     }, {
-        code: "INVALID_ARGS" | "FETCH_FAILED" | "UNKNOWN_ERROR";
+        code: "UNKNOWN_ERROR" | "INVALID_ARGS" | "FETCH_FAILED";
         message: string;
         recoverable: boolean;
     }>;
 }, "strip", z.ZodTypeAny, {
     success: false;
     error: {
-        code: "INVALID_ARGS" | "FETCH_FAILED" | "UNKNOWN_ERROR";
+        code: "UNKNOWN_ERROR" | "INVALID_ARGS" | "FETCH_FAILED";
         message: string;
         recoverable: boolean;
     };
 }, {
     success: false;
     error: {
-        code: "INVALID_ARGS" | "FETCH_FAILED" | "UNKNOWN_ERROR";
+        code: "UNKNOWN_ERROR" | "INVALID_ARGS" | "FETCH_FAILED";
         message: string;
         recoverable: boolean;
     };

package/dist/src/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/commands/doctor/handler.d.ts

@@ -0,0 +1,9 @@
+import { type DoctorCommand, type DoctorInput, type DoctorResult } from './spec.js';
+import { type GcloudService } from '../../services/gcloud/spec.js';
+import { type StitchService } from '../../services/stitch/spec.js';
+export declare class DoctorHandler implements DoctorCommand {
+    private readonly gcloudService;
+    private readonly stitchService;
+    constructor(gcloudService?: GcloudService, stitchService?: StitchService);
+    execute(input: DoctorInput): Promise<DoctorResult>;
+}

package/dist/src/commands/doctor/handler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/commands/doctor/spec.d.ts

@@ -0,0 +1,130 @@
+import { z } from 'zod';
+export declare const DoctorInputSchema: z.ZodObject<{
+    verbose: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    verbose: boolean;
+}, {
+    verbose?: boolean | undefined;
+}>;
+export type DoctorInput = z.infer<typeof DoctorInputSchema>;
+export declare const DoctorErrorCode: z.ZodEnum<["CHECKS_FAILED", "UNKNOWN_ERROR"]>;
+export declare const HealthCheckSchema: z.ZodObject<{
+    name: z.ZodString;
+    passed: z.ZodBoolean;
+    message: z.ZodString;
+    suggestion: z.ZodOptional<z.ZodString>;
+    details: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    name: string;
+    passed: boolean;
+    suggestion?: string | undefined;
+    details?: string | undefined;
+}, {
+    message: string;
+    name: string;
+    passed: boolean;
+    suggestion?: string | undefined;
+    details?: string | undefined;
+}>;
+export declare const DoctorSuccess: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        checks: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            passed: z.ZodBoolean;
+            message: z.ZodString;
+            suggestion: z.ZodOptional<z.ZodString>;
+            details: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            message: string;
+            name: string;
+            passed: boolean;
+            suggestion?: string | undefined;
+            details?: string | undefined;
+        }, {
+            message: string;
+            name: string;
+            passed: boolean;
+            suggestion?: string | undefined;
+            details?: string | undefined;
+        }>, "many">;
+        allPassed: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        checks: {
+            message: string;
+            name: string;
+            passed: boolean;
+            suggestion?: string | undefined;
+            details?: string | undefined;
+        }[];
+        allPassed: boolean;
+    }, {
+        checks: {
+            message: string;
+            name: string;
+            passed: boolean;
+            suggestion?: string | undefined;
+            details?: string | undefined;
+        }[];
+        allPassed: boolean;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: true;
+    data: {
+        checks: {
+            message: string;
+            name: string;
+            passed: boolean;
+            suggestion?: string | undefined;
+            details?: string | undefined;
+        }[];
+        allPassed: boolean;
+    };
+}, {
+    success: true;
+    data: {
+        checks: {
+            message: string;
+            name: string;
+            passed: boolean;
+            suggestion?: string | undefined;
+            details?: string | undefined;
+        }[];
+        allPassed: boolean;
+    };
+}>;
+export declare const DoctorFailure: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["CHECKS_FAILED", "UNKNOWN_ERROR"]>;
+        message: z.ZodString;
+        recoverable: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        code: "UNKNOWN_ERROR" | "CHECKS_FAILED";
+        message: string;
+        recoverable: boolean;
+    }, {
+        code: "UNKNOWN_ERROR" | "CHECKS_FAILED";
+        message: string;
+        recoverable: boolean;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "CHECKS_FAILED";
+        message: string;
+        recoverable: boolean;
+    };
+}, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "CHECKS_FAILED";
+        message: string;
+        recoverable: boolean;
+    };
+}>;
+export type DoctorResult = z.infer<typeof DoctorSuccess> | z.infer<typeof DoctorFailure>;
+export interface DoctorCommand {
+    execute(input: DoctorInput): Promise<DoctorResult>;
+}

package/dist/src/commands/doctor/spec.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/commands/init/handler.d.ts

@@ -0,0 +1,17 @@
+import { type InitCommand, type InitInput, type InitResult } from './spec.js';
+import { type GcloudService } from '../../services/gcloud/spec.js';
+import { type ProjectService } from '../../services/project/spec.js';
+import { type StitchService } from '../../services/stitch/spec.js';
+import { type McpConfigService } from '../../services/mcp-config/spec.js';
+export declare class InitHandler implements InitCommand {
+    private readonly gcloudService;
+    private readonly mcpConfigService;
+    private readonly projectService;
+    private readonly stitchService;
+    constructor(gcloudService?: GcloudService, mcpConfigService?: McpConfigService, projectService?: ProjectService, // ProjectHandler depends on GcloudHandler
+    stitchService?: StitchService);
+    execute(input: InitInput): Promise<InitResult>;
+    private resolveMcpClient;
+    private resolveTransport;
+    private setupGeminiExtension;
+}

package/dist/src/commands/init/handler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/commands/init/spec.d.ts

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+export declare const InitInputSchema: z.ZodObject<{
+    local: z.ZodDefault<z.ZodBoolean>;
+    defaults: z.ZodDefault<z.ZodBoolean>;
+    client: z.ZodOptional<z.ZodString>;
+    transport: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    local: boolean;
+    defaults: boolean;
+    client?: string | undefined;
+    transport?: string | undefined;
+}, {
+    local?: boolean | undefined;
+    defaults?: boolean | undefined;
+    client?: string | undefined;
+    transport?: string | undefined;
+}>;
+export type InitInput = z.infer<typeof InitInputSchema>;
+export declare const InitErrorCode: z.ZodEnum<["GCLOUD_SETUP_FAILED", "AUTH_FAILED", "PROJECT_SELECTION_FAILED", "API_CONFIG_FAILED", "CONFIG_GENERATION_FAILED", "USER_CANCELLED", "UNKNOWN_ERROR"]>;
+export declare const InitSuccess: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        projectId: z.ZodString;
+        mcpConfig: z.ZodString;
+        instructions: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        projectId: string;
+        mcpConfig: string;
+        instructions: string;
+    }, {
+        projectId: string;
+        mcpConfig: string;
+        instructions: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: true;
+    data: {
+        projectId: string;
+        mcpConfig: string;
+        instructions: string;
+    };
+}, {
+    success: true;
+    data: {
+        projectId: string;
+        mcpConfig: string;
+        instructions: string;
+    };
+}>;
+export declare const InitFailure: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["GCLOUD_SETUP_FAILED", "AUTH_FAILED", "PROJECT_SELECTION_FAILED", "API_CONFIG_FAILED", "CONFIG_GENERATION_FAILED", "USER_CANCELLED", "UNKNOWN_ERROR"]>;
+        message: z.ZodString;
+        suggestion: z.ZodOptional<z.ZodString>;
+        recoverable: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        code: "GCLOUD_SETUP_FAILED" | "AUTH_FAILED" | "PROJECT_SELECTION_FAILED" | "API_CONFIG_FAILED" | "CONFIG_GENERATION_FAILED" | "USER_CANCELLED" | "UNKNOWN_ERROR";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    }, {
+        code: "GCLOUD_SETUP_FAILED" | "AUTH_FAILED" | "PROJECT_SELECTION_FAILED" | "API_CONFIG_FAILED" | "CONFIG_GENERATION_FAILED" | "USER_CANCELLED" | "UNKNOWN_ERROR";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: false;
+    error: {
+        code: "GCLOUD_SETUP_FAILED" | "AUTH_FAILED" | "PROJECT_SELECTION_FAILED" | "API_CONFIG_FAILED" | "CONFIG_GENERATION_FAILED" | "USER_CANCELLED" | "UNKNOWN_ERROR";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    };
+}, {
+    success: false;
+    error: {
+        code: "GCLOUD_SETUP_FAILED" | "AUTH_FAILED" | "PROJECT_SELECTION_FAILED" | "API_CONFIG_FAILED" | "CONFIG_GENERATION_FAILED" | "USER_CANCELLED" | "UNKNOWN_ERROR";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    };
+}>;
+export type InitResult = z.infer<typeof InitSuccess> | z.infer<typeof InitFailure>;
+export interface InitCommand {
+    execute(input: InitInput): Promise<InitResult>;
+}

package/dist/src/commands/init/spec.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/commands/proxy/handler.d.ts

@@ -0,0 +1,7 @@
+import { ProxyHandler } from '../../services/proxy/handler.js';
+import type { StartProxyInput, ProxyResult } from '../../services/proxy/spec.js';
+export declare class ProxyCommandHandler {
+    private proxyService;
+    constructor(proxyService?: ProxyHandler);
+    execute(input: StartProxyInput): Promise<ProxyResult>;
+}

package/dist/src/commands/proxy/handler.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/index.d.ts

@@ -0,0 +1,13 @@
+export { GcloudHandler } from './services/gcloud/handler.js';
+export { ProjectHandler } from './services/project/handler.js';
+export { StitchHandler } from './services/stitch/handler.js';
+export { McpConfigHandler } from './services/mcp-config/handler.js';
+export { InitHandler } from './commands/init/handler.js';
+export { DoctorHandler } from './commands/doctor/handler.js';
+export type { GcloudService } from './services/gcloud/spec.js';
+export type { ProjectService } from './services/project/spec.js';
+export type { StitchService } from './services/stitch/spec.js';
+export type { McpConfigService } from './services/mcp-config/spec.js';
+export type { InitCommand } from './commands/init/spec.js';
+export type { DoctorCommand } from './commands/doctor/spec.js';
+export type { McpClient } from './ui/wizard.js';

package/dist/src/platform/detector.d.ts

@@ -0,0 +1,29 @@
+export type OS = 'macos' | 'linux' | 'windows';
+export type Arch = 'arm64' | 'x86_64';
+export interface Platform {
+    os: OS;
+    arch: Arch;
+    gcloudDownloadUrl: string;
+    gcloudBinaryName: string;
+    isWindows: boolean;
+}
+/**
+ * Detect the current platform and architecture
+ */
+export declare function detectPlatform(): Platform;
+/**
+ * Get the user's home directory
+ */
+export declare function getHomeDir(): string;
+/**
+ * Get the Stitch MCP directory path
+ */
+export declare function getStitchDir(): string;
+/**
+ * Get the gcloud SDK installation path
+ */
+export declare function getGcloudSdkPath(): string;
+/**
+ * Get the gcloud config directory path
+ */
+export declare function getGcloudConfigPath(): string;

package/dist/src/platform/paths.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Get cross-platform path join
+ */
+export declare function joinPath(...parts: string[]): string;
+/**
+ * Get the directory name from a path
+ */
+export declare function dirname(filepath: string): string;
+/**
+ * Get the basename from a path
+ */
+export declare function basename(filepath: string): string;
+/**
+ * Normalize path separators for the current platform
+ */
+export declare function normalizePath(filepath: string): string;
+/**
+ * Convert a path to use forward slashes (for consistency)
+ */
+export declare function toUnixPath(filepath: string): string;

package/dist/src/platform/shell.d.ts

@@ -0,0 +1,26 @@
+export interface ShellResult {
+    success: boolean;
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    error?: string;
+}
+/**
+ * Execute a shell command and return the result
+ */
+export declare function execCommand(command: string[], options?: {
+    cwd?: string;
+    env?: Record<string, string>;
+    timeout?: number;
+}): Promise<ShellResult>;
+/**
+ * Execute a shell command and stream output
+ */
+export declare function execCommandStreaming(command: string[], onStdout?: (data: string) => void, onStderr?: (data: string) => void, options?: {
+    cwd?: string;
+    env?: Record<string, string>;
+}): Promise<ShellResult>;
+/**
+ * Check if a command exists in PATH
+ */
+export declare function commandExists(command: string): Promise<boolean>;

package/dist/src/services/gcloud/handler.d.ts

@@ -0,0 +1,48 @@
+import { type GcloudService, type EnsureGcloudInput, type AuthenticateInput, type ListProjectsInput, type SetProjectInput, type GcloudResult, type AuthResult, type ProjectListResult, type ProjectSetResult } from './spec.js';
+export declare class GcloudHandler implements GcloudService {
+    private platform;
+    private gcloudPath;
+    /**
+     * Ensure gcloud is installed and available
+     */
+    ensureInstalled(input: EnsureGcloudInput): Promise<GcloudResult>;
+    /**
+     * Authenticate user
+     */
+    authenticate(input: AuthenticateInput): Promise<AuthResult>;
+    /**
+     * Authenticate application default credentials
+     */
+    authenticateADC(input: AuthenticateInput): Promise<AuthResult>;
+    /**
+     * List projects
+     */
+    listProjects(input: ListProjectsInput): Promise<ProjectListResult>;
+    /**
+     * Set active project
+     */
+    setProject(input: SetProjectInput): Promise<ProjectSetResult>;
+    /**
+     * Get access token
+     */
+    getAccessToken(): Promise<string | null>;
+    getProjectId(): Promise<string | null>;
+    /**
+     * Install beta components
+     */
+    installBetaComponents(): Promise<{
+        success: boolean;
+        error?: {
+            message: string;
+        };
+    }>;
+    private findGlobalGcloud;
+    private getVersionFromPath;
+    private isVersionValid;
+    private installLocal;
+    private setupEnvironment;
+    private getEnvironment;
+    private getGcloudCommand;
+    getActiveAccount(): Promise<string | null>;
+    hasADC(): Promise<boolean>;
+}

package/dist/src/services/gcloud/handler.test.d.ts

@@ -0,0 +1 @@
+export {};