@webjsdev/cli 0.10.11 → 0.10.13

package/README.md

@@ -10,7 +10,7 @@ Installing this package gives you the `webjs` command.
 Install once, globally:
 
 ```sh
-npm i -g @webjsdev/cli
+npm i -g webjsdev
 ```
 
 Then scaffold a new app anywhere:

package/bin/webjs.js

@@ -141,7 +141,7 @@ async function main() {
     }
     case 'ui': {
       // Delegate to @webjsdev/ui. Bundled as a hard dependency of
-      // @webjsdev/cli, so `npm install -g @webjsdev/cli` pulls it in
+      // @webjsdev/cli, so `npm install -g webjsdev` pulls it in
       // automatically, and `webjs ui add button` works out of the box
       // without an extra install in user projects.
       const { createRequire } = await import('node:module');
@@ -157,7 +157,7 @@ async function main() {
           entry = userReq.resolve('@webjsdev/ui/bin/webjsui.js');
         } catch {
           console.error('@webjsdev/ui could not be resolved.');
-          console.error('Reinstall the CLI:  npm install -g @webjsdev/cli');
+          console.error('Reinstall the CLI:  npm install -g webjsdev');
           process.exit(1);
         }
       }
@@ -275,7 +275,9 @@ async function main() {
       // identical to the MCP `check` tool. The non-zero exit on violations is
       // preserved (an agent gates on the exit code AND parses the report).
       if (rest.includes('--json')) {
-        const { projectCheck } = await import('../lib/check-json.js');
+        // The projector lives in @webjsdev/mcp (the MCP `check` tool's home),
+        // so `check --json` and the MCP tool stay byte-identical (#415).
+        const { projectCheck } = await import('@webjsdev/mcp/check-report');
         console.log(JSON.stringify(projectCheck(violations)));
         if (violations.length > 0) process.exit(1);
         break;
@@ -647,19 +649,23 @@ Full docs: https://docs.webjs.com`);
       process.exit(1);
     }
     case 'mcp': {
-      // Read-only MCP server (#262) over stdio. STDOUT is the JSON-RPC channel,
-      // so nothing here may write to stdout: the data functions are read-only
-      // and `runMcpServer` routes all diagnostics to stderr. The CLI version is
-      // advertised in the initialize handshake's serverInfo.
-      const { readFileSync } = await import('node:fs');
+      // Read-only MCP server (#262, #415) over stdio. STDOUT is the JSON-RPC
+      // channel, so nothing here may write to stdout: the data functions are
+      // read-only and `runMcpServer` routes all diagnostics to stderr. The
+      // implementation lives in the standalone `@webjsdev/mcp` package (also
+      // runnable directly as `npx @webjsdev/mcp`); `webjs mcp` delegates to it
+      // for back-compat. The version advertised in the initialize handshake is
+      // @webjsdev/mcp's own, resolved by its bin, so this passes none.
+      const { runMcpServer } = await import('@webjsdev/mcp');
+      const { createRequire } = await import('node:module');
+      const require = createRequire(import.meta.url);
       let version = '0.0.0';
       try {
-        const pkg = JSON.parse(
-          readFileSync(join(__dirname, '..', 'package.json'), 'utf8'),
-        );
-        version = pkg.version || version;
+        const { readFileSync } = await import('node:fs');
+        version = JSON.parse(
+          readFileSync(require.resolve('@webjsdev/mcp/package.json'), 'utf8'),
+        ).version || version;
       } catch {}
-      const { runMcpServer } = await import('../lib/mcp.js');
       await runMcpServer({
         stdin: process.stdin,
         stdout: process.stdout,

package/lib/create.js

@@ -308,6 +308,7 @@ export async function scaffoldApp(name, cwd, opts = {}) {
       // tsc --noEmit). Not needed at runtime (Node strips types in place), only
       // to type-check the app.
       typescript: '^5.6.0',
+      '@types/node': '^24.0.0',
       '@web/test-runner': '^0.20.0',
       '@web/test-runner-playwright': '^0.11.0',
       'playwright': '^1.59.0',
@@ -315,14 +316,19 @@ export async function scaffoldApp(name, cwd, opts = {}) {
       // assertNoA11yViolations() test helper from @webjsdev/core/testing.
       // Test-only: dynamically imported, never shipped to the app runtime.
       'axe-core': '^4.10.0',
-      // tsserver plugin for editor intelligence inside html`` templates.
-      // @webjsdev/ts-plugin bundles ts-lit-plugin internally, so just one
-      // plugin entry is needed in tsconfig (see below).
-      '@webjsdev/ts-plugin': 'latest',
-      // AI-first component library CLI, preinstalled so `webjs ui add button`
-      // works immediately after scaffold. Users can remove if they prefer
-      // to add it later.
-      '@webjsdev/ui': 'latest',
+      // tsserver plugin, wired into tsconfig below. Gives the language
+      // INTELLIGENCE (go-to-def, completions, diagnostics, hover inside html``
+      // templates) in any tsserver editor with NO editor plugin installed,
+      // because editors load tsconfig plugins from node_modules. The `webjs`
+      // VS Code extension and webjs.nvim ALSO bundle this plugin (so it works
+      // before `npm install` too, and adds template HIGHLIGHTING, which a
+      // tsserver plugin can't provide); tsserver dedupes by name, so loading
+      // it both ways is a no-op. Standalone, no Lit dependency. Editor-only.
+      '@webjsdev/intellisense': 'latest',
+      // NOTE: @webjsdev/ui is intentionally NOT pinned. The UI kit is
+      // shadcn-style copy-in: `webjs ui add <name>` copies component source
+      // into components/ui/ (they import @webjsdev/core, not the kit), and the
+      // CLI resolves @webjsdev/ui from its own install.
     },
   }, null, 2) + '\n');
 
@@ -332,6 +338,7 @@ export async function scaffoldApp(name, cwd, opts = {}) {
       module: 'NodeNext',
       moduleResolution: 'NodeNext',
       lib: ['ES2022', 'DOM', 'DOM.Iterable'],
+      types: ['node'],
       strict: true,
       noEmit: true,
       allowImportingTsExtensions: true,
@@ -347,17 +354,16 @@ export async function scaffoldApp(name, cwd, opts = {}) {
       // SYNTAX errors. Use a `const` object + union for enum-shaped
       // values; write fields + constructor assignments explicitly.
       erasableSyntaxOnly: true,
-      // @webjsdev/ts-plugin gives the editor:
-      //   • type-check + diagnostics inside html`` templates (via the
-      //     ts-lit-plugin it bundles internally)
-      //   • webjs-aware go-to-definition on custom-element tags
-      //   • "Unknown tag/attribute" suppression for elements registered
-      //     via Class.register('tag-name')
-      //   • attribute auto-complete sourced from `static properties`
-      //   • attribute-value type-check against `declare` annotations
-      // Editor-only. The framework runs without it.
+      // @webjsdev/intellisense (standalone, no Lit dependency) gives the editor,
+      // inside html`` templates:
+      //   • go-to-definition on custom-element tags, attributes, and CSS classes
+      //   • binding-aware completions (tag names, .prop / ?bool / plain attrs)
+      //   • diagnostics (value type-checks, unquoted-binding, expressionless .prop)
+      //   • hover showing the component class / declared member type
+      // Editor-only. The framework runs without it. For VS Code / Cursor /
+      // Windsurf, the `webjs` extension bundles this automatically.
       plugins: [
-        { name: '@webjsdev/ts-plugin' },
+        { name: '@webjsdev/intellisense' },
       ],
     },
     // `.webjs/routes.d.ts` is the OPT-IN generated route-types overlay (#258):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webjsdev/cli",
-  "version": "0.10.11",
+  "version": "0.10.13",
   "type": "module",
   "description": "webjs CLI - dev, start, create, db",
   "bin": {
@@ -13,6 +13,7 @@
     "README.md"
   ],
   "dependencies": {
+    "@webjsdev/mcp": "^0.1.0",
     "@webjsdev/server": "^0.8.0",
     "@webjsdev/ui": "^0.3.1"
   },

package/templates/.claude.json

@@ -8,7 +8,7 @@
     "webjs": {
       "type": "stdio",
       "command": "npx",
-      "args": ["@webjsdev/cli", "mcp"]
+      "args": ["@webjsdev/mcp"]
     }
   }
 }

package/templates/AGENTS.md

@@ -89,14 +89,14 @@ node_modules/@webjsdev/
     src/actions.js            ← .server.ts scanner, RPC, expose()
     src/auth.js, session.js, cache.js, rate-limit.js, csrf.js
   cli/             webjs CLI (dev / start / build / test / check / create / db)
-  ts-plugin/       tsserver plugin: go-to-definition + diagnostic suppression
+  intellisense/    tsserver plugin: go-to-definition + diagnostic suppression
                    + attribute auto-complete for Class.register('tag') elements
 ```
 
 Reaching straight for the source is the fastest way to resolve "why
 doesn't X work?" with no documentation guesswork and no stale blog posts.
 
-## Editor TS plugin: `@webjsdev/ts-plugin`
+## Editor TS plugin: `@webjsdev/intellisense`
 
 This scaffold's `tsconfig.json` lists a single tsserver plugin. It is
 editor-only, not required for the framework to run.
@@ -104,22 +104,24 @@ editor-only, not required for the framework to run.
 ```jsonc
 // tsconfig.json (already wired by the scaffold)
 "plugins": [
-  { "name": "@webjsdev/ts-plugin" }
+  { "name": "@webjsdev/intellisense" }
 ]
 ```
 
-`@webjsdev/ts-plugin` bundles `ts-lit-plugin` internally (it's a runtime
-dependency of the plugin) and loads it programmatically, so users
-list one entry, not two. You get the full stack of template-literal
-intelligence (type-checking, diagnostics, go-to-def inside
-`` html`…` `` and `` css`…` `` templates) **plus** webjs-aware behaviour
-layered on top:
-
-- "Unknown tag/attribute" diagnostics are silenced for elements
-  registered via `Class.register('tag-name')`.
-- Attribute auto-complete sourced from each component's
-  `static properties`.
-- Attribute-value type-check against `declare propName: T` annotations.
+`@webjsdev/intellisense` is **standalone** (no Lit dependency): one plugin
+entry, its own template parser. Inside `` html`…` `` templates you get:
+
+- Go-to-definition on custom-element tags, attribute / property / event
+  names, and CSS classes in `class="…"`.
+- Binding-aware completions: reachable tag names after `<`, and
+  prefix-keyed attributes (`.prop` property names, `?bool` / plain
+  hyphenated attribute names).
+- Diagnostics: value type-checks against `declare propName: T`, unquoted
+  `@`/`.`/`?` bindings, and expressionless `.prop` bindings.
+- Hover showing the component class / declared member type.
+
+In VS Code / Cursor / Windsurf, the **`webjs` extension** bundles this
+automatically (no `tsconfig.json` edit, no separate Lit extension).
 
 See [docs.webjs.com → Editor setup](https://docs.webjs.com/docs/editor-setup)
 for the full walkthrough.

package/templates/CONVENTIONS.md

@@ -654,11 +654,11 @@ attribute coercion, reflection). `declare` types the field for
 TypeScript without emitting a class-field initializer that would
 clobber the reactive accessor at construction time. The two
 declarations together give you full intelligence in any tsserver-backed
-editor. See the Editor Setup docs for the `ts-lit-plugin` +
-`@webjsdev/ts-plugin` setup that extends this to tag / attribute
-intelligence inside `html\`…\`` templates (go-to-definition, attribute
-auto-complete from `static properties`, no "Unknown tag" red-squiggle on
-registered webjs elements).
+editor. See the Editor Setup docs for the standalone `@webjsdev/intellisense`
+(no Lit dependency) that extends this to tag / attribute intelligence
+inside `html\`…\`` templates (go-to-definition, binding-aware completions,
+value/binding diagnostics, hover); in VS Code / Cursor / Windsurf the
+`webjs` extension bundles it automatically.
 
 **Rules:**
 - One component per file

package/lib/check-json.js

@@ -1,47 +0,0 @@
-/**
- * Shared JSON projector for `webjs check` violations (#262).
- *
- * `webjs check --json` and the `webjs mcp` server's `check` tool BOTH return
- * the identical shape, so the projection lives here once. The input is the raw
- * `Violation[]` from `checkConventions(appDir)` (each `{ rule, file, message,
- * fix }`); the output adds a `summary` count plus a per-rule breakdown so an
- * agent consuming the structured output never has to regex-scrape stdout.
- *
- * Pure and side-effect-free: it neither reads files nor prints. The caller owns
- * running `checkConventions` and (for the CLI) the non-zero exit when there are
- * violations.
- *
- * @module check-json
- */
-
-/**
- * @typedef {{ rule: string, file: string, message: string, fix: string }} Violation
- */
-
-/**
- * @typedef {{
- *   violations: Violation[],
- *   summary: { count: number, byRule: Record<string, number> },
- * }} CheckReport
- */
-
-/**
- * Project a raw `Violation[]` into the structured `{ violations, summary }`
- * report shared by `check --json` and the MCP `check` tool. `violations` is
- * passed through verbatim (the `{ rule, file, message, fix }` shape), and
- * `summary.byRule` tallies how many violations each rule produced.
- *
- * @param {Violation[]} violations
- * @returns {CheckReport}
- */
-export function projectCheck(violations) {
-  /** @type {Record<string, number>} */
-  const byRule = {};
-  for (const v of violations) {
-    byRule[v.rule] = (byRule[v.rule] || 0) + 1;
-  }
-  return {
-    violations,
-    summary: { count: violations.length, byRule },
-  };
-}

package/lib/mcp.js

@@ -1,408 +0,0 @@
-/**
- * `webjs mcp`: a minimal, READ-ONLY Model Context Protocol server (#262).
- *
- * Exposes the live introspection surface an AI agent needs while editing a
- * webjs app (the route table, registered server actions with their RPC
- * endpoints, registered custom-element tags, and the structured `webjs check`
- * violations) over MCP's stdio transport. Every tool REUSES an existing
- * `@webjsdev/server` data function and MUTATES NOTHING. The prior art is
- * Next.js's `next-devtools-mcp` (get_routes / get_server_action_by_id /
- * get_errors); this is deliberately tiny.
- *
- * Transport: MCP stdio is newline-delimited JSON-RPC 2.0. One JSON object per
- * line arrives on stdin; exactly one JSON response line per request is written
- * to stdout. STDOUT IS THE PROTOCOL CHANNEL, so this module writes ONLY
- * JSON-RPC frames there and routes every diagnostic to stderr. A malformed
- * input line is answered with a JSON-RPC parse error and never crashes the
- * loop. Hand-rolled with zero new dependency (webjs is buildless +
- * minimal-deps).
- *
- * @module mcp
- */
-
-import { createInterface } from 'node:readline';
-import { relative } from 'node:path';
-
-const PROTOCOL_VERSION = '2024-11-05';
-
-/**
- * The four read-only tools. Each takes an optional `{ appDir }` (default the
- * server's cwd) and projects an EXISTING `@webjsdev/server` function's output
- * into an agent-friendly shape. Descriptions are crisp so a model picks the
- * right tool without reading source.
- */
-const TOOL_DEFS = [
-  {
-    name: 'list_routes',
-    description:
-      'List the app route table: SSR pages (path, file, dynamic flag, param names) and route.{js,ts} API handlers (path, file, HTTP methods). Read-only.',
-  },
-  {
-    name: 'list_actions',
-    description:
-      'List registered server actions (the .server.{js,ts} files with "use server"): file, exported function name, and the /__webjs/action/<hash>/<fn> RPC endpoint. Read-only.',
-  },
-  {
-    name: 'list_components',
-    description:
-      'List registered custom-element tags: tag name, defining file, and class name. Read-only.',
-  },
-  {
-    name: 'check',
-    description:
-      'Run webjs check (correctness rules) and return the structured violations { rule, file, message, fix } plus a summary count and per-rule breakdown. Read-only.',
-  },
-];
-
-/** The shared input schema: every tool takes an optional appDir override. */
-const TOOL_INPUT_SCHEMA = {
-  type: 'object',
-  properties: {
-    appDir: {
-      type: 'string',
-      description: 'App directory to introspect. Defaults to the server cwd.',
-    },
-  },
-  required: [],
-};
-
-/**
- * Lexically extract the names exported from a module source. Recognises the
- * common forms a server-action / route file uses without LOADING the module
- * (loading would run its top-level side effects: Prisma init, DB connects).
- *
- *   export async function foo() {}   export function foo() {}
- *   export const foo = ...           export let/var foo = ...
- *   export default ...               (recorded as 'default')
- *   export { a, b as c }             (the EXPORTED name, so `c`)
- *
- * @param {string} src
- * @returns {string[]} unique export names, in source order
- */
-export function extractExportNames(src) {
-  /** @type {string[]} */
-  const names = [];
-  const add = (n) => { if (n && !names.includes(n)) names.push(n); };
-
-  // export [async] function NAME / export const|let|var NAME / export class NAME
-  const declRe =
-    /\bexport\s+(?:async\s+)?(?:function\*?|const|let|var|class)\s+([A-Za-z_$][\w$]*)/g;
-  let m;
-  while ((m = declRe.exec(src)) !== null) add(m[1]);
-
-  // export default ...
-  if (/\bexport\s+default\b/.test(src)) add('default');
-
-  // export { a, b as c, default as d }
-  const namedRe = /\bexport\s*\{([^}]*)\}/g;
-  while ((m = namedRe.exec(src)) !== null) {
-    for (const part of m[1].split(',')) {
-      const seg = part.trim();
-      if (!seg) continue;
-      // `local as exported` -> the exported name is what callers import.
-      const asMatch = /\bas\s+([A-Za-z_$][\w$]*)\s*$/.exec(seg);
-      if (asMatch) add(asMatch[1]);
-      else {
-        const idMatch = /^([A-Za-z_$][\w$]*)$/.exec(seg);
-        if (idMatch) add(idMatch[1]);
-      }
-    }
-  }
-  return names;
-}
-
-/**
- * Lexically extract the HTTP method exports of a route.{js,ts} file. The webjs
- * API router (`api.js`) dispatches the five standard verbs, plus `WS` for a
- * WebSocket upgrade. We report exactly those that are exported, NOT `HEAD` /
- * `OPTIONS` (the router does not dispatch a named handler for them, so listing
- * them would imply a route the framework ignores). Read-only: no module load.
- *
- * @param {string} src
- * @returns {string[]}
- */
-export function extractRouteMethods(src) {
-  const METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'WS'];
-  const exported = new Set(extractExportNames(src));
-  return METHODS.filter((m) => exported.has(m));
-}
-
-/**
- * The literal URL path for a page/api directory: `blog/[slug]` -> `/blog/[slug]`,
- * the root `.` -> `/`. Route groups `(group)` and `_private` segments drop, the
- * same normalization `buildRouteTable` uses for matching.
- *
- * @param {string} routeDir  POSIX-style, `.` for the app root.
- * @returns {string}
- */
-function routePathFromDir(routeDir) {
-  if (!routeDir || routeDir === '.') return '/';
-  const segs = routeDir
-    .split('/')
-    .filter((s) => !(s.startsWith('(') && s.endsWith(')')) && !s.startsWith('_'));
-  return segs.length ? '/' + segs.join('/') : '/';
-}
-
-/**
- * The tool runners. Each is async, takes `(appDir)`, and returns a plain
- * JSON-serialisable projection of an existing server data function. All are
- * read-only.
- *
- * @param {{ buildRouteTable: Function, buildActionIndex: Function, hashFile: Function, scanComponents: Function, checkConventions: Function, projectCheck: Function, readFile: Function }} deps
- */
-export function makeToolRunners(deps) {
-  const {
-    buildRouteTable,
-    buildActionIndex,
-    hashFile,
-    scanComponents,
-    checkConventions,
-    projectCheck,
-    readFile,
-  } = deps;
-
-  return {
-    async list_routes(appDir) {
-      const table = await buildRouteTable(appDir);
-      const pages = await Promise.all(
-        table.pages.map(async (r) => {
-          /** @type {{ path: string, file: string, dynamic?: boolean, params?: string[] }} */
-          const out = {
-            path: routePathFromDir(r.routeDir),
-            file: relative(appDir, r.file),
-          };
-          if (r.paramNames && r.paramNames.length) {
-            out.dynamic = true;
-            out.params = r.paramNames;
-          }
-          return out;
-        }),
-      );
-      const apis = await Promise.all(
-        table.apis.map(async (r) => {
-          let methods = [];
-          try {
-            methods = extractRouteMethods(await readFile(r.file, 'utf8'));
-          } catch {}
-          return {
-            path: routePathFromDir(r.routeDir),
-            file: relative(appDir, r.file),
-            methods,
-          };
-        }),
-      );
-      return { pages, apis };
-    },
-
-    async list_actions(appDir) {
-      // `skipExposeLoad` builds the file -> hash maps WITHOUT importing any
-      // `expose()` module, so this stays truly read-only (no Prisma/DB init, and
-      // no stray stdout from a loaded module corrupting the JSON-RPC channel).
-      // The RPC hash is over the file path only, so no module load is needed.
-      const idx = await buildActionIndex(appDir, false, { skipExposeLoad: true });
-      /** @type {Array<{ file: string, fn: string, endpoint: string }>} */
-      const actions = [];
-      for (const [file, hash] of idx.fileToHash) {
-        let names = [];
-        try {
-          names = extractExportNames(await readFile(file, 'utf8'));
-        } catch {}
-        for (const fn of names) {
-          actions.push({
-            file: relative(appDir, file),
-            fn,
-            endpoint: `/__webjs/action/${hash}/${fn}`,
-          });
-        }
-      }
-      // Stable order for deterministic output.
-      actions.sort((a, b) =>
-        a.file === b.file ? a.fn.localeCompare(b.fn) : a.file.localeCompare(b.file),
-      );
-      return actions;
-    },
-
-    async list_components(appDir) {
-      const comps = await scanComponents(appDir);
-      return comps
-        .map((c) => ({
-          tag: c.tag,
-          file: relative(appDir, c.file),
-          className: c.className,
-        }))
-        .sort((a, b) => a.tag.localeCompare(b.tag));
-    },
-
-    async check(appDir) {
-      const violations = await checkConventions(appDir);
-      return projectCheck(violations);
-    },
-  };
-}
-
-/**
- * A JSON-RPC 2.0 result frame.
- * @param {string|number|null} id
- * @param {any} result
- */
-function rpcResult(id, result) {
-  return { jsonrpc: '2.0', id, result };
-}
-
-/**
- * A JSON-RPC 2.0 error frame.
- * @param {string|number|null} id
- * @param {number} code
- * @param {string} message
- */
-function rpcError(id, code, message) {
-  return { jsonrpc: '2.0', id, error: { code, message } };
-}
-
-/**
- * Run the read-only webjs MCP server over the given streams. Reads
- * newline-delimited JSON-RPC from `stdin`, writes one response line per request
- * to `stdout`, and logs diagnostics to `stderr` ONLY (stdout is the protocol
- * channel). Resolves when stdin ends (clean shutdown).
- *
- * Injectable streams + `cwd` keep it testable in-process with PassThrough
- * streams; the bin passes the real `process.std*` + `process.cwd()`.
- *
- * @param {{
- *   stdin: NodeJS.ReadableStream,
- *   stdout: NodeJS.WritableStream,
- *   stderr: NodeJS.WritableStream,
- *   cwd: string,
- *   version?: string,
- *   deps?: object,
- * }} opts
- * @returns {Promise<void>}
- */
-export async function runMcpServer(opts) {
-  const { stdin, stdout, stderr, cwd } = opts;
-  const version = opts.version || '0.0.0';
-
-  // Resolve the data functions from @webjsdev/server (reading them is
-  // read-only). Injectable for tests so they need not boot the real server.
-  let deps = opts.deps;
-  if (!deps) {
-    const server = await import('@webjsdev/server');
-    const check = await import('@webjsdev/server/check');
-    const { readFile } = await import('node:fs/promises');
-    const { projectCheck } = await import('./check-json.js');
-    deps = {
-      buildRouteTable: server.buildRouteTable,
-      buildActionIndex: server.buildActionIndex,
-      hashFile: server.hashFile,
-      scanComponents: server.scanComponents,
-      checkConventions: check.checkConventions,
-      projectCheck,
-      readFile,
-    };
-  }
-  const runners = makeToolRunners(deps);
-
-  /** Write one JSON-RPC frame as a single line to stdout. */
-  const send = (frame) => {
-    stdout.write(JSON.stringify(frame) + '\n');
-  };
-  /** Diagnostics go to stderr only, never stdout. */
-  const logErr = (msg) => {
-    try { stderr.write(`[webjs mcp] ${msg}\n`); } catch {}
-  };
-
-  /**
-   * Dispatch one parsed JSON-RPC message. Returns a frame to send, or null
-   * for a notification (no `id`) which gets no response.
-   */
-  const dispatch = async (msg) => {
-    const id = msg && Object.prototype.hasOwnProperty.call(msg, 'id') ? msg.id : null;
-    const isNotification = id === null || id === undefined;
-    const method = msg && msg.method;
-
-    if (method === 'initialize') {
-      return rpcResult(id, {
-        protocolVersion: PROTOCOL_VERSION,
-        capabilities: { tools: {} },
-        serverInfo: { name: 'webjs', version },
-      });
-    }
-
-    // `notifications/initialized` (and any other notification) gets no reply.
-    if (isNotification) return null;
-
-    if (method === 'tools/list') {
-      return rpcResult(id, {
-        tools: TOOL_DEFS.map((t) => ({
-          name: t.name,
-          description: t.description,
-          inputSchema: TOOL_INPUT_SCHEMA,
-        })),
-      });
-    }
-
-    if (method === 'tools/call') {
-      const params = (msg && msg.params) || {};
-      const name = params.name;
-      const args = params.arguments || {};
-      const runner = runners[name];
-      if (!runner) {
-        return rpcError(id, -32602, `Unknown tool: ${String(name)}`);
-      }
-      const appDir = typeof args.appDir === 'string' && args.appDir ? args.appDir : cwd;
-      try {
-        const result = await runner(appDir);
-        return rpcResult(id, {
-          content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-        });
-      } catch (e) {
-        // A tool failure is an MCP tool-result error (isError), not a transport
-        // error, so the agent sees the message in the content channel.
-        logErr(`tool ${name} failed: ${e && e.message ? e.message : e}`);
-        return rpcResult(id, {
-          isError: true,
-          content: [
-            { type: 'text', text: `Error running ${name}: ${e && e.message ? e.message : String(e)}` },
-          ],
-        });
-      }
-    }
-
-    return rpcError(id, -32601, `Method not found: ${String(method)}`);
-  };
-
-  const rl = createInterface({ input: stdin, crlfDelay: Infinity });
-
-  await new Promise((resolveRun) => {
-    // Serialise line handling so responses preserve request order even though
-    // dispatch is async.
-    let chain = Promise.resolve();
-    rl.on('line', (line) => {
-      const trimmed = line.trim();
-      if (!trimmed) return;
-      chain = chain.then(async () => {
-        let msg;
-        try {
-          msg = JSON.parse(trimmed);
-        } catch {
-          // Malformed line: a JSON-RPC parse error, never a crash.
-          send(rpcError(null, -32700, 'Parse error'));
-          return;
-        }
-        try {
-          const frame = await dispatch(msg);
-          if (frame) send(frame);
-        } catch (e) {
-          logErr(`dispatch error: ${e && e.message ? e.message : e}`);
-          const id =
-            msg && Object.prototype.hasOwnProperty.call(msg, 'id') ? msg.id : null;
-          send(rpcError(id, -32603, 'Internal error'));
-        }
-      });
-    });
-    rl.on('close', () => {
-      // Drain the in-flight chain, then resolve (clean shutdown on stdin end).
-      chain.then(() => resolveRun()).catch(() => resolveRun());
-    });
-  });
-}