@extension.dev/mcp 3.17.0-canary.1779905934.1151df3

package/dist/module.d.ts

@@ -0,0 +1 @@
+export { startServer } from "./src/index";

package/dist/rslib.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@rslib/core").RslibConfig;
+export default _default;

package/dist/src/index.d.ts

@@ -0,0 +1 @@
+export declare function startServer(): Promise<void>;

package/dist/src/lib/act.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Run an `extension <verb> … --output json` act command and return its result
+ * JSON as a string (the MCP tool payload). The CLI prints the control-channel
+ * result frame to stdout (for ok and !ok alike); connection/no-session failures
+ * go to stderr with a non-zero exit. Either way we return a JSON object.
+ *
+ * Per lockstep invariant #1 the act tools wrap the CLI verb rather than talking
+ * to the control WS directly — so MCP behavior can never drift from the CLI.
+ */
+export declare function runActVerb(args: string[], projectPath: string, timeoutMs?: number): Promise<string>;
+/** Shared input fields for act tools. */
+export interface ActArgs {
+    projectPath: string;
+    browser?: string;
+    context?: string;
+    url?: string;
+    tab?: number;
+    timeout?: number;
+}
+/** Build the trailing CLI flags common to act verbs. */
+export declare function commonFlags(args: ActArgs): string[];

package/dist/src/lib/cdp.d.ts

@@ -0,0 +1,48 @@
+export declare class CDPClient {
+    private ws;
+    private messageId;
+    private eventListeners;
+    private pendingRequests;
+    private consoleMessages;
+    connect(wsUrl: string): Promise<void>;
+    disconnect(): void;
+    private handleMessage;
+    private rejectAllPending;
+    sendCommand(method: string, params?: Record<string, unknown>, sessionId?: string): Promise<unknown>;
+    static discoverBrowserWsUrl(port: number, host?: string): Promise<string>;
+    static discoverTargets(port: number, host?: string): Promise<Array<{
+        id: string;
+        type: string;
+        url: string;
+        title: string;
+        webSocketDebuggerUrl: string;
+    }>>;
+    getTargets(): Promise<Array<Record<string, unknown>>>;
+    attachToTarget(targetId: string): Promise<string>;
+    enableDomains(sessionId: string): Promise<void>;
+    navigate(sessionId: string, url: string): Promise<void>;
+    evaluate(sessionId: string, expression: string): Promise<unknown>;
+    getPageHTML(sessionId: string): Promise<string>;
+    getClosedShadowRoots(sessionId: string, maxBytes?: number): Promise<Array<{
+        host: string;
+        type: string;
+        html: string;
+        truncated?: boolean;
+    }>>;
+    getPageMeta(sessionId: string): Promise<Record<string, unknown>>;
+    probeSelectors(sessionId: string, selectors: string[]): Promise<Array<{
+        selector: string;
+        count: number;
+        samples: Array<Record<string, unknown>>;
+    }>>;
+    getDomSnapshot(sessionId: string, maxNodes?: number): Promise<Array<Record<string, unknown>>>;
+    getExtensionRootMeta(sessionId: string): Promise<Record<string, unknown> | null>;
+    getConsoleMessages(): Array<{
+        level: string;
+        text: string;
+        source: string;
+        timestamp: number;
+    }>;
+    getConsoleSummary(): Record<string, unknown>;
+    private onEvent;
+}

package/dist/src/lib/exec.d.ts

@@ -0,0 +1,13 @@
+import { type ChildProcess } from "node:child_process";
+export interface CliResult {
+    code: number | null;
+    stdout: string;
+    stderr: string;
+}
+export declare function runExtensionCli(args: string[], options?: {
+    cwd?: string;
+    timeoutMs?: number;
+}): Promise<CliResult>;
+export declare function spawnExtensionCli(args: string[], options?: {
+    cwd?: string;
+}): ChildProcess;

package/dist/src/lib/process-manager.d.ts

@@ -0,0 +1,5 @@
+import type { ProcessInfo } from "./types";
+export declare function registerSession(info: ProcessInfo): void;
+export declare function getSession(projectPath: string, browser: string): ProcessInfo | undefined;
+export declare function removeSession(projectPath: string, browser: string): void;
+export declare function listSessions(): ProcessInfo[];

package/dist/src/lib/templates-cache.d.ts

@@ -0,0 +1,11 @@
+import type { TemplatesMetaV2, TemplateMeta } from "./types";
+export declare function fetchTemplatesMeta(): Promise<TemplatesMetaV2>;
+export interface TemplateFilters {
+    surface?: string;
+    framework?: string;
+    tags?: string[];
+    featured?: boolean;
+    query?: string;
+}
+export declare function listTemplates(filters?: TemplateFilters): Promise<TemplateMeta[]>;
+export declare function getTemplateBySlug(slug: string): Promise<TemplateMeta | undefined>;

package/dist/src/lib/types.d.ts

@@ -0,0 +1,68 @@
+export interface TemplateMeta {
+    slug: string;
+    name: string;
+    title?: string;
+    version: string;
+    manifest_version: number;
+    description: string;
+    uiContext: string[];
+    surfaces: string[];
+    entrypoints: string[];
+    uiFramework: string;
+    css: string;
+    configFiles: string[];
+    hasBackground: boolean;
+    hasEnv: boolean;
+    permissions: string[];
+    host_permissions: string[];
+    optional_permissions: string[];
+    featured: boolean;
+    tags?: string[];
+    difficulty?: "beginner" | "intermediate" | "advanced";
+    timeToFirstSuccessMinutes?: number;
+    firstSteps?: string[];
+    useCases?: string[];
+    docsUrl?: string;
+    files: string[];
+    browsers: string[];
+    screenshot: string | null;
+    icon: string | null;
+    downloads?: Record<string, string>;
+    repositoryUrl?: string;
+    aiPromptExamples?: string[];
+    aiRecommendFor?: string[];
+    patternExplanation?: string;
+    keyFiles?: string[];
+}
+export interface TemplatesMetaV2 {
+    version: "2";
+    sourceRepo: string;
+    generatorVersion: string;
+    commit: string;
+    generatedAt: string;
+    templates: TemplateMeta[];
+}
+export interface ReadyContract {
+    status: "ready" | "error";
+    message?: string;
+    errors?: string[];
+    code?: string;
+    command: "dev" | "start";
+    browser: string;
+    runId?: string;
+    startedAt?: string;
+    distPath?: string;
+    manifestPath?: string;
+    port?: number | null;
+    pid?: number;
+    ts?: string;
+    compiledAt?: string | null;
+}
+export interface ProcessInfo {
+    pid: number;
+    browser: string;
+    port?: number;
+    projectPath: string;
+    command: "dev" | "start";
+}
+export type BrowserType = "chrome" | "edge" | "firefox" | "chromium-based" | "gecko-based";

package/dist/src/tools/add-feature.d.ts

@@ -0,0 +1,29 @@
+export declare const schema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            projectPath: {
+                type: string;
+                description: string;
+            };
+            feature: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            framework: {
+                type: string;
+                enum: string[];
+                default: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handler(args: {
+    projectPath: string;
+    feature: string;
+    framework?: string;
+}): Promise<string>;

package/dist/src/tools/build.d.ts

@@ -0,0 +1,36 @@
+export declare const schema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            projectPath: {
+                type: string;
+                description: string;
+            };
+            browser: {
+                type: string;
+                enum: string[];
+                default: string;
+                description: string;
+            };
+            zip: {
+                type: string;
+                default: boolean;
+                description: string;
+            };
+            zipSource: {
+                type: string;
+                default: boolean;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handler(args: {
+    projectPath: string;
+    browser?: string;
+    zip?: boolean;
+    zipSource?: boolean;
+}): Promise<string>;

package/dist/src/tools/create.d.ts

@@ -0,0 +1,29 @@
+export declare const schema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            projectName: {
+                type: string;
+                description: string;
+            };
+            template: {
+                type: string;
+                default: string;
+                description: string;
+            };
+            install: {
+                type: string;
+                default: boolean;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handler(args: {
+    projectName: string;
+    template?: string;
+    install?: boolean;
+}): Promise<string>;

package/dist/src/tools/detect-browsers.d.ts

@@ -0,0 +1,20 @@
+export declare const schema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            browsers: {
+                type: string;
+                items: {
+                    type: string;
+                    enum: string[];
+                };
+                description: string;
+            };
+        };
+    };
+};
+export declare function handler(args: {
+    browsers?: string[];
+}): Promise<string>;

package/dist/src/tools/dev.d.ts

@@ -0,0 +1,34 @@
+export declare const schema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            projectPath: {
+                type: string;
+                description: string;
+            };
+            browser: {
+                type: string;
+                enum: string[];
+                default: string;
+            };
+            port: {
+                type: string;
+                description: string;
+            };
+            noBrowser: {
+                type: string;
+                default: boolean;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handler(args: {
+    projectPath: string;
+    browser?: string;
+    port?: number;
+    noBrowser?: boolean;
+}): Promise<string>;

package/dist/src/tools/dom-inspect.d.ts

@@ -0,0 +1,56 @@
+import { type ActArgs } from "../lib/act";
+export declare const schema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            projectPath: {
+                type: string;
+                description: string;
+            };
+            tab: {
+                type: string;
+                description: string;
+            };
+            context: {
+                type: string;
+                enum: string[];
+                default: string;
+                description: string;
+            };
+            include: {
+                type: string;
+                items: {
+                    type: string;
+                    enum: string[];
+                };
+                default: string[];
+                description: string;
+            };
+            maxBytes: {
+                type: string;
+                default: number;
+            };
+            withConsole: {
+                type: string;
+                description: string;
+            };
+            browser: {
+                type: string;
+                default: string;
+            };
+            timeout: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handler(args: ActArgs & {
+    tab?: number;
+    include?: string[];
+    maxBytes?: number;
+    withConsole?: number;
+}): Promise<string>;

package/dist/src/tools/eval.d.ts

@@ -0,0 +1,44 @@
+import { type ActArgs } from "../lib/act";
+export declare const schema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            projectPath: {
+                type: string;
+                description: string;
+            };
+            expression: {
+                type: string;
+                description: string;
+            };
+            context: {
+                type: string;
+                enum: string[];
+                default: string;
+                description: string;
+            };
+            url: {
+                type: string;
+                description: string;
+            };
+            tab: {
+                type: string;
+                description: string;
+            };
+            browser: {
+                type: string;
+                default: string;
+            };
+            timeout: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handler(args: ActArgs & {
+    expression: string;
+}): Promise<string>;

package/dist/src/tools/get-template-source.d.ts

@@ -0,0 +1,25 @@
+export declare const schema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            slug: {
+                type: string;
+                description: string;
+            };
+            files: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handler(args: {
+    slug: string;
+    files?: string[];
+}): Promise<string>;

package/dist/src/tools/inspect.d.ts

@@ -0,0 +1,29 @@
+export declare const schema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            projectPath: {
+                type: string;
+                description: string;
+            };
+            browser: {
+                type: string;
+                default: string;
+                description: string;
+            };
+            format: {
+                type: string;
+                enum: string[];
+                default: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handler(args: {
+    projectPath: string;
+    browser?: string;
+    format?: string;
+}): Promise<string>;

package/dist/src/tools/install-browser.d.ts

@@ -0,0 +1,18 @@
+export declare const schema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            browser: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handler(args: {
+    browser: string;
+}): Promise<string>;

package/dist/src/tools/list-browsers.d.ts

@@ -0,0 +1,9 @@
+export declare const schema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {};
+    };
+};
+export declare function handler(): Promise<string>;

package/dist/src/tools/list-templates.d.ts

@@ -0,0 +1,41 @@
+export declare const schema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            surface: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            framework: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            tags: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            featured: {
+                type: string;
+                description: string;
+            };
+            query: {
+                type: string;
+                description: string;
+            };
+        };
+    };
+};
+export declare function handler(args: {
+    surface?: string;
+    framework?: string;
+    tags?: string[];
+    featured?: boolean;
+    query?: string;
+}): Promise<string>;

package/dist/src/tools/logs.d.ts

@@ -0,0 +1,80 @@
+export declare const schema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            projectPath: {
+                type: string;
+                description: string;
+            };
+            browser: {
+                type: string;
+                default: string;
+                description: string;
+            };
+            level: {
+                type: string;
+                enum: string[];
+                default: string;
+                description: string;
+            };
+            context: {
+                type: string;
+                items: {
+                    type: string;
+                    enum: string[];
+                };
+                description: string;
+            };
+            signalsOnly: {
+                type: string;
+                default: boolean;
+                description: string;
+            };
+            since: {
+                type: string;
+                description: string;
+            };
+            url: {
+                type: string;
+                description: string;
+            };
+            tab: {
+                type: string;
+                description: string;
+            };
+            follow: {
+                type: string;
+                default: boolean;
+                description: string;
+            };
+            followMs: {
+                type: string;
+                default: number;
+                description: string;
+            };
+            limit: {
+                type: string;
+                default: number;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+interface LogsArgs {
+    projectPath: string;
+    browser?: string;
+    level?: string;
+    context?: string[] | string;
+    signalsOnly?: boolean;
+    since?: number;
+    url?: string;
+    tab?: number;
+    follow?: boolean;
+    followMs?: number;
+    limit?: number;
+}
+export declare function handler(args: LogsArgs): Promise<string>;
+export {};

package/dist/src/tools/manifest-validate.d.ts

@@ -0,0 +1,26 @@
+export declare const schema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            manifestPath: {
+                type: string;
+                description: string;
+            };
+            browsers: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                default: string[];
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handler(args: {
+    manifestPath: string;
+    browsers?: string[];
+}): Promise<string>;