@wirl/mcp 0.2.0 → 0.2.1

package/README.md

@@ -14,18 +14,20 @@ The token it receives is deploy-scoped by default: it can deploy, roll back, pul
 
 ## Running it locally
 
-For agents without HTTP MCP support, this package runs the same tools over stdio, using the credentials `wirl login` wrote. wirl serves the package itself, so the command names its address rather than an npm name:
+For agents without HTTP MCP support, this package runs the same tools over stdio, using the credentials `wirl login` wrote. `npx` fetches it from npm the first time, so there is nothing to install beyond Node 20 or later:
 
 ```bash
-claude mcp add wirl -- npx -y https://app.wirl.dev/cli/wirl-mcp.tgz
+claude mcp add wirl -- npx -y @wirl/mcp
 ```
 
 Cursor and anything else that speaks MCP take the same command in their own configuration:
 
 ```json
-{ "mcpServers": { "wirl": { "command": "npx", "args": ["-y", "https://app.wirl.dev/cli/wirl-mcp.tgz"] } } }
+{ "mcpServers": { "wirl": { "command": "npx", "args": ["-y", "@wirl/mcp"] } } }
 ```
 
+If your npm registry does not carry wirl, or to run exactly the build app.wirl.dev serves, name its address instead of the package: `claude mcp add wirl -- npx -y https://app.wirl.dev/cli/wirl-mcp.tgz`.
+
 The first time, the agent calls `wirl_login`, shows you a link and a code, and carries on once you approve in the browser. A local server acts with the CLI's credentials, which are full-scope; revoke them on the Connect an agent page at app.wirl.dev if an agent should lose access.
 
 ## Tools

package/bin.js

@@ -2788,20 +2788,21 @@ arrives: pass \`response.body\` straight on. There are no WebSockets. A front en
 \`"static": "dist"\` serves that folder's files at their own paths (\`/\` is its \`index.html\`) and the module
 answers everything else; add \`"spa": true\` for a client-side router. Nothing outside that folder is served.
 
-Preview before you deploy: \`wirl preview\` puts the folder up at its own address with
-its own database (empty at first), and \`wirl fetch <path> --preview <name>\` (or the
-\`wirl_preview_fetch\` tool) shows you what it serves.
+Preview before you deploy: \`wirl preview\` gives a folder its own address and database (at first only what
+\`migrations/\` makes). \`wirl fetch <path> --preview <name>\` or \`wirl_preview_fetch\` shows what it answers.
 
 npm packages work: install them in the project and the deploy bundles them in. Nothing is installed on the
 server: native code will not run. Node built-ins work (\`node:crypto\`, \`node:path\`, ...; \`Buffer\` and
 \`process\` are global), but what \`node:fs\` writes is gone by the next request: use \`env.DB\`.
 
 \`env\` holds \`DB\` and nothing else. \`env.DB\` is Cloudflare D1: prepared statements with \`.bind()\`, at most
-100 bound parameters a statement. \`exec()\` runs one statement per line. Declare a host under \`connections\`
-in \`wirl.json\`, then \`fetch\` the vendor's real URL: wirl attaches the key. An undeclared host is refused; a
-public API needing no key uses \`"kind": "none"\`. Declaring one deploys before anyone approves it;
-the deploy says per connection whether it is usable now or waiting on an admin. A vendor has 60
-seconds to answer, whole, unless it streams: ask a model for a stream.
+100 bound parameters a statement. \`exec()\` runs one statement per line, as does each file in \`migrations/\`,
+which wirl applies in order to a preview and before going live; a failing one fails the deploy. Never edit
+an applied file. Dropping or renaming a table or column needs \`"migrations": { "destructive": [...] }\`, its
+own live deploy and a person's yes. Declare a host under \`connections\`, then \`fetch\` the vendor's real URL:
+wirl attaches the key. An undeclared host is refused; a public API needing no key uses \`"kind": "none"\`.
+Declaring one deploys before anyone approves it; the deploy says per connection whether it is usable now or
+waiting on an admin. A vendor has 60 seconds to answer, whole, unless it streams: ask a model for a stream.
 
 Six headers say who is asking: \`x-wirl-user-id\`, \`x-wirl-user-email\`, \`x-wirl-user-name\`,
 \`x-wirl-role\`, \`x-wirl-app-id\`, \`x-wirl-org\`. Read the name with
@@ -2811,10 +2812,9 @@ Schedules POST to \`/__wirl/schedule/<name>\`; a run gets 5 minutes unless that
 says otherwise, and at most 15. A \`public_paths\` path takes requests with no sign-in.
 Work that outlives one request (waiting for a person, trying tomorrow, a long loop) is a flow: see Flows.
 
-A new app defaults to org-wide visibility when its org has a company email domain,
-and to private otherwise, including one made with \`wirl orgs create\`.
-Sharing by email adds one named person; \`wirl visibility private|org\` (or the tool)
-sets the level. Public is only ever a person's click on the app's Access page.
+A new app defaults to org-wide visibility when its org has a company email domain, and to private
+otherwise, including one made with \`wirl orgs create\`; \`wirl visibility private|org\` sets the level.
+Sharing by email adds one named person. Public is only ever a person's click on the app's Access page.
 
 Porting an existing project: route it through the \`fetch\` handler, replace ORM calls with
 \`env.DB.prepare(...).bind(...)\`, turn timers into \`schedules\`, and move keys into \`connections\`. Keep the
@@ -2846,18 +2846,40 @@ early, repeated or late one gets 409, or 404 once the run ends; check \`x-wirl-u
   }
 });
 
+// packages/core/src/version.ts
+function wirlVersion() {
+  return BUILT_VERSION ?? WORKSPACE_VERSION;
+}
+var WORKSPACE_VERSION, BUILT_VERSION;
+var init_version = __esm({
+  "packages/core/src/version.ts"() {
+    "use strict";
+    WORKSPACE_VERSION = "0.0.0";
+    BUILT_VERSION = true ? "0.2.1" : null;
+  }
+});
+
 // packages/core/src/install.ts
+function fallbackWhen(controlPlane = "this control plane") {
+  return `If your npm registry does not carry wirl, or to run exactly the build ${controlPlane} serves,`;
+}
+function namedControlPlane(controlOrigin) {
+  return `the wirl control plane (${controlOrigin.replace(/^https?:\/\//, "").replace(/\/+$/, "")})`;
+}
 function installFor(controlOrigin) {
-  if (NPM_PUBLISHED) return { cli: "wirl", mcp: "@wirl/mcp" };
   const origin = controlOrigin.replace(/\/+$/, "");
-  return { cli: `${origin}/cli/wirl.tgz`, mcp: `${origin}/cli/wirl-mcp.tgz` };
+  const tarball = { cli: `${origin}/cli/wirl.tgz`, mcp: `${origin}/cli/wirl-mcp.tgz` };
+  if (NPM_PUBLISHED) return { cli: "wirl", mcp: "@wirl/mcp", tarball };
+  return { ...tarball, tarball };
 }
-var NPM_PUBLISHED, WIRL_BIN;
+var NPM_PUBLISHED, WIRL_BIN, FALLBACK_WHEN, hasFallback;
 var init_install = __esm({
   "packages/core/src/install.ts"() {
     "use strict";
-    NPM_PUBLISHED = false;
+    NPM_PUBLISHED = true;
     WIRL_BIN = NPM_PUBLISHED ? "npx wirl" : "wirl";
+    FALLBACK_WHEN = fallbackWhen();
+    hasFallback = (install) => install.cli !== install.tarball.cli;
   }
 });
 
@@ -3142,6 +3164,7 @@ var init_src = __esm({
     init_broker_stream();
     init_retention();
     init_contract();
+    init_version();
     init_install();
     init_porting();
     init_supplied_bundle();
@@ -4980,7 +5003,7 @@ async function loadCredentials(env = process.env) {
     }
   } catch {
   }
-  throw new CliError("Not signed in.", "Run `wirl login` first, or set WIRL_TOKEN.", { code: "not_signed_in" });
+  throw new CliError("Not signed in.", `Run \`${WIRL_BIN} login\` first, or set WIRL_TOKEN.`, { code: "not_signed_in" });
 }
 async function saveCredentials(creds, env = process.env) {
   const path = credentialsPath(env);
@@ -5041,11 +5064,11 @@ async function pollDeviceLogin(apiOrigin, login, options = {}) {
         continue;
       }
       case "expired_token":
-        throw new CliError("The sign-in code expired before it was approved.", "Run `wirl login` again.");
+        throw new CliError("The sign-in code expired before it was approved.", `Run \`${WIRL_BIN} login\` again.`);
       default:
         throw new CliError(
           typeof body["error"] === "string" ? `Sign-in failed: ${body["error"]}.` : `Sign-in failed (${response.status}).`,
-          "Run `wirl login` again."
+          `Run \`${WIRL_BIN} login\` again.`
         );
     }
   }
@@ -5096,6 +5119,10 @@ var SERVER_TEMPLATE = [
   " *",
   " * Everything real happens here. The page is HTML this module returns. The",
   " * data lives in env.DB, a SQLite database that belongs to this app alone.",
+  " * Its tables are in migrations/0001_init.sql: wirl applies each new file in",
+  " * migrations/ before a version goes live, to a preview's database when the",
+  " * preview is put up, and to the local one when wirl dev starts. Put the",
+  " * next change in migrations/0002_<what>.sql rather than editing that one.",
   " * The person making the request is in headers wirl sets after verifying",
   " * them, which the browser cannot forge. Any rule that matters, such as",
   ' * "you only see your own notes", is a line of code in this file: a check',
@@ -5107,18 +5134,8 @@ var SERVER_TEMPLATE = [
   " * live in .wirl/keys.json beside this file, which git ignores.",
   " */",
   "",
-  "// One line: exec runs one statement per line, as D1 does.",
-  "const SCHEMA =",
-  '  "create table if not exists notes (" +',
-  '  "  id integer primary key," +',
-  '  "  user_id text not null," +',
-  '  "  body text not null," +',
-  `  "  created_at text not null default (datetime('now'))" +`,
-  '  ")";',
-  "",
   "export default {",
   "  async fetch(request, env) {",
-  "    await env.DB.exec(SCHEMA);",
   "    const url = new URL(request.url);",
   "",
   `    // One line per request. Read it with ${WIRL_BIN} logs.`,
@@ -5201,7 +5218,21 @@ var SERVER_TEMPLATE = [
   "}",
   ""
 ].join("\n");
+var INIT_MIGRATION = [
+  "-- This app's tables. wirl applies each new file here, in order, before a version goes live.",
+  "-- Make the next change in 0002_<what>.sql; never edit a file that has been deployed.",
+  "create table notes (id integer primary key, user_id text not null, body text not null, created_at text not null default (datetime('now')))",
+  ""
+].join("\n");
+var INIT_MIGRATION_PATH = `${MIGRATIONS_DIR}/${ADOPTED_FILE}`;
 var SKILL_PATH = join5(".claude", "skills", "wirl", "SKILL.md");
+var SKILL_ORIGIN = "https://app.wirl.dev";
+var SKILL_INSTALL = installFor(SKILL_ORIGIN);
+var SKILL_RUN = NPM_PUBLISHED ? `Run the CLI as \`${WIRL_BIN} <command>\`, which needs no install beyond Node 22.13 or later (in a terminal npm asks "Ok to proceed?" the first time: answer y); this file writes a command as \`wirl <command>\` for short anywhere but the list below.
+
+` : "";
+var SKILL_FALLBACK = hasFallback(SKILL_INSTALL) ? `- ${fallbackWhen(namedControlPlane(SKILL_ORIGIN))} install the CLI from the control plane instead with \`npm install -g ${SKILL_INSTALL.tarball.cli}\`, run plain \`wirl\` where this file says \`${WIRL_BIN}\`, and name \`${SKILL_INSTALL.tarball.mcp}\` in place of \`${SKILL_INSTALL.mcp}\`.
+` : "";
 var SKILL_MARKDOWN = `---
 name: wirl
 description: Deploy and share the internal app in this project with wirl (${WIRL_BIN}). Use when the user wants a tool, dashboard or prototype put somewhere colleagues can open it, shared with a named person, run locally the way it will run deployed, or connected to a third-party API; or wants work that outlives one request, such as waiting for a person to approve something or trying again tomorrow.
@@ -5218,20 +5249,23 @@ Before you build, fetch https://docs.wirl.dev/llms-full.txt: every page of the d
 
 ## Commands
 
-- Connect first, if the agent supports MCP: \`claude mcp add --transport http wirl https://app.wirl.dev/mcp\` opens the browser once to sign in. No HTTP MCP support? \`claude mcp add wirl -- npx -y ${installFor("https://app.wirl.dev").mcp}\` does the same, running locally. Neither available: \`${WIRL_BIN} login\` prints a link and a code; the person approves in the browser. Do this once, when any command says you are not signed in.
+${SKILL_RUN}- Connect first, if the agent supports MCP: \`claude mcp add --transport http wirl https://app.wirl.dev/mcp\` opens the browser once to sign in, and needs no install. No HTTP MCP support? \`claude mcp add wirl -- npx -y ${SKILL_INSTALL.mcp}\` does the same, running locally. Neither available: \`${WIRL_BIN} login\` prints a link and a code; the person approves in the browser. Do this once, when any command says you are not signed in.
 - \`${WIRL_BIN} deploy\` \u2014 deploys this directory. Prints the URL and who can open it.
 - \`${WIRL_BIN} share someone@company.com\` \u2014 that person can open it. Add \`--role editor\` so they can deploy too.
 - \`${WIRL_BIN} dev\` \u2014 runs the app here as it will run deployed, signed in as a stub user.
 - \`${WIRL_BIN} pull <app>\` \u2014 fetches a deployed app's source to keep building.
 - \`${WIRL_BIN} logs\` \u2014 what the deployed app printed, per request, newest first; \`--errors\` for failures only, \`--follow\` to keep watching, \`--cursor <n>\` for the page before a "More before this" line. Read this before changing code when something misbehaves.
+- \`${WIRL_BIN} migrations\` \u2014 what this app's database has applied, read only.
+- \`${WIRL_BIN} migrations adopt\` \u2014 once, for an app whose tables were made in code: writes \`migrations/0001_init.sql\` from the live database's shape.
 - \`${WIRL_BIN} --help\` \u2014 everything else: orgs, members, connections, move, transfer, rollback, flows and runs.
-
+${SKILL_FALLBACK}
 ## Rules
 
 1. **Never ask for or paste an API key.** Declare the connection in \`wirl.json\` and deploy. Needs no key at all (a public API)? Declare it with "kind": "none" and its hosts. If the key is missing, the deploy prints a link to the app's keys page; show the person that link. Locally, keys live in \`.wirl/keys.json\`, which git ignores. To try a vendor call locally without the key, map its connection to a server of your own in \`.wirl/mocks.json\`, like \`{ "anthropic": "http://127.0.0.1:4010" }\`: \`wirl dev\` then sends the calls to that connection's hosts there instead (\`wirl dev --help\` has the rest).
 2. **Call third-party APIs by their real URL** (\`fetch("https://api.hubspot.com/...")\`). wirl attaches the key on the way out, deployed and under \`wirl dev\` alike.
 3. If a command names several organisations and asks which, ask the person; pass \`--org\` or put \`"org"\` in \`wirl.json\`.
 4. To keep a file out of the deploy, list it in a \`.wirlignore\` at the project root (gitignore-style lines; no \`!\` negation).
+5. **A file that can lose data waits for a person.** A deploy that would apply a destructive file (one wirl.json's \`"destructive"\` list must name) to the live database stops and names the page where a person approves each one. Show the person those pages, and deploy again once they say they approved. If \`${WIRL_BIN} deploy\` asks you to type a file's name, stop it and show the page instead, or deploy with \`--json\`, which never asks. Never type the name yourself or send the confirmation: that is the person's, and no flag skips it.
 
 ## wirl.json
 
@@ -5522,7 +5556,7 @@ async function callApi(creds, path, options = {}) {
       throw new CliError(body.message, void 0, refusal);
     }
     if (response.status === 401 || response.status === 403) {
-      throw new CliError("Not signed in, or this token cannot do that.", "Try `wirl login`.", refusal);
+      throw new CliError("Not signed in, or this token cannot do that.", `Try \`${WIRL_BIN} login\`.`, refusal);
     }
     if (response.status === 404) {
       if (body.error !== void 0 && body.error !== "not_found" && body.message) throw new CliError(body.message, void 0, refusal);
@@ -5554,7 +5588,7 @@ async function callApiBytes(creds, path, options = {}) {
       body = {};
     }
     if (response.status === 401 || response.status === 403) {
-      throw new CliError("Not signed in, or this token cannot do that.", "Try `wirl login`.");
+      throw new CliError("Not signed in, or this token cannot do that.", `Try \`${WIRL_BIN} login\`.`);
     }
     if (response.status === 404) throw new CliError("Not found, or you do not have access to it.");
     throw new CliError(body.message ?? body.error ?? `Request failed (${response.status}).`);
@@ -6709,7 +6743,7 @@ var ADOPT_SENTENCES2 = {
    */
   cannotTell: (what) => `wirl did not get the adopt route's answer (${what}), so it cannot tell whether the live database recorded migrations/${ADOPTED_FILE}, and nothing was written here. Run wirl migrations adopt again: while an adopted ${ADOPTED_FILE} is all the live database records, adopting again replaces that record and writes the file.`,
   /** After the call, so the live database records the file; a CLI that reads files otherwise than the control plane says this every time. */
-  notAsRecorded: (install) => `The live database now records migrations/${ADOPTED_FILE} as adopted, but the file wirl sent does not match its own record of it, so nothing was written here. Run wirl migrations adopt again: while an adopted ${ADOPTED_FILE} is all the live database records, adopting again replaces that record and writes the file. If it says this again, this copy of wirl reads migration files differently from the control plane: update it (npm install -g ${install}).`,
+  notAsRecorded: (install) => `The live database now records migrations/${ADOPTED_FILE} as adopted, but the file wirl sent does not match its own record of it, so nothing was written here. Run wirl migrations adopt again: while an adopted ${ADOPTED_FILE} is all the live database records, adopting again replaces that record and writes the file. If it says this again, this copy of wirl reads migration files differently from the control plane: update it (npm install -g ${install.cli}${hasFallback(install) ? `, or, to match this control plane exactly, npm install -g ${install.tarball.cli}` : ""}).`,
   unwritten: (code) => `The live database now records migrations/${ADOPTED_FILE} as adopted, but wirl could not write that file here (${code}). Make migrations/ a folder you can write that holds no .sql file, then run wirl migrations adopt again: while an adopted ${ADOPTED_FILE} is all the live database records, adopting again replaces that record and writes the file.`,
   nothingWritten: "Nothing was written to migrations/.",
   /**
@@ -6887,7 +6921,7 @@ async function adoptIntoProject(creds, options) {
   const read = await readMigrations([{ name: ADOPTED_FILE, text: answer.file.text }], []);
   const [file, ...others] = read.ok ? read.files : [];
   if (file === void 0 || others.length > 0 || file.sha256 !== answer.file.sha256 || file.statements.length !== answer.file.statements) {
-    throw new CliError(ADOPT_SENTENCES2.notAsRecorded(installFor(creds.apiOrigin).cli));
+    throw new CliError(ADOPT_SENTENCES2.notAsRecorded(installFor(creds.apiOrigin)));
   }
   const path = await writeAdopted(projectDir, answer.file.text);
   const { recordLocalAdoption: recordLocalAdoption2 } = await Promise.resolve().then(() => (init_migrations_local(), migrations_local_exports));
@@ -7862,6 +7896,11 @@ function refuseUnlessNames(names) {
     throw new CliError(`${JSON.stringify(value)} is not ${what} name. ${validateSlug(value).message ?? ""}`.trimEnd());
   }
 }
+function npmFallbackLines() {
+  const origin = apiOriginFromEnv();
+  const install = installFor(origin);
+  return hasFallback(install) ? ["", `${fallbackWhen(namedControlPlane(origin))} install the wirl CLI from the control plane instead (npm install -g ${install.tarball.cli}) and run plain wirl where this says ${WIRL_BIN}.`] : [];
+}
 var REMOTE_DEPLOY = {
   name: "wirl_deploy",
   description: "Deploy a directory of files to a URL that colleagues can open. This server runs at app.wirl.dev and cannot read files on the machine you are on, so it returns the exact commands to run in a terminal (and makes the app first, when you name one); the upload itself happens from the machine holding the files, never through this chat. A new app is visible to everyone in the org when the org came from a company email domain; in any other org, including a personal one or one made with wirl orgs create, it starts private. Returns the URL it will get.",
@@ -7880,13 +7919,13 @@ var REMOTE_DEPLOY = {
     const directory = str(args, "directory", ".");
     const app = str(args, "app");
     if (app) await ensureRemoteApp(ctx.creds, org, app);
-    const install = installFor(apiOriginFromEnv());
     return [
       app ? `App ${app} exists in ${org}. Upload it from the machine that holds the files:` : "Upload it from the machine that holds the files:",
       "",
-      `  npm install -g ${install.cli}   # once per machine`,
-      "  wirl login                      # once per machine; opens the browser",
-      `  wirl deploy ${shellPath(directory)} --org ${shellQuote(org)}${app ? ` --app ${shellQuote(app)}` : ""}`,
+      ...NPM_PUBLISHED ? [] : [`  npm install -g ${installFor(apiOriginFromEnv()).cli}   # once per machine`],
+      `  ${WIRL_BIN} login          # once per machine; opens the browser`,
+      `  ${WIRL_BIN} deploy ${shellPath(directory)} --org ${shellQuote(org)}${app ? ` --app ${shellQuote(app)}` : ""}`,
+      ...npmFallbackLines(),
       "",
       app ? `It will be at https://${org}--${app}.${APPS_DOMAIN}.` : `The command takes the app from "app" in the project's wirl.json, else from the folder's name, makes it if it is new, and prints its URL.`,
       "Once it is deployed, wirl_list_apps shows who can open it.",
@@ -7910,12 +7949,12 @@ var REMOTE_PULL = {
     refuseUnlessNames({ org: str(args, "org"), app: str(args, "app") });
     const org = await defaultOrg(ctx.creds, str(args, "org"));
     const app = str(args, "app");
-    const install = installFor(apiOriginFromEnv());
     return [
       "Run in a terminal:",
       "",
-      ...NPM_PUBLISHED ? [] : [`  npm install -g ${install.cli}   # once per machine`],
-      `  ${WIRL_BIN} pull ${shellQuote(app)} ${shellPath(str(args, "directory", app))} --org ${shellQuote(org)}`
+      ...NPM_PUBLISHED ? [] : [`  npm install -g ${installFor(apiOriginFromEnv()).cli}   # once per machine`],
+      `  ${WIRL_BIN} pull ${shellQuote(app)} ${shellPath(str(args, "directory", app))} --org ${shellQuote(org)}`,
+      ...npmFallbackLines()
     ].join("\n");
   }
 };
@@ -7954,6 +7993,7 @@ var REMOTE_PREVIEW = {
       ...NPM_PUBLISHED ? [] : [`  npm install -g ${installFor(apiOriginFromEnv()).cli}   # once per machine`],
       `  ${WIRL_BIN} login          # once per machine; opens the browser`,
       `  ${WIRL_BIN} preview ${shellPath(directory)} --org ${shellQuote(org)}${app ? ` --app ${shellQuote(app)}` : ""}${name ? ` --name ${shellQuote(name)}` : ""}`,
+      ...npmFallbackLines(),
       "",
       ...app ? [] : [`The command takes the app from "app" in the project's wirl.json, else from the folder's name.`],
       "Once it is up, wirl_preview_fetch shows you what it actually renders.",
@@ -8015,6 +8055,7 @@ var REMOTE_MIGRATIONS_ADOPT = {
       ...NPM_PUBLISHED ? [] : [`  npm install -g ${installFor(apiOriginFromEnv()).cli}   # once per machine`],
       `  ${WIRL_BIN} login          # once per machine; opens the browser`,
       `  ${WIRL_BIN} migrations adopt ${shellPath(directory)} --org ${shellQuote(org)}${app ? ` --app ${shellQuote(app)}` : ""}`,
+      ...npmFallbackLines(),
       "",
       ...app ? [] : [`The command takes the app from "app" in the project's wirl.json, else from the folder's name.`],
       "It writes migrations/0001_init.sql beside wirl.json from the live database's shape, never a row, and the live database records it as applied.",
@@ -8034,6 +8075,7 @@ function toolsFor(mode) {
 var SERVER_INSTRUCTIONS = [
   "wirl deploys a small internal tool to a URL colleagues can open, with company sign-in, a database and vaulted API keys already wired up.",
   "Reach for it whenever what you just built should live somewhere shared instead of only on this machine.",
+  ...NPM_PUBLISHED ? [`The text below writes a command as \`wirl <command>\` for short; run one as \`${WIRL_BIN} <command>\`, which needs no install beyond Node 22.13 or later.`] : [],
   "",
   BUILD_CONTRACT,
   "",
@@ -8060,7 +8102,7 @@ async function handleRpc(request, ctx) {
       return result(id, {
         protocolVersion: negotiate(request.params?.["protocolVersion"]),
         capabilities: { tools: {} },
-        serverInfo: { name: "wirl", version: "0.0.0" },
+        serverInfo: { name: "wirl", version: ctx?.serverVersion ?? wirlVersion() },
         instructions: SERVER_INSTRUCTIONS
       });
     // Notifications carry no id and expect no reply.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirl/mcp",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "MCP server for wirl: let your coding agent deploy what it just built, privately.",
   "keywords": [
     "mcp",