@shipstatic/mcp 1.0.0-beta.0 → 1.0.0-beta.10

package/dist/server.js

@@ -1,186 +1,59 @@
-import { createRequire } from 'node:module';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { LABEL_CONSTRAINTS, PASSWORD_CONSTRAINTS } from '@shipstatic/ship';
+import { DeploymentVia } from '@shipstatic/types';
 import { z } from 'zod';
 import { call } from './call.js';
-const { version } = createRequire(import.meta.url)('../package.json');
-const OPEN_WORLD = { openWorldHint: true };
-const READ = {
-    readOnlyHint: true,
-    destructiveHint: false,
-    idempotentHint: true,
-    ...OPEN_WORLD,
-};
-const CREATE = { readOnlyHint: false, destructiveHint: false, ...OPEN_WORLD };
-const WRITE = {
-    readOnlyHint: false,
-    destructiveHint: false,
-    idempotentHint: true,
-    ...OPEN_WORLD,
-};
-const DESTRUCTIVE = {
-    readOnlyHint: false,
-    destructiveHint: true,
-    idempotentHint: true,
-    ...OPEN_WORLD,
-};
-const INSTRUCTIONS = `ShipStatic deploys static websites instantly. Free, no account required.
+import { registerAccountTools } from './tools.js';
+import { ANNOTATIONS, DESCRIPTION_BLOCKS, INSTRUCTION_BLOCKS, PARAM_DESCRIPTIONS, PUBLIC_EXPIRY, SERVER_NAME, UPLOAD_TOOL_NAME, } from './vocabulary.js';
+// Destructured so the fifteen registrations below read as they always have.
+// The definitions live in `vocabulary.ts` because the hosted transport speaks
+// the same ones — that file records what is shared, what is not, and why.
+const { CREATE } = ANNOTATIONS;
+const B = INSTRUCTION_BLOCKS;
+const D = DESCRIPTION_BLOCKS;
+// Composed from the shared blocks plus the two sentences that are genuinely
+// stdio's: how files arrive (a filesystem path) and how a caller
+// authenticates (`SHIP_TOKEN`). The hosted transport composes the same blocks
+// around its own two.
+const INSTRUCTIONS = `${B.opening}
 
-To deploy: call deployments_upload with the build output directory path. The site is live immediately. To make the site private, pass \`password\` — visitors must unlock before viewing, including on any custom domains pointing at it.
+To deploy: call ${UPLOAD_TOOL_NAME} with the build output directory path. ${B.liveAndPassword}
 
-Without SHIP_TOKEN, deployments are public and expire in 3 days. The response includes a claim URL — always show the deployment URL and the claim URL to the user so they can keep the site permanently.
+Without SHIP_TOKEN, deployments are public and expire in ${PUBLIC_EXPIRY}. ${B.claim}
 
 With SHIP_TOKEN configured, deployments go to the user's account and never expire. Listing, managing, and domain operations also require SHIP_TOKEN.
 
-Concepts:
-- Deployment: an immutable set of files with an instant URL (e.g. happy-cat-abc1234.shipstatic.com). No setup needed.
-- Domain: a custom domain (e.g. www.example.com) pointing to a deployment. Optional. Subdomains only — not apex domains.
+${B.conceptsHeader}
+${B.deploymentConcept}
+${B.domainConcept}
 
-To add a custom domain: domains_validate → domains_set → domains_records (show DNS records to user) → user configures DNS → domains_verify.`;
-export function createServer(ship) {
+${B.domainWorkflow}`;
+/**
+ * Builds the stdio server's full 15-tool surface over an injected client.
+ */
+export function createServer(ship, options) {
+    const { version, via = DeploymentVia.MCP } = options;
     const server = new McpServer({
-        name: 'shipstatic',
+        name: SERVER_NAME,
         version,
     }, {
         instructions: INSTRUCTIONS,
     });
     // Deployments
-    server.registerTool('deployments_upload', {
-        description: 'Deploy a static site instantly — free, no account or API key required. Returns the live URL, file count, and size. Without SHIP_TOKEN, the response includes a claim URL (site expires in 3 days) — always show both the deployment URL and claim URL to the user. To make the site private, pass `password`; always show the password to the user if you set one.',
+    server.registerTool(UPLOAD_TOOL_NAME, {
+        description: `Deploy a static site instantly — ${D.free}. Returns the live URL, file count, and size. Without SHIP_TOKEN, the response includes a claim URL (site expires in ${PUBLIC_EXPIRY}) — always show both the deployment URL and claim URL to the user. ${D.password}`,
         annotations: CREATE,
         inputSchema: {
             path: z
                 .string()
                 .describe('Absolute path to the build output directory to deploy (e.g. "/Users/me/project/dist")'),
-            labels: z
-                .array(z.string())
-                .optional()
-                .describe(`Labels for organizing deployments (e.g. ["production", "v1.2"]). Lowercase, ${LABEL_CONSTRAINTS.MIN_LENGTH}-${LABEL_CONSTRAINTS.MAX_LENGTH} chars, allows . _ - separators.`),
-            password: z
-                .string()
-                .optional()
-                .describe(`Optional password to gate the deployment behind an unlock prompt (${PASSWORD_CONSTRAINTS.MIN_LENGTH}–${PASSWORD_CONSTRAINTS.MAX_LENGTH} characters; whitespace significant). Visitors must enter this password before viewing the site, including on any custom domains pointing at it.`),
-        },
-    }, ({ path, labels, password }) => call(() => ship.deployments.upload(path, { labels, password, via: 'mcp' })));
-    server.registerTool('deployments_list', {
-        description: 'List all deployments with their URLs, status, labels, and password protection state.',
-        annotations: READ,
-    }, () => call(() => ship.deployments.list()));
-    server.registerTool('deployments_get', {
-        description: 'Get deployment details including URL, status, file count, size, labels, and password protection state.',
-        annotations: READ,
-        inputSchema: {
-            deployment: z
-                .string()
-                .describe('Deployment hostname (e.g. "happy-cat-abc1234.shipstatic.com"). Returned by deployments_upload or deployments_list.'),
-        },
-    }, ({ deployment }) => call(() => ship.deployments.get(deployment)));
-    server.registerTool('deployments_set', {
-        description: 'Update deployment labels. Replaces all existing labels.',
-        annotations: WRITE,
-        inputSchema: {
-            deployment: z
-                .string()
-                .describe('Deployment hostname (e.g. "happy-cat-abc1234.shipstatic.com"). Use deployments_list to find deployments.'),
-            labels: z
-                .array(z.string())
-                .describe('Labels to set. Replaces all existing labels. Pass empty array to clear.'),
-        },
-    }, ({ deployment, labels }) => call(() => ship.deployments.set(deployment, { labels })));
-    server.registerTool('deployments_delete', {
-        description: 'Permanently delete a deployment and its files. You MUST confirm with the user before calling this tool, referencing the deployment.',
-        annotations: DESTRUCTIVE,
-        inputSchema: {
-            deployment: z
-                .string()
-                .describe('Deployment hostname to delete (e.g. "happy-cat-abc1234.shipstatic.com")'),
-        },
-    }, ({ deployment }) => call(() => ship.deployments.delete(deployment)));
-    // Domains
-    server.registerTool('domains_set', {
-        description: 'Create or update a custom domain. Can reserve a name (omit deployment), link it to a deployment, switch deployments, or update labels. After creating, call domains_records and show the DNS records to the user.',
-        annotations: WRITE,
-        inputSchema: {
-            domain: z.string().describe('Domain name (e.g. "www.example.com" or "blog.example.com")'),
-            deployment: z
-                .string()
-                .optional()
-                .describe('Deployment to serve on this domain (e.g. "happy-cat-abc1234.shipstatic.com"). Omit to reserve the domain without linking.'),
-            labels: z
-                .array(z.string())
-                .optional()
-                .describe('Labels for organizing domains (e.g. ["production"]).'),
-        },
-    }, ({ domain, deployment, labels }) => call(() => ship.domains.set(domain, { deployment, labels })));
-    server.registerTool('domains_list', {
-        description: 'List all domains with their URLs, linked deployment, and verification status.',
-        annotations: READ,
-    }, () => call(() => ship.domains.list()));
-    server.registerTool('domains_get', {
-        description: 'Get domain details including URL, linked deployment, verification status, and labels.',
-        annotations: READ,
-        inputSchema: {
-            domain: z
-                .string()
-                .describe('Domain name (e.g. "www.example.com"). Use domains_list to find names.'),
-        },
-    }, ({ domain }) => call(() => ship.domains.get(domain)));
-    server.registerTool('domains_records', {
-        description: 'Get the DNS records the user needs to configure at their DNS provider. Call after domains_set. You MUST show the returned records to the user.',
-        annotations: READ,
-        inputSchema: {
-            domain: z
-                .string()
-                .describe('Domain name. Must be a domain previously created with domains_set.'),
-        },
-    }, ({ domain }) => call(() => ship.domains.records(domain)));
-    server.registerTool('domains_dns', {
-        description: 'Look up the DNS provider for a domain (e.g. Cloudflare, Namecheap). Helps the user know where to configure their DNS records.',
-        annotations: READ,
-        inputSchema: {
-            domain: z
-                .string()
-                .describe('Domain name to look up DNS provider for (e.g. "www.example.com")'),
-        },
-    }, ({ domain }) => call(() => ship.domains.dns(domain)));
-    server.registerTool('domains_share', {
-        description: 'Get a shareable DNS setup hash for a domain. The hash can be shared with the user so they can view the required DNS records without needing an API key.',
-        annotations: READ,
-        inputSchema: {
-            domain: z
-                .string()
-                .describe('Domain name to generate a share link for. Must be a domain previously created with domains_set.'),
-        },
-    }, ({ domain }) => call(() => ship.domains.share(domain)));
-    server.registerTool('domains_validate', {
-        description: 'Check if a domain name is valid and available before creating it. Returns the normalized form and availability.',
-        annotations: READ,
-        inputSchema: {
-            domain: z
-                .string()
-                .describe('Domain name to check (e.g. "www.example.com"). Call before domains_set to check availability.'),
-        },
-    }, ({ domain }) => call(() => ship.domains.validate(domain)));
-    server.registerTool('domains_verify', {
-        description: 'Trigger DNS verification for a custom domain. Call after the user has configured DNS records from domains_records. Verification is asynchronous — the domain status updates once DNS propagates.',
-        annotations: WRITE,
-        inputSchema: {
-            domain: z
-                .string()
-                .describe('Domain name to verify DNS for. Must be a domain previously created with domains_set.'),
-        },
-    }, ({ domain }) => call(() => ship.domains.verify(domain)));
-    server.registerTool('domains_delete', {
-        description: 'Permanently delete a domain. You MUST confirm with the user before calling this tool, referencing the domain name.',
-        annotations: DESTRUCTIVE,
-        inputSchema: {
-            domain: z.string().describe('Domain name to delete (e.g. "www.example.com")'),
-        },
-    }, ({ domain }) => call(() => ship.domains.delete(domain)));
-    // Debugging
-    server.registerTool('whoami', {
-        description: 'Show authenticated account details including email, plan, and usage.',
-        annotations: READ,
-    }, () => call(() => ship.whoami()));
+            labels: z.array(z.string()).optional().describe(PARAM_DESCRIPTIONS.labels),
+            password: z.string().optional().describe(PARAM_DESCRIPTIONS.password),
+            idempotencyKey: z.string().optional().describe(PARAM_DESCRIPTIONS.idempotencyKey),
+        },
+    }, ({ path, labels, password, idempotencyKey }) => call(() => ship.deployments.upload(path, { labels, password, idempotencyKey, via })));
+    // The other fourteen. Identical on every transport, so they live in the
+    // shared package rather than here — see tools.ts for why upload is not
+    // among them.
+    registerAccountTools(server, ship, call);
     return server;
 }

package/dist/tools.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The account-tied toolset — fourteen tools, identical on every transport.
+ *
+ * `deployments_upload` is not here, and the split is exactly the product's
+ * own shape rather than a convenience:
+ *
+ *   - **Upload is the anonymous door.** It is the one operation that works
+ *     with no account, and it is the one whose INPUT differs by transport —
+ *     a filesystem path over stdio, inline bytes over HTTP, because a Worker
+ *     has no filesystem. It also carries the Apps-SDK widget hosted-side.
+ *     So it is authored per transport, in each `server.ts`.
+ *   - **Everything else needs an identity**, and once a transport has one,
+ *     nothing about these fourteen depends on how the bytes arrived. Same
+ *     names, same schemas, same prose, same 1:1 SDK calls.
+ *
+ * That is why they live in the shared package: when the hosted transport
+ * gains OAuth it registers this function and has the complete toolset, rather
+ * than someone copying fourteen definitions into a second repo — which is the
+ * moment the two surfaces would begin to drift. The cost of doing it after
+ * the copy is a de-duplication under deadline; the cost of doing it before is
+ * this file.
+ *
+ * **The catalogue is static; identity decides what SUCCEEDS.** These are
+ * registered whether or not a credential is present — an anonymous caller
+ * sees them and gets a typed authentication error naming how to authenticate
+ * on *this* transport (the hint is `createCall`'s one per-transport argument).
+ * A tool list that changes shape under the caller would be a second, dynamic
+ * contract for an agent to track, and MCP clients cache the catalogue.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type Ship from '@shipstatic/ship';
+import type { CallFn } from './call.js';
+/**
+ * The fourteen, by name, in registration order.
+ *
+ * Exported so a second transport can state its expected catalogue as
+ * `[UPLOAD_TOOL_NAME, ...ACCOUNT_TOOL_NAMES]` instead of listing fifteen
+ * strings it would then have to keep in agreement with this file — the hosted
+ * parity fence is the consumer, and "fifteen" is otherwise a number two repos
+ * count separately.
+ *
+ * **Deliberately a list beside the registrations rather than a table they are
+ * generated from.** A `Record<name, factory>` would make the pairing
+ * structural, and it would cost the zod→handler inference every one of the
+ * fourteen one-liners below relies on: `({ deployment }) => …` is typed today
+ * from the `inputSchema` literal in the same call, and a loop over a
+ * heterogeneous table cannot correlate the two. The same guarantee costs
+ * nothing as a set comparison, and `tests/server.test.ts` makes it — through a
+ * real `tools/list`, so a registration without a name, a name without a
+ * registration, and a typo in either all turn it red.
+ */
+export declare const ACCOUNT_TOOL_NAMES: readonly ["deployments_list", "deployments_get", "deployments_set", "deployments_delete", "domains_set", "domains_list", "domains_get", "domains_records", "domains_dns", "domains_share", "domains_validate", "domains_verify", "domains_delete", "whoami"];
+export declare function registerAccountTools(server: McpServer, ship: Ship, call: CallFn): void;

package/dist/tools.js

@@ -0,0 +1,219 @@
+/**
+ * The account-tied toolset — fourteen tools, identical on every transport.
+ *
+ * `deployments_upload` is not here, and the split is exactly the product's
+ * own shape rather than a convenience:
+ *
+ *   - **Upload is the anonymous door.** It is the one operation that works
+ *     with no account, and it is the one whose INPUT differs by transport —
+ *     a filesystem path over stdio, inline bytes over HTTP, because a Worker
+ *     has no filesystem. It also carries the Apps-SDK widget hosted-side.
+ *     So it is authored per transport, in each `server.ts`.
+ *   - **Everything else needs an identity**, and once a transport has one,
+ *     nothing about these fourteen depends on how the bytes arrived. Same
+ *     names, same schemas, same prose, same 1:1 SDK calls.
+ *
+ * That is why they live in the shared package: when the hosted transport
+ * gains OAuth it registers this function and has the complete toolset, rather
+ * than someone copying fourteen definitions into a second repo — which is the
+ * moment the two surfaces would begin to drift. The cost of doing it after
+ * the copy is a de-duplication under deadline; the cost of doing it before is
+ * this file.
+ *
+ * **The catalogue is static; identity decides what SUCCEEDS.** These are
+ * registered whether or not a credential is present — an anonymous caller
+ * sees them and gets a typed authentication error naming how to authenticate
+ * on *this* transport (the hint is `createCall`'s one per-transport argument).
+ * A tool list that changes shape under the caller would be a second, dynamic
+ * contract for an agent to track, and MCP clients cache the catalogue.
+ */
+import { z } from 'zod';
+import { ANNOTATIONS } from './vocabulary.js';
+const { READ, WRITE, DESTRUCTIVE } = ANNOTATIONS;
+/**
+ * The fourteen, by name, in registration order.
+ *
+ * Exported so a second transport can state its expected catalogue as
+ * `[UPLOAD_TOOL_NAME, ...ACCOUNT_TOOL_NAMES]` instead of listing fifteen
+ * strings it would then have to keep in agreement with this file — the hosted
+ * parity fence is the consumer, and "fifteen" is otherwise a number two repos
+ * count separately.
+ *
+ * **Deliberately a list beside the registrations rather than a table they are
+ * generated from.** A `Record<name, factory>` would make the pairing
+ * structural, and it would cost the zod→handler inference every one of the
+ * fourteen one-liners below relies on: `({ deployment }) => …` is typed today
+ * from the `inputSchema` literal in the same call, and a loop over a
+ * heterogeneous table cannot correlate the two. The same guarantee costs
+ * nothing as a set comparison, and `tests/server.test.ts` makes it — through a
+ * real `tools/list`, so a registration without a name, a name without a
+ * registration, and a typo in either all turn it red.
+ */
+export const ACCOUNT_TOOL_NAMES = [
+    'deployments_list',
+    'deployments_get',
+    'deployments_set',
+    'deployments_delete',
+    'domains_set',
+    'domains_list',
+    'domains_get',
+    'domains_records',
+    'domains_dns',
+    'domains_share',
+    'domains_validate',
+    'domains_verify',
+    'domains_delete',
+    'whoami',
+];
+/**
+ * The pagination surface, shared by every list tool because it is one
+ * contract, not two. A list answers `{<collection>, cursor}` and nothing
+ * else — `cursor` carries the whole has-more signal and is null on the last
+ * page, so there is no `total` to ask for and no has-more boolean.
+ *
+ * No upper bound is stated here on purpose. The API clamps an unusable
+ * `limit` server-side and owns that number; restating a cap in the tool
+ * schema would give one fact two owners and let them drift. `min(1)` is not
+ * a cap — it rejects a value that could never mean anything.
+ */
+const PAGINATION_INPUT = {
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .optional()
+        .describe('Maximum number of items to return in one page. Omit for the server default.'),
+    cursor: z
+        .string()
+        .optional()
+        .describe("Opaque position from the previous response's `cursor` field; omit for the first page."),
+};
+/** Appended to every list tool's description — the paging contract, stated once. */
+const PAGING_NOTE = " The response's `cursor` is null on the last page; pass it back as `cursor` to fetch the next.";
+/** The deployment argument, described identically wherever it is accepted. */
+const DEPLOYMENT_EXAMPLE = 'happy-cat-abc1234.shipstatic.com';
+export function registerAccountTools(server, ship, call) {
+    // Deployments
+    server.registerTool('deployments_list', {
+        description: `List all deployments with their URLs, status, labels, and password protection state.${PAGING_NOTE}`,
+        annotations: READ,
+        inputSchema: PAGINATION_INPUT,
+    }, ({ limit, cursor }) => call(() => ship.deployments.list({ limit, cursor })));
+    server.registerTool('deployments_get', {
+        description: 'Get deployment details including URL, status, file count, size, labels, and password protection state.',
+        annotations: READ,
+        inputSchema: {
+            deployment: z
+                .string()
+                .describe(`Deployment hostname (e.g. "${DEPLOYMENT_EXAMPLE}"). Returned by deployments_upload or deployments_list.`),
+        },
+    }, ({ deployment }) => call(() => ship.deployments.get(deployment)));
+    server.registerTool('deployments_set', {
+        description: 'Update deployment labels. Replaces all existing labels.',
+        annotations: WRITE,
+        inputSchema: {
+            deployment: z
+                .string()
+                .describe(`Deployment hostname (e.g. "${DEPLOYMENT_EXAMPLE}"). Use deployments_list to find deployments.`),
+            labels: z
+                .array(z.string())
+                .describe('Labels to set. Replaces all existing labels. Pass empty array to clear.'),
+        },
+    }, ({ deployment, labels }) => call(() => ship.deployments.set(deployment, { labels })));
+    server.registerTool('deployments_delete', {
+        description: 'Permanently delete a deployment and its files. You MUST confirm with the user before calling this tool, referencing the deployment.',
+        annotations: DESTRUCTIVE,
+        inputSchema: {
+            deployment: z
+                .string()
+                .describe(`Deployment hostname to delete (e.g. "${DEPLOYMENT_EXAMPLE}")`),
+        },
+    }, ({ deployment }) => call(() => ship.deployments.delete(deployment)));
+    // Domains
+    server.registerTool('domains_set', {
+        description: 'Create or update a custom domain. Can reserve a name (omit deployment), link it to a deployment, switch deployments, or update labels. After creating, call domains_records and show the DNS records to the user.',
+        annotations: WRITE,
+        inputSchema: {
+            domain: z.string().describe('Domain name (e.g. "www.example.com" or "blog.example.com")'),
+            deployment: z
+                .string()
+                .optional()
+                .describe(`Deployment to serve on this domain (e.g. "${DEPLOYMENT_EXAMPLE}"). Omit to reserve the domain without linking.`),
+            labels: z
+                .array(z.string())
+                .optional()
+                .describe('Labels for organizing domains (e.g. ["production"]).'),
+        },
+    }, ({ domain, deployment, labels }) => call(() => ship.domains.set(domain, { deployment, labels })));
+    server.registerTool('domains_list', {
+        description: `List all domains with their URLs, linked deployment, and verification status.${PAGING_NOTE}`,
+        annotations: READ,
+        inputSchema: PAGINATION_INPUT,
+    }, ({ limit, cursor }) => call(() => ship.domains.list({ limit, cursor })));
+    server.registerTool('domains_get', {
+        description: 'Get domain details including URL, linked deployment, verification status, and labels.',
+        annotations: READ,
+        inputSchema: {
+            domain: z
+                .string()
+                .describe('Domain name (e.g. "www.example.com"). Use domains_list to find names.'),
+        },
+    }, ({ domain }) => call(() => ship.domains.get(domain)));
+    server.registerTool('domains_records', {
+        description: 'Get the DNS records the user needs to configure at their DNS provider. Call after domains_set. You MUST show the returned records to the user.',
+        annotations: READ,
+        inputSchema: {
+            domain: z
+                .string()
+                .describe('Domain name. Must be a domain previously created with domains_set.'),
+        },
+    }, ({ domain }) => call(() => ship.domains.records(domain)));
+    server.registerTool('domains_dns', {
+        description: 'Look up the DNS provider for a domain (e.g. Cloudflare, Namecheap). Helps the user know where to configure their DNS records.',
+        annotations: READ,
+        inputSchema: {
+            domain: z
+                .string()
+                .describe('Domain name to look up DNS provider for (e.g. "www.example.com")'),
+        },
+    }, ({ domain }) => call(() => ship.domains.dns(domain)));
+    server.registerTool('domains_share', {
+        description: 'Get a shareable DNS setup hash for a domain. The hash can be shared with the user so they can view the required DNS records without needing an API key.',
+        annotations: READ,
+        inputSchema: {
+            domain: z
+                .string()
+                .describe('Domain name to generate a share link for. Must be a domain previously created with domains_set.'),
+        },
+    }, ({ domain }) => call(() => ship.domains.share(domain)));
+    server.registerTool('domains_validate', {
+        description: 'Check if a domain name is valid and available before creating it. Returns the normalized form and availability.',
+        annotations: READ,
+        inputSchema: {
+            domain: z
+                .string()
+                .describe('Domain name to check (e.g. "www.example.com"). Call before domains_set to check availability.'),
+        },
+    }, ({ domain }) => call(() => ship.domains.validate(domain)));
+    server.registerTool('domains_verify', {
+        description: 'Trigger DNS verification for a custom domain. Call after the user has configured DNS records from domains_records. Verification is asynchronous — the domain status updates once DNS propagates.',
+        annotations: WRITE,
+        inputSchema: {
+            domain: z
+                .string()
+                .describe('Domain name to verify DNS for. Must be a domain previously created with domains_set.'),
+        },
+    }, ({ domain }) => call(() => ship.domains.verify(domain)));
+    server.registerTool('domains_delete', {
+        description: 'Permanently delete a domain. You MUST confirm with the user before calling this tool, referencing the domain name.',
+        annotations: DESTRUCTIVE,
+        inputSchema: {
+            domain: z.string().describe('Domain name to delete (e.g. "www.example.com")'),
+        },
+    }, ({ domain }) => call(() => ship.domains.delete(domain)));
+    // Account
+    server.registerTool('whoami', {
+        description: 'Show authenticated account details including email, plan, and usage.',
+        annotations: READ,
+    }, () => call(() => ship.whoami()));
+}