@leafwright/mcp 0.2.0

package/README.md

@@ -0,0 +1,179 @@
+# @leafwright/mcp
+
+The official [Leafwright](https://leafwright.co) MCP server. It gives an AI
+coding agent (Claude Code, Cursor, Codex, and any MCP client) the ability to
+**generate PDFs, build templates, and debug failed renders from their logs** —
+all through the Leafwright public API.
+
+No headless Chrome, no Puppeteer in your bundle. The agent calls a tool, gets a
+real signed PDF URL back.
+
+## Connect from claude.ai (remote, no install)
+
+Leafwright also runs as a remote MCP server with OAuth. In claude.ai →
+Settings → Connectors → **Add custom connector**, enter:
+
+- **Name**: Leafwright
+- **Remote MCP server URL**: `https://leafwright.co/mcp`
+
+Leave the OAuth fields empty — the connector registers itself and opens a
+browser window where you sign in and pick an organization and default project.
+Works with any MCP client that supports OAuth 2.1 + PKCE and Dynamic Client
+Registration.
+
+## Install (local stdio)
+
+Nothing to install — run it with `npx`:
+
+```sh
+npx -y @leafwright/mcp
+```
+
+Start the server without credentials, then call `leafwright_login` from your
+agent. Open the returned verification URL, sign in, choose an organization and
+default project, then call `leafwright_auth_status`.
+
+Project API keys are still supported for server automation:
+
+```sh
+LEAFWRIGHT_API_KEY=lw_live_...
+```
+
+Get an account at [leafwright.co](https://leafwright.co).
+
+## Configure your client
+
+**Claude Code** (`~/.claude/mcp.json` or project `.mcp.json`), **Cursor**
+(`~/.cursor/mcp.json`), and **Codex** all use the same shape:
+
+```json
+{
+  "mcpServers": {
+    "leafwright": {
+      "command": "npx",
+      "args": ["-y", "@leafwright/mcp"],
+      "env": {}
+    }
+  }
+}
+```
+
+Restart the client. Before login, only auth/help tools appear; after browser
+auth, the full `leafwright_*` tool set appears.
+
+## Environment
+
+| Variable | Required | Default | Purpose |
+| --- | --- | --- | --- |
+| `LEAFWRIGHT_API_KEY` | no | — | Backward-compatible project API key (`lw_live_…` or `lw_test_…`). |
+| `LEAFWRIGHT_MCP_TOKEN` | no | — | MCP token (`mcp_…`) for non-interactive setups. |
+| `LEAFWRIGHT_PROJECT_ID` | no | selected project | Override the active default project. |
+| `LEAFWRIGHT_MCP_READ_ONLY` | no | `false` | `true` exposes only read tools — no renders, no template writes, no AI. |
+
+## Tools
+
+**Auth and context:**
+
+| Tool | What it does |
+| --- | --- |
+| `leafwright_login` | Start browser login. |
+| `leafwright_auth_status` | Complete/check browser login. |
+| `leafwright_logout` | Revoke and clear local MCP auth. |
+| `leafwright_list_organizations` | List the selected token's organization. |
+| `leafwright_list_projects` | List projects in the selected organization. |
+| `leafwright_select_project` | Set the local active project. |
+
+**Read (available after auth, no side effects):**
+
+| Tool | What it does |
+| --- | --- |
+| `leafwright_list_templates` | List the project's templates. |
+| `leafwright_get_template` | Fetch one template (draft HTML/CSS, sample data, versions). |
+| `leafwright_validate_template` | Validate a template / draft overrides before rendering. |
+| `leafwright_get_job` | Render job status and metadata. |
+| `leafwright_get_job_logs` | Render logs — failed assets, fonts, timeouts, overflow. |
+| `leafwright_get_usage` | Credits used/remaining for the billing period. |
+| `leafwright_estimate_usage_cost` | Estimate credits and overage cost for a planned batch of renders. |
+
+**Write (hidden when `LEAFWRIGHT_MCP_READ_ONLY=true`):**
+
+| Tool | What it does |
+| --- | --- |
+| `leafwright_render_html` | Render raw HTML → PDF (signed URL). |
+| `leafwright_render_url` | Render a public URL → PDF (SSRF-protected). |
+| `leafwright_render_template` | Render a published template with JSON data. |
+| `leafwright_create_template` | Create a draft template. |
+| `leafwright_update_template_draft` | Update a draft's HTML/CSS/name/sample data. |
+| `leafwright_ai_generate_template` | Generate a draft template from a prompt. |
+| `leafwright_ai_revise_template` | Revise a draft from a natural-language instruction. |
+| `leafwright_ai_fix_from_logs` | **Repair a template from a failed render's logs.** |
+
+## HTML rules
+
+Leafwright validates all HTML before rendering — the same rules apply to
+`leafwright_render_html`, template create/update, and validation.
+
+**Supported**
+
+- Full documents: doctype, `<html>`, `<head>`, `<meta>`, `<title>`, `<body>`,
+  and `<style>` blocks.
+- Text, heading, list, table, and layout tags (`div`, `section`, `header`,
+  `footer`, `main`, `article`, `figure`).
+- `<img>` with base64 data URIs (`data:image/png`, `jpeg`, `gif`, `webp`, or
+  `svg+xml`), relative paths, or `cid:` references.
+- `class`, `style`, `id`, standard layout/table/meta/image attributes, and
+  `aria-*` / `data-*`.
+- Handlebars placeholders like `{{customer.name}}` in templates.
+
+**Rejected**
+
+- `<script>`, `<iframe>`, `<object>`, `<embed>`, `<form>`, `<link>`, and inline
+  event handlers.
+- Inline `<svg>` markup (`svg`, `path`, `rect`, `g`, and the rest of the SVG
+  element family). Encode the SVG as a **base64** data URI and reference it
+  from an `<img>` instead — URL-encoded SVG data URIs are rejected:
+
+  ```html
+  <img src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0i..." alt="Logo">
+  ```
+
+- SVG in CSS `url()` backgrounds — use an `<img>` element instead.
+- External http(s) URLs in `src` attributes or CSS `url()` — the renderer never
+  fetches remote assets for HTML sources. Embed images as data URIs instead.
+- CSS `@import`.
+
+Size limits: HTML 250 KB, CSS 120 KB, up to 200 pages per PDF. To render a
+public web page *with* its remote assets, use `leafwright_render_url`, which
+fetches the page behind SSRF protections.
+
+## Prompts
+
+Ready-made workflows your client can invoke: `create_invoice_template`,
+`create_report_template`, `create_template_from_prompt`, `debug_pdf_layout`,
+`explain_render_failure`, `integrate_nextjs`, `migrate_from_puppeteer`.
+
+## Resources
+
+`leafwright://docs` (API quickstart), `leafwright://templates` (your
+templates), `leafwright://usage` (current usage), `leafwright://jobs/recent`
+(the 20 most recent render jobs), `leafwright://jobs/{jobId}/logs` (logs for a
+specific job).
+
+## The debugging loop
+
+A code-only agent can't see its PDF. This server closes that loop:
+
+1. Agent renders a template → it fails or looks wrong.
+2. Agent calls `leafwright_get_job_logs` → reads the real cause.
+3. Agent calls `leafwright_ai_fix_from_logs` → gets a fix, re-renders, confirms.
+
+## Safety
+
+The server only calls the Leafwright public API. It runs no shell commands from
+agent input, stores MCP tokens in the OS keychain when possible, falls back to a
+permission-restricted config file, and supports read-only mode. AI **drafts**
+templates; publishing always requires a human in the dashboard.
+
+## License
+
+MIT · [leafwright.co](https://leafwright.co)

package/leafwright-tools.md

@@ -0,0 +1,70 @@
+# Leafwright MCP Tools
+
+The runnable stdio MCP server lives at `mcp/server.mjs` and ships as
+`@leafwright/mcp`. See `README.md` for setup. Full reference below.
+
+## Auth and context tools
+
+- `leafwright_login`: start a browser login and return a verification URL.
+- `leafwright_auth_status`: check or complete browser login.
+- `leafwright_logout`: revoke and clear local MCP auth.
+- `leafwright_list_organizations`: list the token's selected organization.
+- `leafwright_list_projects`: list available projects in that organization.
+- `leafwright_select_project`: set the local active project.
+
+## Read tools (available after auth)
+
+- `leafwright_list_templates`: list project templates.
+- `leafwright_get_template`: fetch one template (draft HTML/CSS, sample data, versions).
+- `leafwright_validate_template`: validate a template or draft override.
+- `leafwright_get_job`: fetch render job status and metadata.
+- `leafwright_get_job_logs`: fetch render logs for debugging.
+- `leafwright_get_usage`: credits used/remaining for the billing period.
+- `leafwright_estimate_usage_cost`: estimate credits and overage cost for a
+  planned batch of renders.
+
+## Write tools (hidden when `LEAFWRIGHT_MCP_READ_ONLY=true`)
+
+- `leafwright_render_html`: render raw HTML to PDF.
+- `leafwright_render_url`: render a public URL to PDF after SSRF checks.
+- `leafwright_render_template`: render a published template with JSON data.
+- `leafwright_create_template`: create a draft template.
+- `leafwright_update_template_draft`: update a draft's HTML/CSS/name/sample data.
+- `leafwright_ai_generate_template`: create an AI-assisted draft template.
+- `leafwright_ai_revise_template`: revise a draft from an instruction (preview or apply).
+- `leafwright_ai_fix_from_logs`: repair a draft from a failed render's logs.
+
+## HTML rules
+
+The same validation applies to `leafwright_render_html`, template
+create/update, and validation. Full documents are supported (doctype, `html`,
+`head`, `meta`, `title`, `body`, `style`) along with text, table, and layout
+tags. Images must be base64 data URIs (`png`, `jpeg`, `gif`, `webp`, or
+`svg+xml`), relative paths, or `cid:` references. Rejected: `<script>`,
+`<iframe>`, `<object>`, `<embed>`, `<form>`, `<link>`, inline `<svg>` markup
+(base64-encode the SVG into an `<img>` data URI instead — URL-encoded SVG
+data URIs are also rejected), SVG in CSS `url()`, inline event handlers,
+external http(s) asset URLs, and CSS `@import`/external `url()`. Limits:
+HTML 250 KB, CSS 120 KB, 200 pages per PDF. The `leafwright://docs` resource
+carries the full list.
+
+## Prompts
+
+`create_invoice_template`, `create_report_template`, `create_template_from_prompt`,
+`debug_pdf_layout`, `explain_render_failure`, `integrate_nextjs`,
+`migrate_from_puppeteer`.
+
+## Resources
+
+`leafwright://docs`, `leafwright://templates`, `leafwright://usage`,
+`leafwright://jobs/recent`, `leafwright://jobs/{jobId}/logs`.
+
+## Environment
+
+- `LEAFWRIGHT_API_KEY`: optional backward-compatible project API key.
+- `LEAFWRIGHT_MCP_TOKEN`: optional non-interactive MCP token.
+- `LEAFWRIGHT_PROJECT_ID`: optional active project override.
+- `LEAFWRIGHT_MCP_READ_ONLY`: optional, `true` exposes read tools only.
+
+Do not pass API keys or MCP tokens through tool arguments. Prefer browser auth
+with `leafwright_login`; MCP clients inject env credentials only for automation.

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@leafwright/mcp",
+  "version": "0.2.0",
+  "description": "Model Context Protocol server for Leafwright — let your AI coding agent generate, template, and debug PDFs.",
+  "type": "module",
+  "bin": {
+    "leafwright-mcp": "./server.mjs"
+  },
+  "main": "server.mjs",
+  "files": [
+    "server.mjs",
+    "README.md",
+    "leafwright-tools.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "start": "node server.mjs"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.3.6"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "pdf",
+    "html-to-pdf",
+    "leafwright",
+    "claude",
+    "cursor",
+    "ai-agent",
+    "puppeteer-alternative"
+  ],
+  "homepage": "https://leafwright.co",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Tactic-Systems/leafwright.git",
+    "directory": "mcp"
+  },
+  "bugs": {
+    "url": "https://github.com/Tactic-Systems/leafwright/issues"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/server.mjs

@@ -0,0 +1,1099 @@
+#!/usr/bin/env node
+
+import { execFileSync } from "node:child_process";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import * as z from "zod/v4";
+
+const DEFAULT_BASE_URL = "https://leafwright.co";
+const KEYCHAIN_SERVICE = "leafwright-mcp";
+const KEYCHAIN_ACCOUNT = "default";
+const CONFIG_PATH = join(homedir(), ".config", "leafwright", "mcp-auth.json");
+const runtimeStorage = new AsyncLocalStorage();
+let runtimeOverrides = {};
+
+function currentRuntimeOverrides() {
+  return runtimeStorage.getStore() ?? runtimeOverrides;
+}
+
+export function runWithLeafwrightMcpRuntime(options, callback) {
+  return runtimeStorage.run(options ?? {}, callback);
+}
+
+function readJsonFile(path) {
+  try {
+    if (!existsSync(path)) {
+      return null;
+    }
+
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function writeJsonFile(path, value) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(value, null, 2), { mode: 0o600 });
+}
+
+function readKeychainToken() {
+  if (process.platform !== "darwin") {
+    return null;
+  }
+
+  try {
+    return execFileSync("security", [
+      "find-generic-password",
+      "-s",
+      KEYCHAIN_SERVICE,
+      "-a",
+      KEYCHAIN_ACCOUNT,
+      "-w"
+    ], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+function writeKeychainToken(token) {
+  if (process.platform !== "darwin") {
+    return false;
+  }
+
+  try {
+    execFileSync("security", [
+      "add-generic-password",
+      "-U",
+      "-s",
+      KEYCHAIN_SERVICE,
+      "-a",
+      KEYCHAIN_ACCOUNT,
+      "-w",
+      token
+    ], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function deleteKeychainToken() {
+  if (process.platform !== "darwin") {
+    return;
+  }
+
+  try {
+    execFileSync("security", [
+      "delete-generic-password",
+      "-s",
+      KEYCHAIN_SERVICE,
+      "-a",
+      KEYCHAIN_ACCOUNT
+    ], { stdio: "ignore" });
+  } catch {
+    // Missing keychain entry is fine.
+  }
+}
+
+function readStoredAuth() {
+  const fileAuth = readJsonFile(CONFIG_PATH) ?? {};
+  const keychainToken = readKeychainToken();
+
+  return {
+    ...fileAuth,
+    accessToken: keychainToken || fileAuth.accessToken || null,
+    tokenStorage: keychainToken ? "keychain" : fileAuth.accessToken ? "file" : null
+  };
+}
+
+function writeStoredAuth(auth) {
+  if (
+    currentRuntimeOverrides().disableLocalStorage ||
+    process.env.LEAFWRIGHT_MCP_DISABLE_LOCAL_AUTH === "true"
+  ) {
+    return;
+  }
+
+  const stored = {
+    ...readStoredAuth(),
+    ...auth,
+    updatedAt: new Date().toISOString()
+  };
+
+  if (stored.accessToken && writeKeychainToken(stored.accessToken)) {
+    const { accessToken: _accessToken, ...fileValue } = stored;
+    writeJsonFile(CONFIG_PATH, fileValue);
+    return;
+  }
+
+  writeJsonFile(CONFIG_PATH, stored);
+}
+
+function clearStoredAuth() {
+  if (
+    currentRuntimeOverrides().disableLocalStorage ||
+    process.env.LEAFWRIGHT_MCP_DISABLE_LOCAL_AUTH === "true"
+  ) {
+    return;
+  }
+
+  deleteKeychainToken();
+
+  try {
+    unlinkSync(CONFIG_PATH);
+  } catch {
+    // Missing config file is fine.
+  }
+}
+
+function config() {
+  const overrides = currentRuntimeOverrides();
+  const disableLocalStorage =
+    overrides.disableLocalStorage || process.env.LEAFWRIGHT_MCP_DISABLE_LOCAL_AUTH === "true";
+  const stored = disableLocalStorage ? {} : readStoredAuth();
+  const apiKey = overrides.apiKey ?? process.env.LEAFWRIGHT_API_KEY ?? null;
+  const mcpToken =
+    overrides.mcpToken ?? process.env.LEAFWRIGHT_MCP_TOKEN ?? stored.accessToken ?? null;
+  const bearerToken = overrides.bearerToken ?? apiKey ?? mcpToken;
+
+  return {
+    apiKey,
+    mcpToken,
+    bearerToken,
+    tokenSource: overrides.tokenSource || (apiKey
+      ? "api_key_env"
+      : process.env.LEAFWRIGHT_MCP_TOKEN
+        ? "mcp_token_env"
+        : stored.accessToken
+          ? stored.tokenStorage || "stored"
+          : bearerToken
+            ? "bearer"
+            : null),
+    baseUrl: (overrides.baseUrl || process.env.LEAFWRIGHT_API_BASE_URL || DEFAULT_BASE_URL).replace(/\/$/, ""),
+    readOnly: overrides.readOnly ?? process.env.LEAFWRIGHT_MCP_READ_ONLY === "true",
+    activeProjectId:
+      overrides.activeProjectId ||
+      process.env.LEAFWRIGHT_PROJECT_ID ||
+      stored.activeProjectId ||
+      stored.token?.defaultProjectId ||
+      null
+  };
+}
+
+function isAuthenticated() {
+  return Boolean(config().bearerToken);
+}
+
+async function leafwrightRequest(path, init = {}) {
+  const { bearerToken, baseUrl } = config();
+
+  if (!bearerToken) {
+    throw new Error("Leafwright MCP is not authenticated. Run leafwright_login first.");
+  }
+
+  const response = await fetch(`${baseUrl}${path}`, {
+    ...init,
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${bearerToken}`,
+      ...init.headers
+    }
+  });
+  const text = await response.text();
+  const payload = text ? JSON.parse(text) : {};
+
+  if (!response.ok) {
+    const message =
+      payload?.error?.message || payload?.message || `Leafwright request failed: ${response.status}`;
+    const error = new Error(message);
+    error.status = response.status;
+    error.payload = payload;
+    throw error;
+  }
+
+  return payload;
+}
+
+async function anonymousLeafwrightRequest(path, init = {}) {
+  const { baseUrl } = config();
+  const response = await fetch(`${baseUrl}${path}`, {
+    ...init,
+    headers: {
+      "content-type": "application/json",
+      ...init.headers
+    }
+  });
+  const text = await response.text();
+  const payload = text ? JSON.parse(text) : {};
+
+  if (!response.ok) {
+    const message =
+      payload?.error?.message || payload?.message || `Leafwright request failed: ${response.status}`;
+    const error = new Error(message);
+    error.status = response.status;
+    error.payload = payload;
+    throw error;
+  }
+
+  return payload;
+}
+
+function withProjectBody(body = {}, explicitProjectId) {
+  const projectId = explicitProjectId || config().activeProjectId;
+
+  return projectId ? { ...body, project_id: projectId } : body;
+}
+
+function withProjectQuery(path, explicitProjectId) {
+  const projectId = explicitProjectId || config().activeProjectId;
+
+  if (!projectId) {
+    return path;
+  }
+
+  const separator = path.includes("?") ? "&" : "?";
+  return `${path}${separator}project_id=${encodeURIComponent(projectId)}`;
+}
+
+function toolResult(payload) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+    structuredContent: payload
+  };
+}
+
+function toolError(error) {
+  const payload = {
+    error: {
+      message: error instanceof Error ? error.message : "Leafwright MCP tool failed.",
+      status: typeof error?.status === "number" ? error.status : undefined,
+      details: error?.payload?.error?.details ?? error?.payload?.error ?? undefined
+    }
+  };
+
+  return {
+    isError: true,
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+    structuredContent: payload
+  };
+}
+
+function tool(run) {
+  return async (args) => {
+    try {
+      return toolResult(await run(args ?? {}));
+    } catch (error) {
+      return toolError(error);
+    }
+  };
+}
+
+function registerAuthTools(server, ensureFullTools) {
+  server.registerTool(
+    "leafwright_login",
+    {
+      title: "Log in to Leafwright",
+      description:
+        "Start a browser login flow for Leafwright MCP. Open the returned URL, choose an organization and project, then call leafwright_auth_status.",
+      inputSchema: {
+        client_name: z.string().optional().describe("Optional client name shown in Leafwright.")
+      },
+      annotations: { destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    tool(async ({ client_name }) => {
+      const started = await anonymousLeafwrightRequest("/api/v1/mcp/auth/start", {
+        method: "POST",
+        body: JSON.stringify({ client_name: client_name || "Leafwright MCP" })
+      });
+
+      writeStoredAuth({
+        pendingDeviceCode: started.device_code,
+        pendingUserCode: started.user_code,
+        pendingExpiresAt: started.expires_at,
+        baseUrl: config().baseUrl
+      });
+
+      return {
+        status: "pending",
+        verification_url: started.verification_url,
+        user_code: started.user_code,
+        expires_at: started.expires_at,
+        next_step:
+          "Open verification_url, approve access, then call leafwright_auth_status."
+      };
+    })
+  );
+
+  server.registerTool(
+    "leafwright_auth_status",
+    {
+      title: "Leafwright auth status",
+      description: "Check whether Leafwright MCP is authenticated. Completes a pending browser login if approved.",
+      inputSchema: {},
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    tool(async () => {
+      const current = config();
+
+      if (current.bearerToken) {
+        ensureFullTools();
+        return {
+          status: "connected",
+          token_source: current.tokenSource,
+          active_project_id: current.activeProjectId
+        };
+      }
+
+      const stored =
+        currentRuntimeOverrides().disableLocalStorage ||
+        process.env.LEAFWRIGHT_MCP_DISABLE_LOCAL_AUTH === "true"
+          ? {}
+          : readStoredAuth();
+
+      if (!stored.pendingDeviceCode) {
+        return {
+          status: "not_authenticated",
+          next_step: "Call leafwright_login to start browser authentication."
+        };
+      }
+
+      const tokenResponse = await anonymousLeafwrightRequest("/api/v1/mcp/auth/token", {
+        method: "POST",
+        body: JSON.stringify({ device_code: stored.pendingDeviceCode })
+      }).catch((error) => {
+        if (error.status === 202) {
+          return error.payload;
+        }
+
+        throw error;
+      });
+
+      if (tokenResponse.status === "pending") {
+        return {
+          status: "pending",
+          user_code: stored.pendingUserCode,
+          expires_at: tokenResponse.expires_at || stored.pendingExpiresAt
+        };
+      }
+
+      writeStoredAuth({
+        accessToken: tokenResponse.access_token,
+        token: tokenResponse.token,
+        activeProjectId: tokenResponse.token?.defaultProjectId,
+        pendingDeviceCode: null,
+        pendingUserCode: null,
+        pendingExpiresAt: null
+      });
+      ensureFullTools();
+
+      return {
+        status: "connected",
+        token: tokenResponse.token,
+        active_project_id: tokenResponse.token?.defaultProjectId
+      };
+    })
+  );
+
+  server.registerTool(
+    "leafwright_logout",
+    {
+      title: "Log out of Leafwright",
+      description: "Revoke the stored Leafwright MCP token and clear local auth state.",
+      inputSchema: {},
+      annotations: { destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    tool(async () => {
+      const { bearerToken, mcpToken } = config();
+
+      if (mcpToken || bearerToken?.startsWith("mcp_")) {
+        await leafwrightRequest("/api/v1/mcp/auth/revoke", { method: "POST" }).catch(() => null);
+      }
+
+      clearStoredAuth();
+
+      return {
+        status: "logged_out"
+      };
+    })
+  );
+}
+
+function registerContextTools(server) {
+  server.registerTool(
+    "leafwright_list_organizations",
+    {
+      title: "List Leafwright organizations",
+      description: "List organizations available to the authenticated Leafwright MCP token.",
+      inputSchema: {},
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    tool(() => leafwrightRequest("/api/v1/mcp/context", { method: "GET" }))
+  );
+
+  server.registerTool(
+    "leafwright_list_projects",
+    {
+      title: "List Leafwright projects",
+      description: "List projects available to the authenticated Leafwright MCP token.",
+      inputSchema: {},
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    tool(async () => {
+      const context = await leafwrightRequest("/api/v1/mcp/context", { method: "GET" });
+
+      return {
+        data: context.projects ?? context.data?.projects ?? []
+      };
+    })
+  );
+
+  server.registerTool(
+    "leafwright_select_project",
+    {
+      title: "Select active Leafwright project",
+      description: "Set the local default project for future project-scoped MCP tool calls.",
+      inputSchema: {
+        project_id: z.string().min(1).describe("Project ID to use as the local active project.")
+      },
+      annotations: { destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    tool(async ({ project_id }) => {
+      const context = await leafwrightRequest("/api/v1/mcp/context", { method: "GET" });
+      const projects = context.projects ?? context.data?.projects ?? [];
+      const project = projects.find((candidate) => candidate.id === project_id);
+
+      if (!project) {
+        throw new Error("Project is not available to this MCP token.");
+      }
+
+      writeStoredAuth({ activeProjectId: project.id });
+
+      return {
+        active_project_id: project.id,
+        project
+      };
+    })
+  );
+}
+
+function registerReadTools(server) {
+  server.registerTool(
+    "leafwright_list_templates",
+    {
+      title: "List templates",
+      description: "List templates available to the active Leafwright project.",
+      inputSchema: { project_id: z.string().optional().describe("Optional project override.") },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    tool(({ project_id }) => leafwrightRequest(withProjectQuery("/api/v1/templates", project_id), { method: "GET" }))
+  );
+
+  server.registerTool(
+    "leafwright_get_template",
+    {
+      title: "Get template",
+      description: "Fetch a single template, including its draft HTML/CSS, sample data, and published versions.",
+      inputSchema: { template_id: z.string().min(1).describe("Template ID.") },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    tool(({ template_id }) =>
+      leafwrightRequest(`/api/v1/templates/${encodeURIComponent(template_id)}`, { method: "GET" })
+    )
+  );
+
+  server.registerTool(
+    "leafwright_validate_template",
+    {
+      title: "Validate template",
+      description:
+        "Validate a template (optionally with draft HTML/CSS/sample-data overrides) before rendering. Validation errors state which tag, attribute, or URL was rejected and what to use instead; the leafwright://docs resource lists the full HTML rules.",
+      inputSchema: {
+        template_id: z.string().min(1).describe("Template ID."),
+        html: z.string().optional().describe("Optional draft HTML override."),
+        css: z.string().optional().describe("Optional draft CSS override."),
+        sample_data: z.record(z.string(), z.unknown()).optional().describe("Optional sample data override.")
+      },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    tool(({ template_id, html, css, sample_data }) =>
+      leafwrightRequest(`/api/v1/templates/${encodeURIComponent(template_id)}/validate`, {
+        method: "POST",
+        body: JSON.stringify({ html, css, sample_data })
+      })
+    )
+  );
+
+  server.registerTool(
+    "leafwright_get_job",
+    {
+      title: "Get render job",
+      description: "Fetch render job status and metadata (pages, credits used, file size, duration).",
+      inputSchema: { job_id: z.string().min(1).describe("Render job ID.") },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    tool(({ job_id }) =>
+      leafwrightRequest(`/api/v1/jobs/${encodeURIComponent(job_id)}`, { method: "GET" })
+    )
+  );
+
+  server.registerTool(
+    "leafwright_get_job_logs",
+    {
+      title: "Get render job logs",
+      description:
+        "Fetch render logs for a job. Use this to debug a failed or wrong-looking render.",
+      inputSchema: { job_id: z.string().min(1).describe("Render job ID.") },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    tool(({ job_id }) =>
+      leafwrightRequest(`/api/v1/jobs/${encodeURIComponent(job_id)}/logs`, { method: "GET" })
+    )
+  );
+
+  server.registerTool(
+    "leafwright_get_usage",
+    {
+      title: "Get usage and credits",
+      description: "Get current billing-period usage for the active project.",
+      inputSchema: { project_id: z.string().optional().describe("Optional project override.") },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    tool(({ project_id }) => leafwrightRequest(withProjectQuery("/api/v1/usage", project_id), { method: "GET" }))
+  );
+
+  server.registerTool(
+    "leafwright_estimate_usage_cost",
+    {
+      title: "Estimate usage cost",
+      description:
+        "Estimate credit usage and overage cost for a planned batch of renders against the active project's plan and current billing period.",
+      inputSchema: {
+        renders: z.number().int().min(1).describe("Number of planned renders."),
+        pages_per_render: z
+          .number()
+          .int()
+          .min(1)
+          .optional()
+          .describe("Expected pages per rendered document. Defaults to 1."),
+        project_id: z.string().optional().describe("Optional project override.")
+      },
+      annotations: { readOnlyHint: true, openWorldHint: true }
+    },
+    tool(({ renders, pages_per_render, project_id }) => {
+      const params = new URLSearchParams({ renders: String(renders) });
+
+      if (pages_per_render !== undefined) {
+        params.set("pages_per_render", String(pages_per_render));
+      }
+
+      return leafwrightRequest(withProjectQuery(`/api/v1/usage/estimate?${params}`, project_id), {
+        method: "GET"
+      });
+    })
+  );
+}
+
+const HTML_RULES =
+  "Full HTML documents are supported: doctype, html, head, meta, title, body, style, plus text, layout, table, and img tags. Rejected: <script>, <iframe>, <object>, <embed>, <form>, <link>, inline <svg> markup, inline event handlers, and external http(s) asset URLs. Embed images — including SVGs — as base64 data URIs in <img> src (data:image/png, jpeg, gif, webp, or svg+xml;base64,...), relative paths, or cid: references. CSS must not use @import or external url().";
+
+function registerWriteTools(server) {
+  server.registerTool(
+    "leafwright_render_html",
+    {
+      title: "Render HTML to PDF",
+      description:
+        `Render raw HTML into a PDF. Returns job metadata and a signed download URL for sync renders. ${HTML_RULES}`,
+      inputSchema: {
+        html: z.string().min(1).describe("Raw HTML to render. Follows the HTML rules in the tool description."),
+        filename: z.string().optional().describe("Optional output filename."),
+        async: z.boolean().optional().describe("Queue the render instead of waiting for completion."),
+        project_id: z.string().optional().describe("Optional project override.")
+      },
+      annotations: { destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    tool(({ html, filename, async = false, project_id }) =>
+      leafwrightRequest("/api/v1/pdfs", {
+        method: "POST",
+        body: JSON.stringify(withProjectBody({
+          source: { type: "html", html },
+          filename,
+          delivery: { mode: async ? "async" : "sync", return: "url" }
+        }, project_id))
+      })
+    )
+  );
+
+  server.registerTool(
+    "leafwright_render_url",
+    {
+      title: "Render URL to PDF",
+      description: "Render a public HTTP(S) URL into a PDF. Leafwright applies SSRF protections before rendering.",
+      inputSchema: {
+        url: z.string().url().describe("Public HTTP(S) URL to render."),
+        filename: z.string().optional().describe("Optional output filename."),
+        async: z.boolean().optional().describe("Queue the render instead of waiting for completion."),
+        project_id: z.string().optional().describe("Optional project override.")
+      },
+      annotations: { destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    tool(({ url, filename, async = false, project_id }) =>
+      leafwrightRequest("/api/v1/pdfs", {
+        method: "POST",
+        body: JSON.stringify(withProjectBody({
+          source: { type: "url", url },
+          filename,
+          delivery: { mode: async ? "async" : "sync", return: "url" }
+        }, project_id))
+      })
+    )
+  );
+
+  server.registerTool(
+    "leafwright_render_template",
+    {
+      title: "Render template",
+      description: "Render a published Leafwright template with JSON data.",
+      inputSchema: {
+        template_id: z.string().min(1).describe("Published template ID."),
+        data: z.record(z.string(), z.unknown()).optional().describe("Template data object."),
+        filename: z.string().optional().describe("Optional output filename."),
+        template_version_id: z.string().optional().describe("Optional template version ID.")
+      },
+      annotations: { destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    tool(({ template_id, data, filename, template_version_id }) =>
+      leafwrightRequest(`/api/v1/templates/${encodeURIComponent(template_id)}/render`, {
+        method: "POST",
+        body: JSON.stringify({ data, filename, template_version_id })
+      })
+    )
+  );
+
+  server.registerTool(
+    "leafwright_create_template",
+    {
+      title: "Create template",
+      description: "Create a new draft template. Drafts are not published; publishing requires a human in the dashboard.",
+      inputSchema: {
+        name: z.string().min(1).describe("Template name."),
+        html: z.string().optional().describe("Draft HTML (Handlebars supported). Follows the HTML rules in the leafwright://docs resource."),
+        css: z.string().optional().describe("Draft CSS."),
+        sample_data: z.record(z.string(), z.unknown()).optional().describe("Sample data."),
+        project_id: z.string().optional().describe("Optional project override.")
+      },
+      annotations: { destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    tool(({ name, html, css, sample_data, project_id }) =>
+      leafwrightRequest("/api/v1/templates", {
+        method: "POST",
+        body: JSON.stringify(withProjectBody({ name, html, css, sample_data }, project_id))
+      })
+    )
+  );
+
+  server.registerTool(
+    "leafwright_update_template_draft",
+    {
+      title: "Update template draft",
+      description: "Update a template's draft HTML, CSS, name, or sample data.",
+      inputSchema: {
+        template_id: z.string().min(1).describe("Template ID."),
+        name: z.string().optional().describe("New template name."),
+        html: z.string().optional().describe("New draft HTML. Follows the HTML rules in the leafwright://docs resource."),
+        css: z.string().optional().describe("New draft CSS."),
+        sample_data: z.record(z.string(), z.unknown()).optional().describe("New sample data.")
+      },
+      annotations: { destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    tool(({ template_id, name, html, css, sample_data }) =>
+      leafwrightRequest(`/api/v1/templates/${encodeURIComponent(template_id)}`, {
+        method: "PATCH",
+        body: JSON.stringify({ name, html, css, sample_data })
+      })
+    )
+  );
+
+  server.registerTool(
+    "leafwright_ai_generate_template",
+    {
+      title: "AI generate template",
+      description: "Create an AI-assisted template draft from a prompt.",
+      inputSchema: {
+        prompt: z.string().min(1).describe("Template generation instructions."),
+        document_type: z.string().optional().describe("Document type."),
+        sample_data: z.record(z.string(), z.unknown()).optional().describe("Sample data."),
+        name: z.string().optional().describe("Optional template name."),
+        project_id: z.string().optional().describe("Optional project override.")
+      },
+      annotations: { destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    tool(({ prompt, document_type, sample_data, name, project_id }) =>
+      leafwrightRequest("/api/v1/templates/ai/generate", {
+        method: "POST",
+        body: JSON.stringify(withProjectBody({ prompt, document_type, sample_data, name }, project_id))
+      })
+    )
+  );
+
+  server.registerTool(
+    "leafwright_ai_revise_template",
+    {
+      title: "AI revise template",
+      description: "Revise a template's draft from a natural-language instruction.",
+      inputSchema: {
+        template_id: z.string().min(1).describe("Template ID."),
+        instruction: z.string().min(1).describe("What to change."),
+        apply: z.boolean().optional().describe("Apply the revision to the draft.")
+      },
+      annotations: { destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    tool(({ template_id, instruction, apply }) =>
+      leafwrightRequest(`/api/v1/templates/${encodeURIComponent(template_id)}/ai/revise`, {
+        method: "POST",
+        body: JSON.stringify({ instruction, apply })
+      })
+    )
+  );
+
+  server.registerTool(
+    "leafwright_ai_fix_from_logs",
+    {
+      title: "AI fix template from render logs",
+      description: "Repair a template's draft using the render logs of a failed or wrong-looking job.",
+      inputSchema: {
+        template_id: z.string().min(1).describe("Template ID to repair."),
+        job_id: z.string().min(1).describe("Render job ID whose logs explain the failure."),
+        apply: z.boolean().optional().describe("Apply the fix to the draft.")
+      },
+      annotations: { destructiveHint: false, idempotentHint: false, openWorldHint: true }
+    },
+    tool(({ template_id, job_id, apply }) =>
+      leafwrightRequest(`/api/v1/templates/${encodeURIComponent(template_id)}/ai/fix-from-logs`, {
+        method: "POST",
+        body: JSON.stringify({ job_id, apply })
+      })
+    )
+  );
+}
+
+const DOCS_TEXT = `# Leafwright MCP
+
+Run leafwright_login to authenticate in a browser, choose an organization and a
+default project, then call leafwright_auth_status after approval.
+
+Existing LEAFWRIGHT_API_KEY and LEAFWRIGHT_MCP_TOKEN environment variables are
+still supported for automation.
+
+## HTML rules
+
+Leafwright validates all HTML before rendering. The same rules apply to
+leafwright_render_html, template create/update, and template validation.
+
+Supported:
+- Full documents: doctype, html, head, meta, title, body, and <style> blocks.
+- Text, heading, list, table, and layout tags (div, section, header, footer,
+  main, article, figure).
+- <img> with base64 data URIs (data:image/png, jpeg, gif, webp, or svg+xml),
+  relative paths, or cid: references.
+- class, style, id, and standard layout/table/meta/image attributes, plus
+  aria-* and data-*.
+- Handlebars placeholders like {{customer.name}} in templates.
+
+Rejected:
+- <script>, <iframe>, <object>, <embed>, <form>, <link>, and inline event
+  handlers (onclick and similar).
+- Inline <svg> markup (svg, path, rect, g, and the rest of the SVG element
+  family). Encode the SVG as a base64 data URI and reference it from an
+  <img> src instead: <img src="data:image/svg+xml;base64,...">. The data URI
+  must be base64 — URL-encoded SVG data URIs are rejected.
+- SVG in CSS url() backgrounds — use an <img> element instead.
+- External http(s) URLs in src attributes or CSS url() — the renderer never
+  fetches remote assets for HTML sources. Embed images as data URIs instead.
+- CSS @import.
+
+Size limits: HTML 250 KB, CSS 120 KB, up to 200 pages per PDF.
+
+To render an existing public web page with its remote assets, use
+leafwright_render_url instead — that path fetches the page with SSRF
+protections.`;
+
+function registerDocsResource(server) {
+  server.registerResource(
+    "leafwright-docs",
+    "leafwright://docs",
+    {
+      title: "Leafwright MCP quickstart",
+      description: "How to authenticate and use Leafwright MCP.",
+      mimeType: "text/markdown"
+    },
+    async (uri) => ({
+      contents: [{ uri: uri.href, mimeType: "text/markdown", text: DOCS_TEXT }]
+    })
+  );
+}
+
+function registerAuthenticatedResources(server) {
+  server.registerResource(
+    "leafwright-templates",
+    "leafwright://templates",
+    {
+      title: "Project templates",
+      description: "Templates available to the active project.",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      const data = await leafwrightRequest(withProjectQuery("/api/v1/templates"), { method: "GET" });
+      return { contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify(data, null, 2) }] };
+    }
+  );
+
+  server.registerResource(
+    "leafwright-usage",
+    "leafwright://usage",
+    {
+      title: "Current usage",
+      description: "Credits used and remaining for the active project.",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      const data = await leafwrightRequest(withProjectQuery("/api/v1/usage"), { method: "GET" });
+      return { contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify(data, null, 2) }] };
+    }
+  );
+
+  server.registerResource(
+    "leafwright-recent-jobs",
+    "leafwright://jobs/recent",
+    {
+      title: "Recent render jobs",
+      description: "The most recent render jobs for the active project.",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      const data = await leafwrightRequest(withProjectQuery("/api/v1/jobs?limit=20"), { method: "GET" });
+      return { contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify(data, null, 2) }] };
+    }
+  );
+
+  server.registerResource(
+    "leafwright-job-logs",
+    new ResourceTemplate("leafwright://jobs/{jobId}/logs", { list: undefined }),
+    {
+      title: "Render job logs",
+      description: "Render logs for a specific job, useful for debugging failures.",
+      mimeType: "application/json"
+    },
+    async (uri, { jobId }) => {
+      const data = await leafwrightRequest(`/api/v1/jobs/${encodeURIComponent(jobId)}/logs`, {
+        method: "GET"
+      });
+      return { contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify(data, null, 2) }] };
+    }
+  );
+}
+
+function userPrompt(text) {
+  return { messages: [{ role: "user", content: { type: "text", text } }] };
+}
+
+function registerPrompts(server) {
+  server.registerPrompt(
+    "create_invoice_template",
+    {
+      title: "Create an invoice template",
+      description: "Generate a clean invoice template with Leafwright AI.",
+      argsSchema: { details: z.string().optional().describe("Line items, fields, branding notes, etc.") }
+    },
+    ({ details }) =>
+      userPrompt(
+        `Create a professional invoice template in Leafwright using leafwright_ai_generate_template with document_type "invoice".${
+          details ? `\n\nSpecifics:\n${details}` : ""
+        }\n\nRender a preview and debug with leafwright_get_job_logs plus leafwright_ai_fix_from_logs if needed. Leave it as a draft.`
+      )
+  );
+
+  server.registerPrompt(
+    "create_report_template",
+    {
+      title: "Create a report template",
+      description: "Generate a multi-section report template.",
+      argsSchema: { details: z.string().optional().describe("Sections, charts, branding notes, etc.") }
+    },
+    ({ details }) =>
+      userPrompt(
+        `Create a multi-page report template in Leafwright using leafwright_ai_generate_template with document_type "report".${
+          details ? `\n\nSpecifics:\n${details}` : ""
+        }\n\nRender a preview, debug if needed, and leave it as a draft.`
+      )
+  );
+
+  server.registerPrompt(
+    "create_template_from_prompt",
+    {
+      title: "Create a template from a description",
+      description: "Generate any document template from a free-text description.",
+      argsSchema: {
+        description: z.string().describe("What the document should contain and look like."),
+        document_type: z.string().optional().describe("invoice | quote | report | certificate | etc.")
+      }
+    },
+    ({ description, document_type }) =>
+      userPrompt(
+        `Use leafwright_ai_generate_template to create a template${
+          document_type ? ` (document_type "${document_type}")` : ""
+        } from this description:\n\n${description}\n\nThen render a preview and verify it. Leave it as a draft.`
+      )
+  );
+
+  server.registerPrompt(
+    "debug_pdf_layout",
+    {
+      title: "Debug a PDF layout",
+      description: "Diagnose and fix a render that failed or looks wrong.",
+      argsSchema: {
+        job_id: z.string().describe("The render job that failed or looked wrong."),
+        template_id: z.string().optional().describe("If the render came from a template, its ID.")
+      }
+    },
+    ({ job_id, template_id }) =>
+      userPrompt(
+        `Call leafwright_get_job and leafwright_get_job_logs with job_id "${job_id}", explain the root cause, then ${
+          template_id
+            ? `call leafwright_ai_fix_from_logs with template_id "${template_id}" and job_id "${job_id}".`
+            : "propose the HTML/CSS change that fixes it."
+        }`
+      )
+  );
+
+  server.registerPrompt(
+    "explain_render_failure",
+    {
+      title: "Explain a render failure",
+      description: "Plain-language explanation of why a render failed.",
+      argsSchema: { job_id: z.string().describe("The failed render job ID.") }
+    },
+    ({ job_id }) =>
+      userPrompt(
+        `Call leafwright_get_job_logs with job_id "${job_id}" and explain why the render failed and exactly what to change.`
+      )
+  );
+
+  server.registerPrompt(
+    "integrate_nextjs",
+    {
+      title: "Integrate Leafwright into a Next.js app",
+      description: "Add server-side PDF generation to a Next.js project.",
+      argsSchema: {}
+    },
+    () =>
+      userPrompt(
+        "Add PDF generation to this Next.js app using Leafwright instead of Puppeteer. Use LEAFWRIGHT_API_KEY or Leafwright MCP auth and verify with leafwright_render_html."
+      )
+  );
+
+  server.registerPrompt(
+    "migrate_from_puppeteer",
+    {
+      title: "Migrate from Puppeteer to Leafwright",
+      description: "Replace headless-Chrome PDF code with the Leafwright API.",
+      argsSchema: {}
+    },
+    () =>
+      userPrompt(
+        "Find Puppeteer PDF generation and replace it with Leafwright /api/v1/pdfs calls. Use leafwright_render_html to confirm output before deleting old code."
+      )
+  );
+}
+
+function sendListChanged(server) {
+  try {
+    server.sendToolListChanged();
+    server.sendResourceListChanged();
+    server.sendPromptListChanged();
+  } catch {
+    // The server may not be connected yet during startup registration.
+  }
+}
+
+export function createLeafwrightMcpServer(options = {}) {
+  runtimeOverrides = options;
+  const server = new McpServer({
+    name: "leafwright",
+    version: "0.3.0"
+  });
+  let docsRegistered = false;
+  let resourcesRegistered = false;
+  let promptsRegistered = false;
+  let fullToolsRegistered = false;
+
+  function ensureDocsResource() {
+    if (docsRegistered) {
+      return;
+    }
+
+    registerDocsResource(server);
+    docsRegistered = true;
+  }
+
+  function ensureAuthenticatedResources() {
+    if (resourcesRegistered) {
+      return;
+    }
+
+    registerAuthenticatedResources(server);
+    resourcesRegistered = true;
+  }
+
+  function ensurePrompts() {
+    if (promptsRegistered) {
+      return;
+    }
+
+    registerPrompts(server);
+    promptsRegistered = true;
+  }
+
+  function ensureFullTools() {
+    if (fullToolsRegistered || !isAuthenticated()) {
+      return;
+    }
+
+    registerContextTools(server);
+    registerReadTools(server);
+    ensureDocsResource();
+    ensureAuthenticatedResources();
+    ensurePrompts();
+
+    if (!config().readOnly) {
+      registerWriteTools(server);
+    }
+
+    fullToolsRegistered = true;
+    sendListChanged(server);
+  }
+
+  registerAuthTools(server, ensureFullTools);
+  ensureDocsResource();
+
+  if (isAuthenticated()) {
+    ensureFullTools();
+  }
+
+  return server;
+}
+
+async function main() {
+  const server = createLeafwrightMcpServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  await main();
+}