create-ailk 0.24.0 → 0.25.1

package/templates/apps/mcp/src/lib/shown-offerings.ts

@@ -1,105 +0,0 @@
-/**
- * The MCP read of the site's Offerings shown set (#8933, spec D6).
- *
- * `get_pricing` and `get_offerings` answer a connected site's shown set —
- * the persisted Stripe snapshot `GET /v1/content/shown-offerings` serves
- * (#8924) — rather than its page content. apps/mcp reaches Offerings data
- * only over HTTP (#8876 D9), so this file reads that route through
- * `@working-theory/api-client` and hands the tools the current set, or
- * `null` for the content path:
- *
- * 1. The deployment's own claim first: unless `mcpCommerceClaim()` reads
- *    `claimed`, no HTTP call is made at all. The API's claim, read inside
- *    the route, still decides; this one only spares an unlicensed host the
- *    call.
- * 2. One `apiClient.offerings.shown()`, raced against
- *    `MCP_SHOWN_SET_BUDGET_MS`, so a hung API never holds a tool call.
- * 3. A refusal, a body `shownOfferingsAnswerSchema` refuses, the budget
- *    passing or a rejection is `null` and one `console.error` line.
- * 4. Otherwise `currentShownSet` — a `current` set with offerings, or `null`.
- *
- * The workspace is the API's: api-client sends the deployment's own spoke
- * key, and no tool argument names one (identity-blind). No Stripe package is
- * imported here or anywhere in apps/mcp (T7).
- *
- * T6 — every log line is `{ event, outcome }` plus an HTTP `status` or an
- * error's class name as `errName`: never a body, a message, the shown set, a
- * lookup key, an id, a name or a description. The log calls live here
- * because the tool files may not call `console.*`.
- */
-
-import { apiClient } from "@working-theory/api-client";
-import { currentShownSet } from "@working-theory/content-adapters";
-import {
-  shownOfferingsAnswerSchema,
-  type WorkspaceShownSetWire,
-} from "@working-theory/validation";
-
-import { mcpCommerceClaim } from "./commerce-claim.js";
-
-/** The longest one tool call waits on the shown set before answering content. */
-export const MCP_SHOWN_SET_BUDGET_MS = 5000;
-
-const OVER_BUDGET = Symbol("over-budget");
-
-/** An error's class name only — never its message, which may carry Stripe text. */
-function errName(err: unknown): string {
-  return err instanceof Error ? err.constructor.name : typeof err;
-}
-
-/** The site's current shown set, or `null` for the content path. */
-export async function mcpCurrentShownSet(): Promise<WorkspaceShownSetWire | null> {
-  if (mcpCommerceClaim() !== "claimed") return null;
-
-  // Caught before the race, so a rejection after the budget is never unhandled.
-  const read = apiClient.offerings.shown().catch((err: unknown) => {
-    console.error({
-      event: "shown-offerings",
-      outcome: "unreachable",
-      errName: errName(err),
-    });
-    return null;
-  });
-  let timer: NodeJS.Timeout | undefined;
-  const budget = new Promise<typeof OVER_BUDGET>((resolve) => {
-    timer = setTimeout(() => resolve(OVER_BUDGET), MCP_SHOWN_SET_BUDGET_MS);
-  });
-  let res: Awaited<typeof read> | typeof OVER_BUDGET;
-  try {
-    res = await Promise.race([read, budget]);
-  } finally {
-    clearTimeout(timer);
-  }
-
-  if (res === OVER_BUDGET) {
-    console.error({ event: "shown-offerings", outcome: "over_budget" });
-    return null;
-  }
-  if (res === null) return null;
-  if (!res.ok) {
-    console.error({
-      event: "shown-offerings",
-      outcome: "refused",
-      status: res.status,
-    });
-    return null;
-  }
-  const parsed = shownOfferingsAnswerSchema.safeParse(res.body);
-  if (!parsed.success) {
-    console.error({ event: "shown-offerings", outcome: "unreadable" });
-    return null;
-  }
-  return currentShownSet(parsed.data);
-}
-
-/**
- * Logs a shown-set mapping that threw (D12): the tool then answers its
- * content path, so no `ZodError` message ever reaches the agent.
- */
-export function reportMappingFailure(err: unknown): void {
-  console.error({
-    event: "shown-offerings",
-    outcome: "mapping_failed",
-    errName: errName(err),
-  });
-}

package/templates/apps/mcp/src/lib/site-config.ts

@@ -1,53 +0,0 @@
-/**
- * The deployment's `_site.mdx`, read once per content root (#7169).
- *
- * `read_content` answers through `readContentDocument` in
- * `@working-theory/content-adapters`, which takes the parsed site config for
- * the `HomePage` graph and the `origin` read. That package may not import
- * `@working-theory/site-config` (`architecture.yaml`), so the read stays with
- * each app: this is the same reader `apps/api/src/routes/content/get-page.ts`
- * carries — the one duplication the import rule leaves, kept identical so a
- * `HomePage` read through the tool is the route's to the byte. The rejected
- * alternative, `@working-theory/aeo`'s `loadSitewideIdentity`, applies its own
- * acceptance rules and a parent-directory fallback, which could make the two
- * differ on an edge site.
- *
- * A local read with the client-safe `/schema` entry:
- * `@working-theory/site-config/server` imports `server-only`, which throws
- * outside a React Server Components runtime.
- */
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-import {
-  SiteConfigSchema,
-  type SiteConfig,
-} from "@working-theory/site-config/schema";
-import { parse as parseYaml } from "yaml";
-
-const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---/;
-
-/** `_site.mdx` per content root, read once; `null` when it does not load. */
-const siteConfigByRoot = new Map<string, SiteConfig | null>();
-
-/**
- * The deployment's `_site.mdx`, validated against `SiteConfigSchema`, or
- * `undefined` on any failure (absent, unreadable, invalid).
- */
-export function readSiteConfig(contentRoot: string): SiteConfig | undefined {
-  if (!siteConfigByRoot.has(contentRoot)) {
-    let config: SiteConfig | null = null;
-    try {
-      const raw = readFileSync(join(contentRoot, "_site.mdx"), "utf8");
-      const match = FRONTMATTER_RE.exec(raw);
-      if (match) {
-        const parsed = SiteConfigSchema.safeParse(parseYaml(match[1] ?? ""));
-        if (parsed.success) config = parsed.data;
-      }
-    } catch {
-      // Absent or unreadable — no site.
-    }
-    siteConfigByRoot.set(contentRoot, config);
-  }
-  return siteConfigByRoot.get(contentRoot) ?? undefined;
-}

package/templates/apps/mcp/src/lib/stripe-tax-signal.ts

@@ -1,59 +0,0 @@
-/**
- * stripe-tax-signal — reads `commerce.stripe_tax` from project.yaml (#5949 D4).
- *
- * The declaration the audit's `tax-code-when-stripe-tax` rule grades against:
- * "this site's Stripe account has Stripe Tax enabled, so every priced page owes
- * a `stripe.taxCode`". Declarative only — nothing here calls Stripe, and no
- * license claim is read.
- *
- * The actual YAML read + field extraction delegates to `loadCommerceConfig`
- * (`@working-theory/aeo`, exported from the package root since #6012) — this
- * file's own job is the directory PROBE: apps run from their own dirs in
- * dev/build (`apps/mcp/`) but from repo root in some test setups, mirroring
- * `apps/mcp/src/lib/locales.ts`'s own project.yaml probe (the same three
- * candidates it walks; `apps/*` may not import `apps/*`, so a shared probe
- * helper isn't an option either — only the parse/extract logic was the
- * duplicate #6012 removes).
- *
- * NEVER throws. An unreadable, absent, malformed or non-boolean value all
- * resolve to `undefined` — the site declares no Stripe Tax posture, and the
- * rule passes saying so.
- */
-
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-
-import { loadCommerceConfig } from "@working-theory/aeo";
-
-/**
- * Probe likely locations for project.yaml. Apps run from their own dirs in
- * dev/build (`apps/mcp/`) but from repo root in some test setups — the same
- * three candidates `locales.ts` walks.
- */
-function resolveProjectYamlPath(cwd: string): string {
-  const candidates = [
-    join(cwd, "project.yaml"),
-    join(cwd, "..", "project.yaml"),
-    join(cwd, "..", "..", "project.yaml"),
-  ];
-  for (const candidate of candidates) {
-    try {
-      readFileSync(candidate, "utf8");
-      return candidate;
-    } catch {
-      // continue
-    }
-  }
-  return candidates[0] ?? join(cwd, "project.yaml");
-}
-
-/**
- * `commerce.stripe_tax` at `projectRoot` (default: the process cwd), or
- * `undefined` when the site declares none.
- */
-export function readStripeTaxSignal(
-  projectRoot: string = process.cwd(),
-): boolean | undefined {
-  const resolvedPath = resolveProjectYamlPath(projectRoot);
-  return loadCommerceConfig(dirname(resolvedPath)).stripeTaxEnabled;
-}

package/templates/apps/mcp/src/request-context.ts

@@ -1,52 +0,0 @@
-/**
- * Per-request context for @working-theory/mcp, shared by the HTTP transport
- * and the MCP lead-write tools (#8073).
- *
- * Deliberately dependency-free beyond `@working-theory/api-client` (already
- * loaded by every tool): `http-transport.ts` imports Fastify and the full
- * HTTP stack, and `src/index.ts`'s stdio branch dynamic-imports `server.js`
- * specifically to avoid loading that stack for a local stdio caller. A tool
- * importing `trustedCallerAddress` straight from `http-transport.ts` would
- * pull Fastify into every stdio boot and, worse, close an import cycle
- * (`http-transport.ts` → `server.ts` → `tools/*.ts` → `http-transport.ts`).
- * This module sits below both: `http-transport.ts` populates the store,
- * the tools read it, neither imports the other.
- */
-
-import { AsyncLocalStorage } from "node:async_hooks";
-
-import { visitorForwardHeaders } from "@working-theory/api-client";
-
-/**
- * The caller address the transport trusted for the POST request currently
- * being handled — `request.ip`, Fastify's own `trustProxy`-resolved value
- * (the Vercel entry trusts exactly one hop, #8070 D5), never the raw,
- * caller-forgeable leftmost `X-Forwarded-For` entry. Populated by
- * `http-transport.ts` for the duration of one `transport.handleRequest()`
- * call and read by the three MCP lead-write tools (#8073) so they can
- * forward it to the hub without the tool gaining an identity argument.
- * `undefined` outside an HTTP request — stdio has no client address to
- * forward.
- */
-export const trustedCallerAddress = new AsyncLocalStorage<string>();
-
-/**
- * The two visitor-forwarding headers (`x-ailk-visitor-ip`,
- * `x-ailk-visitor-forward-key`) for the request this call is running inside,
- * or `undefined` when there is no trusted address for this call (not an HTTP
- * request), no `AILK_VISITOR_FORWARD_KEY`, or `visitorForwardHeaders` itself
- * declines (an unsafe transport, an unsafe key value). Read by the lead-write
- * tools right before they call the hub (#8073).
- */
-export function visitorForwardHeadersForThisCall():
-  | Record<string, string>
-  | undefined {
-  const address = trustedCallerAddress.getStore();
-  if (!address) return undefined;
-  return visitorForwardHeaders(
-    {
-      get: (name: string) => (name === "x-forwarded-for" ? address : null),
-    },
-    process.env.AILK_VISITOR_FORWARD_KEY,
-  );
-}

package/templates/apps/mcp/src/server.ts

@@ -1,343 +0,0 @@
-/**
- * MCP server factory.
- *
- * Creates and configures the McpServer instance with all registered tools.
- * The server is returned unconnected — callers attach a transport (stdio in
- * production, in-memory in tests).
- *
- * Tool names + descriptions + input shapes come from the canonical catalog
- * exported by `@working-theory/metadata` (issue #209). The catalog is the single source
- * of truth shared with `apps/web /.well-known/mcp` for agent discovery.
- * Handlers continue to live in `apps/mcp/src/tools/*` — this module wires
- * each catalog entry to its handler.
- */
-
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import {
-  getMcpToolRegistrations,
-  OSS_DISABLED_TOOLS,
-  type McpCatalogOptions,
-  type McpToolRegistration,
-} from "@working-theory/metadata";
-
-import { isModuleEnabled } from "./config/modules.js";
-import {
-  mcpCommerceClaim,
-  mcpFeatureGateOverride,
-  mcpHeldFeatures,
-} from "./lib/commerce-claim.js";
-import { notFoundError } from "./lib/errors.js";
-import { UNSERVED_MCP_TOOLS } from "./lib/topology.generated.js";
-import { ailkAudit } from "./tools/audit.js";
-import { ailkCaptureLead } from "./tools/capture_lead.js";
-import { ailkCreateProject } from "./tools/create_project.js";
-import { ailkGetBusinessHours } from "./tools/get_business_hours.js";
-import { ailkGetFaq } from "./tools/get_faq.js";
-import { ailkGetLocations } from "./tools/get_locations.js";
-import { ailkGetOfferings } from "./tools/get_offerings.js";
-import { ailkGetPricing } from "./tools/get_pricing.js";
-import { ailkGetSiteInfo } from "./tools/get_site_info.js";
-import { ailkListPages } from "./tools/list_pages.js";
-import { ailkPurchase } from "./tools/purchase.js";
-import { ailkReadContent } from "./tools/read_content.js";
-import { ailkRequestCallback } from "./tools/request_callback.js";
-import { ailkSearchContent } from "./tools/search_content.js";
-import { ailkSubscribeNewsletter } from "./tools/subscribe_newsletter.js";
-
-/**
- * Tool-name → handler map. Each handler accepts the parsed input the SDK
- * passes through after Zod validation against the catalog input shape.
- *
- * Cast via `never` is safe: each handler validates its input via its own
- * Zod parse before doing real work (see apps/mcp/src/tools/*.ts).
- */
-const HANDLERS: Record<string, (input: unknown) => Promise<unknown>> = {
-  start_purchase: (input) => ailkPurchase(input as never),
-  list_pages: (input) => ailkListPages(input as never),
-  read_content: (input) => ailkReadContent(input as never),
-  search_content: (input) => ailkSearchContent(input as never),
-  get_site_info: (input) => ailkGetSiteInfo(input as never),
-  get_business_hours: (input) => ailkGetBusinessHours(input as never),
-  get_locations: (input) => ailkGetLocations(input as never),
-  get_offerings: (input) => ailkGetOfferings(input as never),
-  get_pricing: (input) => ailkGetPricing(input as never),
-  get_faq: (input) => ailkGetFaq(input as never),
-  audit: (input) => {
-    const { slug, type, url } = input as {
-      slug?: string;
-      type?: string;
-      url?: string;
-    };
-    const handlerInput = url !== undefined ? { url } : { slug: slug!, type };
-    return ailkAudit(handlerInput as never);
-  },
-  capture_lead: (input) => ailkCaptureLead(input as never),
-  subscribe_newsletter: (input) => ailkSubscribeNewsletter(input as never),
-  request_callback: (input) => ailkRequestCallback(input as never),
-  create_project: (input) => ailkCreateProject(input as never),
-};
-
-type ToolHandler = (input: unknown) => Promise<unknown>;
-
-/**
- * Module-conditional tool handlers — the FILE-grain half of S1's registration
- * gate (#5182).
- *
- * `shouldRegister` already keeps a paid module's tools out of the registered
- * catalog when the module is absent, but that is a RUNTIME filter: a static
- * `import` of the handler still pins the file into the TYPE graph, so an OSS
- * strip that deletes it reds `tsc`. A literal `await import()` does not help —
- * `import()` defers evaluation, not resolution, so `tsc` resolves the specifier
- * either way and reports TS2307 once the file is gone.
- *
- * The specifier therefore comes from this table rather than being written
- * inline, which is what makes it non-literal at the call site and so
- * unresolvable by `tsc`. The cast in {@link resolveHandler} is the load-bearing
- * line: `import(nonLiteral)` yields `any`, and the cast is the only thing
- * restoring a type at the module boundary.
- *
- * Every entry here is a slice file the strip deletes; every entry's catalog
- * row carries the matching `module` tag, so `shouldRegister` and this table
- * appear or vanish together.
- */
-const MODULE_TOOL_ENTRIES: Record<
-  string,
-  { readonly specifier: string; readonly exportName: string }
-> = {
-  // #4416 — the scheduling twins of GET /v1/schedule/availability and
-  // POST /v1/schedule/book. Anonymous, identity-blind, credential-free: the
-  // scheduling credential lives in apps/api, which these reach via api-client.
-  list_availability: {
-    specifier: "./tools/list_availability.js",
-    exportName: "ailkListAvailability",
-  },
-  get_event_meta: {
-    specifier: "./tools/get_event_meta.js",
-    exportName: "ailkGetEventMeta",
-  },
-  create_booking: {
-    specifier: "./tools/create_booking.js",
-    exportName: "ailkCreateBooking",
-  },
-  // #8843 D5 — the twin of GET /v1/schedule/meetings.
-  list_meetings: {
-    specifier: "./tools/list_meetings.js",
-    exportName: "ailkListMeetings",
-  },
-  // D-48 signal-collectors — the flow engine's MCP twins of GET
-  // /v1/flows/:slug and POST /v1/flows/:slug/steps. Anonymous, identity-blind;
-  // free-anonymous status is now module-gated rather than unconditional.
-  get_flow: { specifier: "./tools/get_flow.js", exportName: "ailkGetFlow" },
-  submit_flow_step: {
-    specifier: "./tools/submit_flow_step.js",
-    exportName: "ailkSubmitFlowStep",
-  },
-};
-
-/**
- * Resolves a tool name to its handler: the statically-imported map first, then
- * the module-conditional table. Called from inside the already-`async`
- * `server.tool` callback so {@link createMcpServer} stays synchronous — seven
- * files call it that way, one of them production (`src/index.ts`), and making
- * it async would rewrite all seven for no gain.
- */
-async function resolveHandler(name: string): Promise<ToolHandler> {
-  const direct = HANDLERS[name];
-  if (direct) return direct;
-
-  const entry = MODULE_TOOL_ENTRIES[name];
-  if (!entry) {
-    throw new Error(`MCP catalog drift: no handler for tool '${name}'`);
-  }
-  const mod = (await import(entry.specifier)) as Record<
-    string,
-    ToolHandler | undefined
-  >;
-  const fn = mod[entry.exportName];
-  if (!fn) {
-    throw new Error(
-      `MCP slice drift: '${entry.specifier}' does not export '${entry.exportName}'`,
-    );
-  }
-  return fn;
-}
-
-/**
- * Tool descriptor returned by {@link listRegisteredTools}. A minimal shape
- * sufficient for callers that need to assert which tools are registered
- * (e.g., the S15a regression test) without depending on the SDK's internal
- * `_registeredTools` field.
- */
-export interface RegisteredToolDescriptor {
-  name: string;
-  description: string;
-}
-
-/**
- * Whether a catalog registration entry should register on this build/boot —
- * four filters:
- *
- *  0. the topology filter (#8070 D7): a name in the generated seam's
- *     `UNSERVED_MCP_TOOLS` is never served — `create_project` on a spoke,
- *     which carries no create-ailk CLI for it to spawn. `[]` on a hub. The
- *     web manifest drops the same list, so the two surfaces agree;
- *  1. the OSS-disabled filter (static per-name set; empty since #5971);
- *  2. the module-presence filter (S1, #5088): a tool tagged with `module`
- *     (e.g. `create_booking` carrying `module: "scheduling"`) registers only
- *     when {@link isModuleEnabled} says its module is present, the same way
- *     its `apps/api` HTTP route is module-conditional in `server.ts` there —
- *     so a tool and its route appear or vanish together, holding API↔MCP
- *     parity;
- *  3. the ADD-ON CLAIM filter (#5971): a tool tagged `addon: "commerce"`
- *     registers only on a deployment that positively holds the `commerce`
- *     licence claim. Deliberately NOT the module filter — D-64/#5796 moved
- *     the commerce primitives off module gating precisely so that adding
- *     commerce to a live site is a licence change that lands no files on its
- *     repo, and "keyless site" / "keyed site" name the LICENCE, not an env
- *     allowlist.
- *
- * The claim is the memoised claim, re-read every `MCP_CLAIM_REFRESH_MS`; this
- * stays synchronous — see `lib/commerce-claim.ts`. {@link isServedNow}
- * re-applies this filter at call time.
- *
- * The LICENCE-FEATURE gate (#7136) is not repeated here: it applies upstream,
- * in `getMcpToolRegistrations()`, through {@link catalogOptionsForThisBoot} —
- * only the catalog knows `MCP_FEATURE_GATE_MODE`. `catalog-drift.test.ts`
- * pins that upstream filter from this side in every claim state.
- */
-function shouldRegister(reg: {
-  name: string;
-  module?: string;
-  addon?: "commerce";
-}): boolean {
-  if (UNSERVED_MCP_TOOLS.includes(reg.name)) return false;
-  if (OSS_DISABLED_TOOLS.has(reg.name)) return false;
-  if (reg.module && !isModuleEnabled(reg.module)) return false;
-  if (reg.addon === "commerce" && mcpCommerceClaim() !== "claimed")
-    return false;
-  return true;
-}
-
-/**
- * Call-time gate (#7315). True when a server built NOW would register this
- * tool — the exact same predicate {@link listRegisteredTools} computes, so
- * the call-time answer and a fresh session's `tools/list` cannot disagree by
- * construction. A session keeps the tool list it registered at `initialize`;
- * this makes each listed entry refuse within `MCP_CLAIM_REFRESH_MS` of a
- * re-read that drops its claim.
- */
-function isServedNow(reg: McpToolRegistration): boolean {
-  return listRegisteredTools().some((current) => current.name === reg.name);
-}
-
-/**
- * The {@link McpCatalogOptions} this boot's claims imply — passed to
- * `getMcpToolRegistrations()` so the upstream catalog filter and
- * {@link shouldRegister} agree by construction rather than by coincidence.
- * Carries the held licence features (#7136); the gate mode is the catalog's
- * `MCP_FEATURE_GATE_MODE` unless a test has overridden it.
- */
-function catalogOptionsForThisBoot(): McpCatalogOptions {
-  const featureGate = mcpFeatureGateOverride();
-  return {
-    addons: { commerce: mcpCommerceClaim() === "claimed" },
-    features: [...mcpHeldFeatures()],
-    ...(featureGate ? { featureGate } : {}),
-  };
-}
-
-/**
- * The one-release warning cycle's boot report (#7136): for every tool this
- * boot serves whose licence `feature` the deployment does not hold, calls
- * `warn` once, naming the tool and the feature, and returns their names.
- *
- * Called ONCE per process from `bootMcp()` (`boot.ts`, which both `index.ts`
- * and the Vercel entry `app.ts` await), after the claim resolves — never
- * from {@link createMcpServer}, which runs once per HTTP session. In refuse
- * mode it finds nothing: the upstream catalog filter has already dropped
- * every such tool, so it needs no mode check of its own. Defaults to
- * `console.warn` — stderr, never stdout, which is the stdio transport's
- * JSON-RPC channel. The message carries two catalog literals and nothing
- * read from the licence.
- */
-export function reportUnlicensedProTools(
-  warn: (message: string) => void = console.warn,
-): string[] {
-  const held = mcpHeldFeatures();
-  const unlicensed = getMcpToolRegistrations(catalogOptionsForThisBoot())
-    .filter(shouldRegister)
-    .filter((reg) => reg.feature !== undefined && !held.has(reg.feature));
-  for (const reg of unlicensed) {
-    warn(
-      `[mcp] licence feature "${reg.feature}" is not held by this deployment — ` +
-        `tool "${reg.name}" is served in this release only; the next release ` +
-        `stops serving it unless the licence includes "${reg.feature}".`,
-    );
-  }
-  return unlicensed.map((reg) => reg.name);
-}
-
-/**
- * Returns the list of tools that {@link createMcpServer} will register, after
- * the OSS catalog filter ({@link OSS_DISABLED_TOOLS}), the module-presence
- * filter and the add-on claim filter are applied. Pure — no server instance
- * is constructed.
- *
- * Consumed by `apps/mcp/__tests__/purchase-disabled.test.ts`, which drives
- * both halves of the claim matrix: `start_purchase` absent on a keyless boot,
- * present on a claimed one.
- */
-export function listRegisteredTools(): RegisteredToolDescriptor[] {
-  return getMcpToolRegistrations(catalogOptionsForThisBoot())
-    .filter(shouldRegister)
-    .map((reg) => ({ name: reg.name, description: reg.description }));
-}
-
-/**
- * Creates a configured McpServer with all AILK tools registered, less any
- * tool this topology does not serve (`UNSERVED_MCP_TOOLS`, #8070 D7), less any
- * tool name in {@link OSS_DISABLED_TOOLS}, less any tool whose `module` is
- * not enabled on this build (S1, #5088), and less any `addon`-tagged tool
- * whose claim this deployment does not hold (#5971) — see
- * {@link shouldRegister}. Every filter is applied defensively here even
- * though the upstream `getMcpToolRegistrations()` already excludes the same
- * entries: a belt-and-braces guard so a regression in the metadata package
- * can't accidentally register something this boot should not serve.
- */
-export function createMcpServer(): McpServer {
-  const server = new McpServer({
-    name: "ailk",
-    version: "0.1.0",
-  });
-
-  for (const reg of getMcpToolRegistrations(catalogOptionsForThisBoot())) {
-    if (!shouldRegister(reg)) {
-      continue;
-    }
-    // Boot-time drift detection is preserved: a registered name must be
-    // resolvable from ONE of the two tables, checked here rather than at first
-    // invocation, so a catalog/handler mismatch still fails at startup.
-    if (!HANDLERS[reg.name] && !MODULE_TOOL_ENTRIES[reg.name]) {
-      throw new Error(`MCP catalog drift: no handler for tool '${reg.name}'`);
-    }
-    server.tool(reg.name, reg.description, reg.inputShape, async (input) => {
-      if (
-        (reg.feature !== undefined || reg.addon !== undefined) &&
-        !isServedNow(reg)
-      ) {
-        return {
-          content: [
-            { type: "text", text: JSON.stringify(notFoundError("Not found")) },
-          ],
-        };
-      }
-      const handler = await resolveHandler(reg.name);
-      const result = await handler(input);
-      return {
-        content: [{ type: "text", text: JSON.stringify(result) }],
-      };
-    });
-  }
-
-  return server;
-}