webflow-mcp 0.3.0

package/.webflow/flows/_template/index.ts

@@ -0,0 +1,14 @@
+// export const capabilities = {
+//   browser: true,
+//   category: 'pick-a-sector-from-taxonomy.json',
+//   service: 'pick-a-service-under-that-sector',
+//   requiresLogin: false
+// };
+
+export async function run(ctx: { flowName: string; profile: { id: string; dir: string } }, input: { message: string }) {
+  return {
+    flow: ctx.flowName,
+    profile: ctx.profile.id,
+    echoed: input.message
+  };
+}

package/.webflow/flows/_template/schema.json

@@ -0,0 +1,11 @@
+{
+  "type": "object",
+  "description": "Template input schema for a WebFlow flow.",
+  "properties": {
+    "message": {
+      "type": "string",
+      "description": "Message to echo from the flow."
+    }
+  },
+  "required": ["message"]
+}

package/.webflow/skills/README.md

@@ -0,0 +1,3 @@
+# WebFlow Skills
+
+Place local project skills here.

package/README.md

@@ -0,0 +1,215 @@
+# WebFlow MCP
+
+Local worker and unified MCP gateway for the WebFlowMCP signed remote automation catalog. A legacy
+local-authoring mode can still discover `.webflow/flows/*` and expose each valid flow directly.
+
+## Requirements
+
+- Node 20+
+- npm 10+
+
+## Install
+
+```bash
+npm install
+npm run build
+```
+
+For an installed package:
+
+```bash
+npm install -g webflow-mcp
+webflow login
+```
+
+`webflow login` creates a worker-only credential locally and opens the dashboard for browser approval.
+It never asks for the separate MCP token.
+
+## Unified MCP gateway
+
+Normal SaaS use configures one local MCP. It provides worker lifecycle, browser preferences, profile
+administration and signed-flow approvals locally, while proxying catalog and execution calls to the relay.
+
+OpenCode example:
+
+```jsonc
+{
+  "mcp": {
+    "webflow": {
+      "type": "local",
+      "command": ["webflow-mcp"],
+      "environment": {
+        "WEBFLOW_RELAY_MCP_URL": "https://relay.webflowmcp.es/mcp",
+        "WEBFLOW_RELAY_MCP_TOKEN": "{env:WEBFLOW_MCP_TOKEN}"
+      }
+    }
+  }
+}
+```
+
+Set `WEBFLOW_MCP_TOKEN` outside a checked-in project config to the `tok_...` value created in the
+dashboard. The MCP token authenticates only `/mcp`; the background worker uses its independent
+browser-paired `wkr_...` credential. Start and stop the worker through `start_worker`/`stop_worker`.
+
+Gateway mode exposes a stable catalog surface rather than one dynamic tool per saved flow. Discover with
+`browse_catalog`/`search_flows`, inspect with `describe_flow`, and execute saved flows with
+`run_flow_with_options`.
+
+## CLI
+
+```bash
+webflow init
+webflow create flow checkout
+webflow fork checkout checkout-copy
+```
+
+The workspace contract is:
+
+```text
+.webflow/
+  flows/
+    _template/
+    <flow>/
+      schema.json
+      index.ts
+  skills/
+```
+
+Provider profiles are machine-global under `~/.webflow/profiles/`; they are not part of a workspace.
+
+## Authoring a flow
+
+Each flow must export `run(ctx, input)` from `index.ts` and define a supported JSON-schema subset in `schema.json`:
+
+```ts
+export async function run(ctx, input) {
+  return { flow: ctx.flowName, echoed: input.message };
+}
+```
+
+Supported schema keys: `type`, `properties`, `required`, `items`, `enum`, `description`, `default`.
+
+## Legacy local-authoring MCP
+
+The `projectRoot` argument is the absolute path to **the repo you are working in** — it decides where downloads land. The flows themselves do not need to live there: if `projectRoot` has no `.webflow/flows`, the server automatically uses the flows shipped with this package (Model B). So a single flows repo serves many working repos, and each repo keeps its own outputs.
+
+During development from this repo:
+
+```bash
+node --import tsx src/mcp/cli.ts /absolute/path/to/your-working-repo
+```
+
+Or after building:
+
+```bash
+npm run build
+node dist/src/mcp/cli.js /absolute/path/to/your-working-repo
+```
+
+For MCP client configuration **from another repo**, point the entrypoint at this package and the argument at that repo. Flows come from here; downloads stay in that repo:
+
+```json
+{
+  "mcpServers": {
+    "webflow": {
+      "command": "node",
+      "args": [
+        "C:/absolute/path/to/webflow-mcp/dist/src/mcp/cli.js",
+        "C:/absolute/path/to/your-other-repo"
+      ]
+    }
+  }
+}
+```
+
+To override where flows are loaded from, set `WEBFLOW_FLOWS_DIR` to a workspace that has `.webflow/flows`. The server falls back to `CLAUDE_PROJECT_DIR` then `cwd` when no argument is given, and prints which flows root, session store, and downloads dir it resolved as startup diagnostics.
+
+On Windows, `run-mcp.bat` is only a local helper. It requires `npm run build` first and expects the workspace root as its first argument:
+
+```bat
+run-mcp.bat C:\absolute\path\to\workspace
+```
+
+## Doctor
+
+Use `doctor` before wiring MCP from another repo:
+
+```bash
+webflow doctor /absolute/path/to/workspace
+node dist/src/cli/index.js doctor /absolute/path/to/workspace
+```
+
+`doctor` checks Node, the workspace layout, exposed flows, parseable schemas, build output, Playwright/Chromium availability, and warns about fragile flow patterns such as fixed CDP port `9222`, `taskkill`, `Profile 1`, `process.cwd()`, hardcoded Windows paths, or `connectOverCDP`.
+
+## Sessions vs downloads
+
+Two things are deliberately decoupled:
+
+- **Login sessions are global.** Chrome profiles live in one shared store, default `~/.webflow/profiles` (override with `WEBFLOW_PROFILES_DIR`). Log in once and every workspace reuses the session — you do not re-authenticate per repo.
+- **Downloads are per-repo.** Each flow writes to `<projectRoot>/.webflow/downloads/<flow>/...`, so outputs are organized by the workspace you ran from. Point the MCP server's `projectRoot` at a repo and that repo collects its own downloads while sharing the global login.
+
+The MCP server prints both locations as diagnostics on startup.
+
+## Browser Flow Setup
+
+Run `webflow setup <flow>` once per profile to log in. By default this opens a **plain real Chrome window with no automation flags**, pointed at the flow's dedicated global profile. Log in, accept any prompts, then close the window — the session persists and is reused by automated runs. This avoids the "unsafe browser" block that strict providers raise against automation-controlled login windows.
+
+```bash
+webflow setup chatgpt-prompt
+webflow setup google-speech-generate --url https://aistudio.google.com
+```
+
+Flows share a profile by declaring the same `capabilities.profile` (for example `chatgpt-prompt` and `chatgpt-image-generate` both use `chatgpt`), so one login covers the whole provider.
+
+### Browser modes
+
+A flow declares how it drives the browser via `capabilities.browser`:
+
+- `true` / `'managed'` — Playwright-managed persistent profile (default). Clean, isolated, works headless from any repo. Used by ChatGPT, Gemini app, X, and the scrapers.
+- `'cdp'` — the runner attaches to a real Chrome over CDP. Used by strict providers (`google-speech-generate` for Google AI Studio, `adobe-lipsync`). The runner launches Chrome against the dedicated profile on a free port, connects, and **closes that window when the flow finishes** (it owns what it launched). If you instead attach to a Chrome you already had open via `cdpUrl`, it only disconnects and leaves your window alone. Optional per-run overrides: `cdpUrl`, `chromePath`, `userDataDir`.
+
+Flows consume `ctx.page`/`ctx.browser` and are mode-agnostic, so switching a flow between `managed` and `cdp` needs no code changes.
+
+### Verifying whether a strict provider can use the managed profile
+
+`'cdp'` is the proven path for AI Studio/Adobe; the managed profile is unverified there. To test whether managed + one-time login is enough (and unify on a single mechanism), run a `cdp` flow once with:
+
+```bash
+# PowerShell:  $env:WEBFLOW_CDP_AS_MANAGED = '1'
+WEBFLOW_CDP_AS_MANAGED=1 webflow run google-speech-generate --headed --input '{ ... }'
+```
+
+If the provider accepts the login, switch that flow's `capabilities.browser` to `'managed'`. If it rejects, leave it on `'cdp'`.
+
+### Running multiple agents in parallel
+
+A Chrome user-data-dir can be opened by only one process at a time, so parallel agents cannot share one profile directory. Set `WEBFLOW_PROFILE_INSTANCE=<id>` per agent: the runner clones the logged-in base profile into a per-instance directory on first use. Off by default (a single agent reuses the shared base profile). Note that some providers may then ask the extra session to re-verify as a new device.
+
+### Signed remote flows
+
+Official relays send immutable Ed25519-signed flow releases. The worker verifies the relay-bound public
+key, manifest and exact code/schema/capability hashes before importing any code. Every new flow digest
+also requires an explicit local decision. Through the unified MCP, call `list_flow_approvals`, inspect the
+full digest/signer/trust domain, ask the user, and then call `approve_flow_update` with the exact returned
+identity and `confirmed:true`. The interactive CLI remains available:
+
+```bash
+webflow approvals list
+webflow approvals approve <flow> --trust-domain <domain>
+webflow approvals revoke <flow> --trust-domain <domain>
+```
+
+The remote relay cannot approve a release; MCP approval tools mutate only worker-local state. Their
+`confirmed:true` argument is a user-interaction convention, while typing `APPROVE` in the CLI remains the
+stronger manual path. Flow source is not installed as a local catalog, but code
+executed on a user-controlled computer cannot be made impossible for that computer's owner to capture.
+Signed code still has the worker process's OS permissions; this release does not add a sandbox.
+Signing keys and release commands are operator-only; end users never generate or manage signing keys.
+
+## Verification
+
+```bash
+npm test
+npm run smoke
+npm pack --dry-run --json
+```

package/dist/src/anti-block/provider-gate.d.ts

@@ -0,0 +1,19 @@
+export type ProviderSignal = 'ok' | 'blocked' | 'verification_required' | 'rate_limited' | 'page_not_found' | 'unknown';
+export interface AntiBlockPolicy {
+    provider?: string;
+    minIntervalMs?: number;
+    openAfterFailures?: number;
+    cooldownMs?: number;
+    tripOnPageNotFound?: boolean;
+}
+export declare function deriveProviderKey(flowName: string, capabilities?: {
+    service?: string;
+    profile?: string;
+    startUrl?: string;
+    antiBlock?: AntiBlockPolicy;
+}): string;
+export declare function classifyProviderSignal(error: unknown, tripOnPageNotFound?: boolean): ProviderSignal;
+export declare class ProviderGate {
+    enter(provider: string, policy?: AntiBlockPolicy): Promise<() => void>;
+    record(provider: string, signal: ProviderSignal, policy?: AntiBlockPolicy): Promise<void>;
+}

package/dist/src/anti-block/provider-gate.js

@@ -0,0 +1,116 @@
+import { resolve } from 'node:path';
+import { ensureDir, readJsonFile, writeJsonFile } from '../shared/fs.js';
+import { getAntiBlockDir, sanitizeName } from '../shared/paths.js';
+import { WebFlowError } from '../shared/errors.js';
+const DEFAULT_POLICY = {
+    minIntervalMs: 5_000,
+    openAfterFailures: 2,
+    cooldownMs: 10 * 60_000
+};
+const queues = new Map();
+function statePath(provider) {
+    return resolve(getAntiBlockDir(), `${sanitizeName(provider)}.json`);
+}
+async function readState(provider) {
+    try {
+        const value = await readJsonFile(statePath(provider));
+        return {
+            lastAttemptAt: Number(value.lastAttemptAt) || 0,
+            consecutiveFailures: Number(value.consecutiveFailures) || 0,
+            cooldownUntil: Number(value.cooldownUntil) || 0,
+            lastSignal: typeof value.lastSignal === 'string' ? value.lastSignal : 'unknown'
+        };
+    }
+    catch {
+        return { lastAttemptAt: 0, consecutiveFailures: 0, cooldownUntil: 0, lastSignal: 'unknown' };
+    }
+}
+async function writeState(provider, state) {
+    await ensureDir(getAntiBlockDir());
+    await writeJsonFile(statePath(provider), { provider, ...state, updatedAt: new Date().toISOString() });
+}
+function sleep(ms) {
+    return new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
+}
+export function deriveProviderKey(flowName, capabilities) {
+    if (capabilities?.antiBlock?.provider)
+        return sanitizeName(capabilities.antiBlock.provider);
+    if (capabilities?.service)
+        return sanitizeName(capabilities.service);
+    if (capabilities?.profile)
+        return sanitizeName(capabilities.profile);
+    if (capabilities?.startUrl && capabilities.startUrl !== 'about:blank') {
+        try {
+            return sanitizeName(new URL(capabilities.startUrl).hostname);
+        }
+        catch { /* fall through */ }
+    }
+    return sanitizeName(flowName);
+}
+export function classifyProviderSignal(error, tripOnPageNotFound = false) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/\[VERIFICATION_REQUIRED\]|verify you are human|checking your browser/i.test(message))
+        return 'verification_required';
+    if (/\[RATE_LIMITED\]|too many requests|rate limit|\b429\b/i.test(message))
+        return 'rate_limited';
+    if (/\[BLOCKED\]|captcha|access denied|cloudflare|datadome|actividad inusual|unusual traffic|just a moment/i.test(message))
+        return 'blocked';
+    if (tripOnPageNotFound && /\[PAGE_NOT_FOUND\]/i.test(message))
+        return 'page_not_found';
+    return 'unknown';
+}
+export class ProviderGate {
+    async enter(provider, policy = {}) {
+        const key = sanitizeName(provider);
+        const previous = queues.get(key) ?? Promise.resolve();
+        let releaseQueue = () => { };
+        const current = new Promise((resolvePromise) => { releaseQueue = resolvePromise; });
+        const queued = previous.catch(() => undefined).then(() => current);
+        queues.set(key, queued);
+        await previous.catch(() => undefined);
+        try {
+            const state = await readState(key);
+            const now = Date.now();
+            if (state.cooldownUntil > now) {
+                throw new WebFlowError('PROVIDER_COOLDOWN', `Provider "${key}" is cooling down until ${new Date(state.cooldownUntil).toISOString()}.`, {
+                    provider: key,
+                    retryAfter: new Date(state.cooldownUntil).toISOString(),
+                    lastSignal: state.lastSignal
+                });
+            }
+            const interval = Math.max(0, policy.minIntervalMs ?? DEFAULT_POLICY.minIntervalMs);
+            if (state.lastAttemptAt && now - state.lastAttemptAt < interval)
+                await sleep(interval - (now - state.lastAttemptAt));
+            await writeState(key, { ...state, lastAttemptAt: Date.now() });
+        }
+        catch (error) {
+            releaseQueue();
+            if (queues.get(key) === queued)
+                queues.delete(key);
+            throw error;
+        }
+        return () => {
+            releaseQueue();
+            if (queues.get(key) === queued)
+                queues.delete(key);
+        };
+    }
+    async record(provider, signal, policy = {}) {
+        const key = sanitizeName(provider);
+        const state = await readState(key);
+        if (signal === 'ok') {
+            await writeState(key, { ...state, consecutiveFailures: 0, cooldownUntil: 0, lastSignal: 'ok' });
+            return;
+        }
+        if (signal === 'unknown')
+            return;
+        const failures = state.consecutiveFailures + 1;
+        const threshold = Math.max(1, policy.openAfterFailures ?? DEFAULT_POLICY.openAfterFailures);
+        await writeState(key, {
+            ...state,
+            consecutiveFailures: failures,
+            cooldownUntil: failures >= threshold ? Date.now() + Math.max(1_000, policy.cooldownMs ?? DEFAULT_POLICY.cooldownMs) : 0,
+            lastSignal: signal
+        });
+    }
+}

package/dist/src/cli/commands/approvals.d.ts

@@ -0,0 +1,5 @@
+export type ApprovalConfirmer = (message: string) => Promise<void>;
+export declare function formatApprovalState(json?: boolean): Promise<string>;
+export declare function confirmApprovalInTerminal(message: string, isInteractive?: boolean): Promise<void>;
+export declare function approveFlow(flowName: string, trustDomain?: string, confirmer?: ApprovalConfirmer): Promise<string>;
+export declare function revokeFlow(flowName: string, trustDomain?: string, confirmer?: ApprovalConfirmer): Promise<string>;

package/dist/src/cli/commands/approvals.js

@@ -0,0 +1,69 @@
+import { createInterface } from 'node:readline/promises';
+import { approvePending, listApprovals, listPending, revokeApproval } from '../../security/flow-approvals.js';
+import { WebFlowError } from '../../shared/errors.js';
+export async function formatApprovalState(json = false) {
+    const [approved, pending] = await Promise.all([listApprovals(), listPending()]);
+    if (json)
+        return JSON.stringify({ approved, pending }, null, 2);
+    const lines = [
+        ...pending.map((entry) => `PENDING  ${entry.flowName}  ${entry.version}  ${entry.flowDigest.slice(0, 16)}...  ${entry.trustDomain}`),
+        ...approved.map((entry) => `APPROVED ${entry.flowName}  ${entry.version}  ${entry.flowDigest.slice(0, 16)}...  ${entry.trustDomain}`)
+    ];
+    return lines.length ? lines.join('\n') : 'No signed flow approvals or pending updates.';
+}
+export async function confirmApprovalInTerminal(message, isInteractive = Boolean(process.stdin.isTTY && process.stdout.isTTY)) {
+    if (!isInteractive) {
+        throw new WebFlowError('INTERACTIVE_CONFIRMATION_REQUIRED', 'Flow approval requires an interactive local terminal.');
+    }
+    const prompt = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await prompt.question(`${message}\nType APPROVE to continue: `);
+        if (answer !== 'APPROVE')
+            throw new WebFlowError('APPROVAL_CANCELLED', 'Flow approval was cancelled.');
+    }
+    finally {
+        prompt.close();
+    }
+}
+export async function approveFlow(flowName, trustDomain, confirmer = confirmApprovalInTerminal) {
+    const matches = (await listPending()).filter((entry) => entry.flowName === flowName && (!trustDomain || entry.trustDomain === trustDomain));
+    if (matches.length === 0)
+        throw new WebFlowError('FLOW_APPROVAL_NOT_FOUND', `No pending signed update found for flow "${flowName}".`);
+    if (matches.length > 1)
+        throw new WebFlowError('FLOW_APPROVAL_AMBIGUOUS', `Specify --trust-domain for flow "${flowName}".`);
+    const pending = matches[0];
+    await confirmer([
+        `Approve signed flow update "${pending.flowName}"?`,
+        `Version: ${pending.version}`,
+        `Digest: ${pending.flowDigest}`,
+        `Signer: ${pending.keyId}`,
+        `Trust domain: ${pending.trustDomain}`
+    ].join('\n'));
+    const latest = (await listPending()).find((entry) => entry.flowName === pending.flowName && entry.trustDomain === pending.trustDomain);
+    if (!latest || latest.flowDigest !== pending.flowDigest || latest.releaseId !== pending.releaseId) {
+        throw new WebFlowError('FLOW_APPROVAL_CHANGED', 'The pending signed update changed during confirmation; inspect and approve it again.');
+    }
+    const approved = await approvePending(flowName, pending.trustDomain, {
+        flowDigest: pending.flowDigest,
+        releaseId: pending.releaseId,
+        sequence: pending.sequence
+    });
+    return `Approved ${approved.flowName} ${approved.version} (${approved.flowDigest.slice(0, 16)}...).`;
+}
+export async function revokeFlow(flowName, trustDomain, confirmer = confirmApprovalInTerminal) {
+    const matches = (await listApprovals()).filter((entry) => entry.flowName === flowName && (!trustDomain || entry.trustDomain === trustDomain));
+    if (matches.length === 0)
+        return `No approval found for ${flowName}.`;
+    if (matches.length > 1)
+        throw new WebFlowError('FLOW_APPROVAL_AMBIGUOUS', `Specify --trust-domain for flow "${flowName}".`);
+    const approval = matches[0];
+    await confirmer([
+        `Revoke local approval for flow "${approval.flowName}"?`,
+        `Version: ${approval.version}`,
+        `Digest: ${approval.flowDigest}`,
+        `Signer: ${approval.keyId}`,
+        `Trust domain: ${approval.trustDomain}`
+    ].join('\n'));
+    const removed = await revokeApproval(flowName, approval.trustDomain);
+    return removed ? `Revoked approval for ${flowName}.` : `No approval found for ${flowName}.`;
+}

package/dist/src/cli/commands/config.d.ts

@@ -0,0 +1,4 @@
+import { type WebflowConfig } from '../../config/webflow-config.js';
+export declare function formatConfig(config: WebflowConfig): string;
+export declare function getConfig(): Promise<WebflowConfig>;
+export declare function setConfigPreference(kind: string | undefined, scope: string | undefined, nameOrValue: string | undefined, maybeValue?: string): Promise<WebflowConfig>;

package/dist/src/cli/commands/config.js

@@ -0,0 +1,56 @@
+import { loadConfig, setDefaultBrowserMode, setDefaultBrowserVisibility, setFlowBrowserMode, setFlowBrowserVisibility } from '../../config/webflow-config.js';
+import { WebFlowError } from '../../shared/errors.js';
+function isBrowserVisibility(value) {
+    return value === 'visible' || value === 'hidden';
+}
+function isDefaultBrowserVisibility(value) {
+    return value === 'inherit' || isBrowserVisibility(value);
+}
+function isBrowserMode(value) {
+    return value === 'managed' || value === 'cdp';
+}
+function isDefaultBrowserMode(value) {
+    return value === 'inherit' || isBrowserMode(value);
+}
+export function formatConfig(config) {
+    return [
+        'WebFlow config',
+        `Browser visibility default: ${config.browserVisibility.default}`,
+        `Browser visibility per-flow: ${Object.keys(config.browserVisibility.flows).length ? JSON.stringify(config.browserVisibility.flows) : '(none)'}`,
+        `Browser mode default: ${config.browserMode.default}`,
+        `Browser mode per-flow: ${Object.keys(config.browserMode.flows).length ? JSON.stringify(config.browserMode.flows) : '(none)'}`
+    ].join('\n');
+}
+export async function getConfig() {
+    return loadConfig();
+}
+export async function setConfigPreference(kind, scope, nameOrValue, maybeValue) {
+    if (kind !== 'browser-mode' && kind !== 'browser-visibility') {
+        throw new WebFlowError('INVALID_COMMAND', 'Usage: webflow config <get|browser-mode|browser-visibility> ...');
+    }
+    if (scope !== 'default' && scope !== 'flow') {
+        throw new WebFlowError('INVALID_COMMAND', `Usage: webflow config ${kind} <default|flow> ...`);
+    }
+    if (kind === 'browser-visibility') {
+        if (scope === 'default') {
+            if (!isDefaultBrowserVisibility(nameOrValue)) {
+                throw new WebFlowError('INVALID_COMMAND', 'Browser visibility default must be one of: inherit, visible, hidden.');
+            }
+            return setDefaultBrowserVisibility(nameOrValue);
+        }
+        if (!nameOrValue || !isDefaultBrowserVisibility(maybeValue)) {
+            throw new WebFlowError('INVALID_COMMAND', 'Usage: webflow config browser-visibility flow <flow> <inherit|visible|hidden>');
+        }
+        return setFlowBrowserVisibility(nameOrValue, maybeValue === 'inherit' ? null : maybeValue);
+    }
+    if (scope === 'default') {
+        if (!isDefaultBrowserMode(nameOrValue)) {
+            throw new WebFlowError('INVALID_COMMAND', 'Browser mode default must be one of: inherit, managed, cdp.');
+        }
+        return setDefaultBrowserMode(nameOrValue);
+    }
+    if (!nameOrValue || !isDefaultBrowserMode(maybeValue)) {
+        throw new WebFlowError('INVALID_COMMAND', 'Usage: webflow config browser-mode flow <flow> <inherit|managed|cdp>');
+    }
+    return setFlowBrowserMode(nameOrValue, maybeValue === 'inherit' ? null : maybeValue);
+}

package/dist/src/cli/commands/create-flow.d.ts

@@ -0,0 +1,4 @@
+export declare function createFlow(projectRoot: string, name: string): Promise<{
+    name: string;
+    dir: string;
+}>;

package/dist/src/cli/commands/create-flow.js

@@ -0,0 +1,27 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { ensureDir, pathExists } from '../../shared/fs.js';
+import { WebFlowError } from '../../shared/errors.js';
+import { getWorkspacePaths, sanitizeName } from '../../shared/paths.js';
+export async function createFlow(projectRoot, name) {
+    const sanitizedName = sanitizeName(name);
+    const paths = getWorkspacePaths(projectRoot);
+    const templateDir = resolve(paths.flowsDir, '_template');
+    const flowDir = resolve(paths.flowsDir, sanitizedName);
+    if (!(await pathExists(templateDir))) {
+        throw new WebFlowError('WORKSPACE_NOT_INITIALIZED', 'Run `webflow init` before creating flows.');
+    }
+    if (await pathExists(flowDir)) {
+        throw new WebFlowError('FLOW_ALREADY_EXISTS', `Flow "${sanitizedName}" already exists.`);
+    }
+    await ensureDir(flowDir);
+    const [schemaTemplate, indexTemplate] = await Promise.all([
+        readFile(resolve(templateDir, 'schema.json'), 'utf8'),
+        readFile(resolve(templateDir, 'index.ts'), 'utf8')
+    ]);
+    await Promise.all([
+        writeFile(resolve(flowDir, 'schema.json'), schemaTemplate.replace(/Template input schema/g, `${sanitizedName} flow input schema`), 'utf8'),
+        writeFile(resolve(flowDir, 'index.ts'), indexTemplate.replace(/ctx.flowName/g, JSON.stringify(sanitizedName)), 'utf8')
+    ]);
+    return { name: sanitizedName, dir: flowDir };
+}

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

@@ -0,0 +1,19 @@
+export type DoctorLevel = 'ok' | 'warn' | 'error';
+export interface DoctorCheck {
+    level: DoctorLevel;
+    message: string;
+}
+export interface DoctorResult {
+    projectRoot: string;
+    checks: DoctorCheck[];
+    exposedFlows: string[];
+    invalidFlows: string[];
+    exitCode: number;
+}
+export interface DoctorOptions {
+    nodeVersion?: string;
+    checkPlaywright?: boolean;
+    packageRoot?: string;
+}
+export declare function runDoctor(projectRoot: string, options?: DoctorOptions): Promise<DoctorResult>;
+export declare function formatDoctorResult(result: DoctorResult): string;