google-stitch-mcp 0.3.2

package/dist/commands/doctor/command.d.ts

@@ -0,0 +1,2 @@
+import { type CommandDefinition } from '../../framework/CommandDefinition.js';
+export declare const command: CommandDefinition;

package/dist/commands/doctor/context.d.ts

@@ -0,0 +1,19 @@
+import { type DoctorInput } from './spec.js';
+import { type UserInterface } from '../../framework/UserInterface.js';
+import { type GcloudService } from '../../services/gcloud/spec.js';
+import { type StitchService } from '../../services/stitch/spec.js';
+export interface DoctorContext {
+    input: DoctorInput;
+    ui: UserInterface;
+    gcloudService: GcloudService;
+    stitchService: StitchService;
+    authMode: 'apiKey' | 'oauth';
+    apiKey?: string;
+    checks: Array<{
+        name: string;
+        passed: boolean;
+        message: string;
+        suggestion?: string;
+        details?: string;
+    }>;
+}

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

@@ -0,0 +1,12 @@
+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';
+import { type UserInterface } from '../../framework/UserInterface.js';
+export declare class DoctorHandler implements DoctorCommand {
+    private readonly gcloudService;
+    private readonly stitchService;
+    private steps;
+    private readonly ui;
+    constructor(gcloudService?: GcloudService, stitchService?: StitchService, ui?: UserInterface);
+    execute(input: DoctorInput): Promise<DoctorResult>;
+}

package/dist/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, {
+    name: string;
+    message: string;
+    passed: boolean;
+    suggestion?: string | undefined;
+    details?: string | undefined;
+}, {
+    name: string;
+    message: 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, {
+            name: string;
+            message: string;
+            passed: boolean;
+            suggestion?: string | undefined;
+            details?: string | undefined;
+        }, {
+            name: string;
+            message: string;
+            passed: boolean;
+            suggestion?: string | undefined;
+            details?: string | undefined;
+        }>, "many">;
+        allPassed: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        checks: {
+            name: string;
+            message: string;
+            passed: boolean;
+            suggestion?: string | undefined;
+            details?: string | undefined;
+        }[];
+        allPassed: boolean;
+    }, {
+        checks: {
+            name: string;
+            message: string;
+            passed: boolean;
+            suggestion?: string | undefined;
+            details?: string | undefined;
+        }[];
+        allPassed: boolean;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: true;
+    data: {
+        checks: {
+            name: string;
+            message: string;
+            passed: boolean;
+            suggestion?: string | undefined;
+            details?: string | undefined;
+        }[];
+        allPassed: boolean;
+    };
+}, {
+    success: true;
+    data: {
+        checks: {
+            name: string;
+            message: 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/commands/doctor/steps/AdcCheckStep.d.ts

@@ -0,0 +1,8 @@
+import { type CommandStep, type StepResult } from '../../../framework/CommandStep.js';
+import { type DoctorContext } from '../context.js';
+export declare class AdcCheckStep implements CommandStep<DoctorContext> {
+    id: string;
+    name: string;
+    shouldRun(context: DoctorContext): Promise<boolean>;
+    run(context: DoctorContext): Promise<StepResult>;
+}

package/dist/commands/doctor/steps/ApiCheckStep.d.ts

@@ -0,0 +1,8 @@
+import { type CommandStep, type StepResult } from '../../../framework/CommandStep.js';
+import { type DoctorContext } from '../context.js';
+export declare class ApiCheckStep implements CommandStep<DoctorContext> {
+    id: string;
+    name: string;
+    shouldRun(context: DoctorContext): Promise<boolean>;
+    run(context: DoctorContext): Promise<StepResult>;
+}

package/dist/commands/doctor/steps/ApiKeyConnectionStep.d.ts

@@ -0,0 +1,8 @@
+import { type CommandStep, type StepResult } from '../../../framework/CommandStep.js';
+import { type DoctorContext } from '../context.js';
+export declare class ApiKeyConnectionStep implements CommandStep<DoctorContext> {
+    id: string;
+    name: string;
+    shouldRun(context: DoctorContext): Promise<boolean>;
+    run(context: DoctorContext): Promise<StepResult>;
+}

package/dist/commands/doctor/steps/ApiKeyDetectedStep.d.ts

@@ -0,0 +1,8 @@
+import { type CommandStep, type StepResult } from '../../../framework/CommandStep.js';
+import { type DoctorContext } from '../context.js';
+export declare class ApiKeyDetectedStep implements CommandStep<DoctorContext> {
+    id: string;
+    name: string;
+    shouldRun(context: DoctorContext): Promise<boolean>;
+    run(context: DoctorContext): Promise<StepResult>;
+}

package/dist/commands/doctor/steps/AuthCheckStep.d.ts

@@ -0,0 +1,8 @@
+import { type CommandStep, type StepResult } from '../../../framework/CommandStep.js';
+import { type DoctorContext } from '../context.js';
+export declare class AuthCheckStep implements CommandStep<DoctorContext> {
+    id: string;
+    name: string;
+    shouldRun(context: DoctorContext): Promise<boolean>;
+    run(context: DoctorContext): Promise<StepResult>;
+}

package/dist/commands/doctor/steps/GcloudCheckStep.d.ts

@@ -0,0 +1,8 @@
+import { type CommandStep, type StepResult } from '../../../framework/CommandStep.js';
+import { type DoctorContext } from '../context.js';
+export declare class GcloudCheckStep implements CommandStep<DoctorContext> {
+    id: string;
+    name: string;
+    shouldRun(context: DoctorContext): Promise<boolean>;
+    run(context: DoctorContext): Promise<StepResult>;
+}

package/dist/commands/doctor/steps/ProjectCheckStep.d.ts

@@ -0,0 +1,8 @@
+import { type CommandStep, type StepResult } from '../../../framework/CommandStep.js';
+import { type DoctorContext } from '../context.js';
+export declare class ProjectCheckStep implements CommandStep<DoctorContext> {
+    id: string;
+    name: string;
+    shouldRun(context: DoctorContext): Promise<boolean>;
+    run(context: DoctorContext): Promise<StepResult>;
+}

package/dist/commands/init/command.d.ts

@@ -0,0 +1,2 @@
+import { type CommandDefinition } from '../../framework/CommandDefinition.js';
+export declare const command: CommandDefinition;

package/dist/commands/init/context.d.ts

@@ -0,0 +1,24 @@
+import { type InitInput } from './spec.js';
+import { type UserInterface } from '../../framework/UserInterface.js';
+import { type GcloudService } from '../../services/gcloud/spec.js';
+import { type McpConfigService } from '../../services/mcp-config/spec.js';
+import { type ProjectService } from '../../services/project/spec.js';
+import { type StitchService } from '../../services/stitch/spec.js';
+import { type McpClient } from '../../ui/wizard.js';
+export interface InitContext {
+    input: InitInput;
+    ui: UserInterface;
+    gcloudService: GcloudService;
+    mcpConfigService: McpConfigService;
+    projectService: ProjectService;
+    stitchService: StitchService;
+    mcpClient?: McpClient;
+    authMode?: 'apiKey' | 'oauth';
+    apiKey?: string;
+    accessToken?: string;
+    projectId?: string;
+    transport?: 'http' | 'stdio';
+    authAccount?: string;
+    instructions?: string;
+    finalConfig?: string;
+}

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

@@ -0,0 +1,19 @@
+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';
+import { type UserInterface } from '../../framework/UserInterface.js';
+export declare class InitHandler implements InitCommand {
+    private readonly gcloudService;
+    private readonly mcpConfigService;
+    private readonly projectService;
+    private readonly stitchService;
+    private readonly ui;
+    private checklist;
+    private steps;
+    constructor(gcloudService?: GcloudService, mcpConfigService?: McpConfigService, projectService?: ProjectService, stitchService?: StitchService, ui?: UserInterface);
+    execute(input: InitInput): Promise<InitResult>;
+    private updateStep;
+    private printStepResult;
+}

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

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+export declare const InitInputSchema: z.ZodObject<{
+    local: z.ZodDefault<z.ZodBoolean>;
+    defaults: z.ZodDefault<z.ZodBoolean>;
+    autoVerify: z.ZodDefault<z.ZodBoolean>;
+    client: z.ZodOptional<z.ZodString>;
+    transport: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    local: boolean;
+    defaults: boolean;
+    autoVerify: boolean;
+    client?: string | undefined;
+    transport?: string | undefined;
+}, {
+    client?: string | undefined;
+    local?: boolean | undefined;
+    defaults?: boolean | undefined;
+    autoVerify?: boolean | 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: "UNKNOWN_ERROR" | "AUTH_FAILED" | "GCLOUD_SETUP_FAILED" | "PROJECT_SELECTION_FAILED" | "API_CONFIG_FAILED" | "CONFIG_GENERATION_FAILED" | "USER_CANCELLED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    }, {
+        code: "UNKNOWN_ERROR" | "AUTH_FAILED" | "GCLOUD_SETUP_FAILED" | "PROJECT_SELECTION_FAILED" | "API_CONFIG_FAILED" | "CONFIG_GENERATION_FAILED" | "USER_CANCELLED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "AUTH_FAILED" | "GCLOUD_SETUP_FAILED" | "PROJECT_SELECTION_FAILED" | "API_CONFIG_FAILED" | "CONFIG_GENERATION_FAILED" | "USER_CANCELLED";
+        message: string;
+        recoverable: boolean;
+        suggestion?: string | undefined;
+    };
+}, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "AUTH_FAILED" | "GCLOUD_SETUP_FAILED" | "PROJECT_SELECTION_FAILED" | "API_CONFIG_FAILED" | "CONFIG_GENERATION_FAILED" | "USER_CANCELLED";
+        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/commands/init/steps/AuthModeStep.d.ts

@@ -0,0 +1,8 @@
+import { type CommandStep, type StepResult } from '../../../framework/CommandStep.js';
+import { type InitContext } from '../context.js';
+export declare class AuthModeStep implements CommandStep<InitContext> {
+    id: string;
+    name: string;
+    shouldRun(context: InitContext): Promise<boolean>;
+    run(context: InitContext): Promise<StepResult>;
+}

package/dist/commands/init/steps/AuthStep.d.ts

@@ -0,0 +1,8 @@
+import { type CommandStep, type StepResult } from '../../../framework/CommandStep.js';
+import { type InitContext } from '../context.js';
+export declare class AuthStep implements CommandStep<InitContext> {
+    id: string;
+    name: string;
+    shouldRun(context: InitContext): Promise<boolean>;
+    run(context: InitContext): Promise<StepResult>;
+}

package/dist/commands/init/steps/ClientSelectionStep.d.ts

@@ -0,0 +1,9 @@
+import { type CommandStep, type StepResult } from '../../../framework/CommandStep.js';
+import { type InitContext } from '../context.js';
+export declare class ClientSelectionStep implements CommandStep<InitContext> {
+    id: string;
+    name: string;
+    shouldRun(context: InitContext): Promise<boolean>;
+    run(context: InitContext): Promise<StepResult>;
+    private resolveMcpClient;
+}

package/dist/commands/init/steps/ConfigStep.d.ts

@@ -0,0 +1,9 @@
+import { type CommandStep, type StepResult } from '../../../framework/CommandStep.js';
+import { type InitContext } from '../context.js';
+export declare class ConfigStep implements CommandStep<InitContext> {
+    id: string;
+    name: string;
+    shouldRun(context: InitContext): Promise<boolean>;
+    run(context: InitContext): Promise<StepResult>;
+    private setupGeminiExtension;
+}

package/dist/commands/init/steps/GcloudInstallStep.d.ts

@@ -0,0 +1,8 @@
+import { type CommandStep, type StepResult } from '../../../framework/CommandStep.js';
+import { type InitContext } from '../context.js';
+export declare class GcloudInstallStep implements CommandStep<InitContext> {
+    id: string;
+    name: string;
+    shouldRun(context: InitContext): Promise<boolean>;
+    run(context: InitContext): Promise<StepResult>;
+}

package/dist/commands/init/steps/IamApiStep.d.ts

@@ -0,0 +1,8 @@
+import { type CommandStep, type StepResult } from '../../../framework/CommandStep.js';
+import { type InitContext } from '../context.js';
+export declare class IamApiStep implements CommandStep<InitContext> {
+    id: string;
+    name: string;
+    shouldRun(context: InitContext): Promise<boolean>;
+    run(context: InitContext): Promise<StepResult>;
+}

package/dist/commands/init/steps/ProjectSelectStep.d.ts

@@ -0,0 +1,8 @@
+import { type CommandStep, type StepResult } from '../../../framework/CommandStep.js';
+import { type InitContext } from '../context.js';
+export declare class ProjectSelectStep implements CommandStep<InitContext> {
+    id: string;
+    name: string;
+    shouldRun(context: InitContext): Promise<boolean>;
+    run(context: InitContext): Promise<StepResult>;
+}

package/dist/commands/init/steps/TestConnectionStep.d.ts

@@ -0,0 +1,8 @@
+import { type CommandStep, type StepResult } from '../../../framework/CommandStep.js';
+import { type InitContext } from '../context.js';
+export declare class TestConnectionStep implements CommandStep<InitContext> {
+    id: string;
+    name: string;
+    shouldRun(context: InitContext): Promise<boolean>;
+    run(context: InitContext): Promise<StepResult>;
+}

package/dist/commands/init/steps/TransportStep.d.ts

@@ -0,0 +1,9 @@
+import { type CommandStep, type StepResult } from '../../../framework/CommandStep.js';
+import { type InitContext } from '../context.js';
+export declare class TransportStep implements CommandStep<InitContext> {
+    id: string;
+    name: string;
+    shouldRun(context: InitContext): Promise<boolean>;
+    run(context: InitContext): Promise<StepResult>;
+    private resolveTransport;
+}

package/dist/commands/logout/command.d.ts

@@ -0,0 +1,2 @@
+import { type CommandDefinition } from '../../framework/CommandDefinition.js';
+export declare const command: CommandDefinition;

package/dist/commands/logout/context.d.ts

@@ -0,0 +1,12 @@
+import { type LogoutInput } from './spec.js';
+import { type UserInterface } from '../../framework/UserInterface.js';
+import { type GcloudService } from '../../services/gcloud/spec.js';
+export interface LogoutContext {
+    input: LogoutInput;
+    ui: UserInterface;
+    gcloudService: GcloudService;
+    gcloudPath?: string;
+    userRevoked: boolean;
+    adcRevoked: boolean;
+    configCleared: boolean;
+}

package/dist/commands/logout/handler.d.ts

@@ -0,0 +1,8 @@
+import { type LogoutCommand, type LogoutInput, type LogoutResult } from './spec.js';
+import { type GcloudService } from '../../services/gcloud/spec.js';
+export declare class LogoutHandler implements LogoutCommand {
+    private readonly gcloudService;
+    private steps;
+    constructor(gcloudService?: GcloudService);
+    execute(input: LogoutInput): Promise<LogoutResult>;
+}

package/dist/commands/logout/spec.d.ts

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+export declare const LogoutInputSchema: z.ZodObject<{
+    force: z.ZodDefault<z.ZodBoolean>;
+    clearConfig: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    force: boolean;
+    clearConfig: boolean;
+}, {
+    force?: boolean | undefined;
+    clearConfig?: boolean | undefined;
+}>;
+export type LogoutInput = z.infer<typeof LogoutInputSchema>;
+export declare const LogoutErrorCode: z.ZodEnum<["GCLOUD_NOT_FOUND", "REVOKE_FAILED", "CONFIG_CLEAR_FAILED", "UNKNOWN_ERROR"]>;
+export declare const LogoutSuccess: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+    data: z.ZodObject<{
+        userRevoked: z.ZodBoolean;
+        adcRevoked: z.ZodBoolean;
+        configCleared: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        userRevoked: boolean;
+        adcRevoked: boolean;
+        configCleared: boolean;
+    }, {
+        userRevoked: boolean;
+        adcRevoked: boolean;
+        configCleared: boolean;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: true;
+    data: {
+        userRevoked: boolean;
+        adcRevoked: boolean;
+        configCleared: boolean;
+    };
+}, {
+    success: true;
+    data: {
+        userRevoked: boolean;
+        adcRevoked: boolean;
+        configCleared: boolean;
+    };
+}>;
+export declare const LogoutFailure: z.ZodObject<{
+    success: z.ZodLiteral<false>;
+    error: z.ZodObject<{
+        code: z.ZodEnum<["GCLOUD_NOT_FOUND", "REVOKE_FAILED", "CONFIG_CLEAR_FAILED", "UNKNOWN_ERROR"]>;
+        message: z.ZodString;
+        recoverable: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        code: "UNKNOWN_ERROR" | "GCLOUD_NOT_FOUND" | "REVOKE_FAILED" | "CONFIG_CLEAR_FAILED";
+        message: string;
+        recoverable: boolean;
+    }, {
+        code: "UNKNOWN_ERROR" | "GCLOUD_NOT_FOUND" | "REVOKE_FAILED" | "CONFIG_CLEAR_FAILED";
+        message: string;
+        recoverable: boolean;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "GCLOUD_NOT_FOUND" | "REVOKE_FAILED" | "CONFIG_CLEAR_FAILED";
+        message: string;
+        recoverable: boolean;
+    };
+}, {
+    success: false;
+    error: {
+        code: "UNKNOWN_ERROR" | "GCLOUD_NOT_FOUND" | "REVOKE_FAILED" | "CONFIG_CLEAR_FAILED";
+        message: string;
+        recoverable: boolean;
+    };
+}>;
+export type LogoutResult = z.infer<typeof LogoutSuccess> | z.infer<typeof LogoutFailure>;
+export interface LogoutCommand {
+    execute(input: LogoutInput): Promise<LogoutResult>;
+}

package/dist/commands/logout/steps/ClearConfigStep.d.ts

@@ -0,0 +1,8 @@
+import { type CommandStep, type StepResult } from '../../../framework/CommandStep.js';
+import { type LogoutContext } from '../context.js';
+export declare class ClearConfigStep implements CommandStep<LogoutContext> {
+    id: string;
+    name: string;
+    shouldRun(context: LogoutContext): Promise<boolean>;
+    run(context: LogoutContext): Promise<StepResult>;
+}

package/dist/commands/logout/steps/PrepareStep.d.ts

@@ -0,0 +1,8 @@
+import { type CommandStep, type StepResult } from '../../../framework/CommandStep.js';
+import { type LogoutContext } from '../context.js';
+export declare class PrepareStep implements CommandStep<LogoutContext> {
+    id: string;
+    name: string;
+    shouldRun(context: LogoutContext): Promise<boolean>;
+    run(context: LogoutContext): Promise<StepResult>;
+}

package/dist/commands/logout/steps/RevokeAdcStep.d.ts

@@ -0,0 +1,9 @@
+import { type CommandStep, type StepResult } from '../../../framework/CommandStep.js';
+import { type LogoutContext } from '../context.js';
+export declare class RevokeAdcStep implements CommandStep<LogoutContext> {
+    id: string;
+    name: string;
+    shouldRun(context: LogoutContext): Promise<boolean>;
+    run(context: LogoutContext): Promise<StepResult>;
+    private getEnvironment;
+}

package/dist/commands/logout/steps/RevokeUserStep.d.ts

@@ -0,0 +1,9 @@
+import { type CommandStep, type StepResult } from '../../../framework/CommandStep.js';
+import { type LogoutContext } from '../context.js';
+export declare class RevokeUserStep implements CommandStep<LogoutContext> {
+    id: string;
+    name: string;
+    shouldRun(context: LogoutContext): Promise<boolean>;
+    run(context: LogoutContext): Promise<StepResult>;
+    private getEnvironment;
+}

package/dist/commands/proxy/command.d.ts

@@ -0,0 +1,2 @@
+import { type CommandDefinition } from '../../framework/CommandDefinition.js';
+export declare const command: CommandDefinition;

package/dist/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/commands/registry.d.ts

@@ -0,0 +1,2 @@
+import { type CommandDefinition } from '../framework/CommandDefinition.js';
+export declare const commands: CommandDefinition[];

package/dist/commands/screens/ScreensView.d.ts

@@ -0,0 +1,16 @@
+import type { StitchMCPClient } from '../../services/mcp-client/client.js';
+interface Screen {
+    screenId: string;
+    title: string;
+    hasCode: boolean;
+    codeUrl: string | null;
+    hasImage: boolean;
+}
+interface ScreensViewProps {
+    projectId: string;
+    projectTitle: string;
+    screens: Screen[];
+    client: StitchMCPClient;
+}
+export declare function ScreensView({ projectId, projectTitle, screens, client }: ScreensViewProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/commands/screens/command.d.ts

@@ -0,0 +1,2 @@
+import { type CommandDefinition } from '../../framework/CommandDefinition.js';
+export declare const command: CommandDefinition;