@waniwani/kit 0.1.0

package/cli/validate.mjs

@@ -0,0 +1,248 @@
+/**
+ * The build check.
+ *
+ * Structural rules first (cheap, from the filesystem), then the modules are
+ * actually imported so a broken export or a flow that fails to compile is
+ * reported here rather than as a stack trace at request time.
+ */
+
+import { readFileSync } from "node:fs";
+import { relative } from "node:path";
+
+const NAME_RE = /^[a-z0-9](?:[a-z0-9_-]*[a-z0-9])?$/;
+
+class Report {
+	constructor(root) {
+		this.root = root;
+		this.errors = [];
+		this.warnings = [];
+	}
+
+	error(where, message, hint) {
+		this.errors.push({ where, message, hint });
+	}
+
+	warn(where, message, hint) {
+		this.warnings.push({ where, message, hint });
+	}
+
+	get ok() {
+		return this.errors.length === 0;
+	}
+}
+
+function rel(root, file) {
+	return relative(root, file) || ".";
+}
+
+/** Everything the filesystem alone can tell us. */
+function checkStructure(app, report) {
+	const { root } = app;
+
+	if (!app.configFile) {
+		report.error(
+			"waniwani.config.ts",
+			"missing app config",
+			"create waniwani.config.ts with `export default defineApp({ name: '...' })`",
+		);
+	}
+
+	if (app.tools.length + app.widgets.length + app.flows.length + app.docs.length === 0) {
+		report.error(
+			".",
+			"this app exposes nothing",
+			"add a tool (tools/<name>.ts), a widget (widgets/<name>/), a flow (flows/<name>.ts), or docs (docs/<slug>.md)",
+		);
+	}
+
+	for (const widget of app.widgets) {
+		const where = rel(root, widget.dir);
+		if (!widget.contract) {
+			report.error(
+				where,
+				"missing widget.ts",
+				"every widget folder needs a widget.ts with `export default defineWidget({ ... })`",
+			);
+		}
+		if (!widget.ui) {
+			report.error(
+				where,
+				"missing ui.tsx",
+				"every widget folder needs a ui.tsx with a default-exported React component",
+			);
+		}
+	}
+
+	// Styling is Tailwind, out of the template's `src/index.css`. Nothing imports
+	// an app's own CSS, so a styles.css is a file whose rules never load — and it
+	// fails in the worst way, by rendering an unstyled widget rather than an
+	// error. Naming it here costs one deletion; missing it costs a debugging
+	// session against a bundle that never mentions the file.
+	for (const file of app.strayStyles) {
+		report.error(
+			rel(root, file),
+			"app CSS is not bundled — nothing imports this file",
+			"style with Tailwind utility classes in ui.tsx; the template's src/index.css carries the @theme tokens and the `dark` variant",
+		);
+	}
+
+	// A widget's folder name is its MCP tool name and its bundle entry name, so
+	// it has to survive both.
+	const named = [
+		...app.tools.map((t) => ({ kind: "tool", name: t.name, where: rel(root, t.file) })),
+		...app.widgets.map((w) => ({ kind: "widget", name: w.name, where: rel(root, w.dir) })),
+	];
+
+	const seen = new Map();
+	for (const entry of named) {
+		if (!NAME_RE.test(entry.name)) {
+			report.error(
+				entry.where,
+				`"${entry.name}" is not a valid MCP tool name`,
+				"use lowercase letters, digits, dashes and underscores",
+			);
+		}
+		const previous = seen.get(entry.name);
+		if (previous) {
+			report.error(
+				entry.where,
+				`name "${entry.name}" is already taken by ${previous.kind} ${previous.where}`,
+				"tool and widget names share one namespace — rename one of them",
+			);
+		}
+		seen.set(entry.name, entry);
+	}
+
+	// Flows point at widgets by name. Catching a typo here beats catching it
+	// when a user is halfway through a conversation.
+	const widgetNames = new Set(app.widgets.map((w) => w.name));
+	for (const flow of app.flows) {
+		const source = readFileSync(flow.file, "utf-8");
+		for (const match of source.matchAll(/showWidget\(\s*\{[^}]*?tool:\s*["'`]([^"'`]+)["'`]/gs)) {
+			const target = match[1];
+			if (!widgetNames.has(target)) {
+				report.error(
+					rel(root, flow.file),
+					`showWidget references the widget "${target}", which does not exist`,
+					widgetNames.size > 0
+						? `known widgets: ${[...widgetNames].join(", ")}`
+						: "this app has no widgets/ folder",
+				);
+			}
+		}
+	}
+}
+
+/** Import each module and check the shape of what it exports. */
+async function checkModules(app, report) {
+	const { root } = app;
+
+	if (app.configFile) {
+		const config = await load(app.configFile, rel(root, app.configFile), report);
+		if (config && !config.name) {
+			report.error(
+				rel(root, app.configFile),
+				"defineApp() is missing `name`",
+				"the MCP server name, e.g. name: 'oney-split-payment'",
+			);
+		}
+	}
+
+	for (const tool of app.tools) {
+		const where = rel(root, tool.file);
+		const def = await load(tool.file, where, report);
+		if (!def) continue;
+		if (typeof def.run !== "function") {
+			report.error(where, "tool is missing run()", "export default defineTool({ ..., run })");
+		}
+		if (!def.description) {
+			report.error(
+				where,
+				"tool is missing a description",
+				"the description is how the model decides to call it — say when to use it",
+			);
+		}
+		if (!def.title) {
+			report.warn(where, "tool is missing a title", "titles show up in connector UIs");
+		}
+	}
+
+	for (const widget of app.widgets) {
+		if (!widget.contract) continue;
+		const where = rel(root, widget.contract);
+		const def = await load(widget.contract, where, report);
+		if (!def) continue;
+		if (!def.data || typeof def.data !== "object") {
+			report.error(
+				where,
+				"widget is missing a `data` schema",
+				"data is the single schema for input, output, and the component's props",
+			);
+		}
+		if (!def.description) {
+			report.error(
+				where,
+				"widget is missing a description",
+				"the description is how the model decides to show it",
+			);
+		}
+	}
+
+	for (const flow of app.flows) {
+		const where = rel(root, flow.file);
+		const def = await load(flow.file, where, report);
+		if (!def) continue;
+		if (!def.name || !def.config || typeof def.handler !== "function") {
+			report.error(
+				where,
+				"this is not a compiled flow",
+				"export default createFlow({ ... }).addEdge(...).compile()",
+			);
+		}
+	}
+}
+
+/**
+ * App modules are TypeScript, and they import each other with the `.js`
+ * specifiers TypeScript's ESM output requires — `../lib/plans.js` for a file on
+ * disk called `plans.ts`. Node's built-in type stripping does not remap those,
+ * so validation registers tsx's resolver before importing anything out of the
+ * app folder. Bun does the remapping on its own, which is what hid this while
+ * the CLI still ran under bun.
+ *
+ * Registration is global to the process and idempotent here, so it happens once
+ * on the first load rather than at startup — `waniwani start` never validates.
+ */
+let resolverRegistered = false;
+async function registerTypeScriptResolver() {
+	if (resolverRegistered) return;
+	resolverRegistered = true;
+	const { register } = await import("tsx/esm/api");
+	register();
+}
+
+async function load(file, where, report) {
+	try {
+		await registerTypeScriptResolver();
+		const module = await import(`${file}?t=${Date.now()}`);
+		const def = module.default;
+		if (!def) {
+			report.error(where, "no default export", "the runtime loads this module's default export");
+			return null;
+		}
+		return def;
+	} catch (error) {
+		report.error(where, "failed to load", error instanceof Error ? error.message : String(error));
+		return null;
+	}
+}
+
+export async function validateApp(app) {
+	const report = new Report(app.root);
+	checkStructure(app, report);
+	// Importing broken modules produces noise on top of structural errors.
+	if (report.ok) {
+		await checkModules(app, report);
+	}
+	return report;
+}

package/dist/index.d.ts

@@ -0,0 +1,113 @@
+/**
+ * The Waniwani MCP authoring API.
+ *
+ * This is everything an app author imports. There is no server bootstrap, no
+ * transport, no MCP wiring, no build config in an app repo — the runtime owns
+ * all of it (see `./server.ts`) and the CLI generates the glue (see `../cli/`).
+ *
+ * An app is a folder:
+ *
+ *   waniwani.config.ts          defineApp({ ... })
+ *   tools/<name>.ts             export default defineTool({ ... })
+ *   widgets/<name>/widget.ts    export default defineWidget({ ... })
+ *   widgets/<name>/ui.tsx       export default function Component() { ... }
+ *   flows/<name>.ts             export default createFlow({ ... }).compile()
+ *   docs/<slug>.md              searchable knowledge
+ */
+import type { z } from "zod";
+/** A Zod object shape — `{ name: z.string() }`, not `z.object({ ... })`. */
+export type Shape = z.ZodRawShape;
+/** The TypeScript type a `Shape` describes. */
+export type Infer<S extends Shape> = z.infer<z.ZodObject<S>>;
+/**
+ * Behavioural hints handed to the host LLM. The runtime translates these into
+ * MCP `annotations` and always fills in the `title` that Claude's Connectors
+ * Directory requires, so an app repo cannot get that wrong.
+ */
+export type ToolHints = {
+    /** The tool only reads. Defaults to `true` for widgets, `false` for tools. */
+    readOnly?: boolean;
+    /** The tool can destroy data. */
+    destructive?: boolean;
+    /** The tool reaches out to the open internet. */
+    openWorld?: boolean;
+    /** Calling twice with the same input has the same effect as calling once. */
+    idempotent?: boolean;
+};
+export type AppConfig = {
+    /** MCP server name, e.g. `oney-split-payment`. */
+    name: string;
+    /** Shown to humans in connector UIs. */
+    title?: string;
+    /** Defaults to the app `package.json` version. */
+    version?: string;
+    /**
+     * Server-level instructions handed to the host LLM once, before any tool
+     * call. Tone, guardrails, what this app is for.
+     */
+    instructions?: string;
+};
+export declare function defineApp(config: AppConfig): AppConfig;
+/**
+ * What a tool handler may return. A string becomes the model-facing text; an
+ * object becomes `structuredContent` plus a JSON text fallback. Returning a
+ * full MCP `CallToolResult` is still allowed for the rare tool that needs it.
+ */
+export type ToolResult = string | Record<string, unknown> | {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    structuredContent?: Record<string, unknown>;
+};
+export type ToolDefinition<S extends Shape = Shape, R extends ToolResult = ToolResult> = {
+    title: string;
+    /** LLM-facing. When to call this, and what it does. */
+    description: string;
+    input?: S;
+    output?: Shape;
+    hints?: ToolHints;
+    run: (input: Infer<S>) => R | Promise<R>;
+};
+export declare function defineTool<S extends Shape, R extends ToolResult>(def: ToolDefinition<S, R>): ToolDefinition<S, R>;
+export type WidgetCsp = {
+    /** Domains the widget may `fetch()`. */
+    connectDomains?: string[];
+    /** Domains the widget may load images/fonts/scripts from. */
+    resourceDomains?: string[];
+};
+/**
+ * A widget contract. This file is imported by *both* the server and the
+ * browser bundle, so it must stay free of React and CSS — the component lives
+ * next to it in `ui.tsx`.
+ *
+ * `data` is the single schema for the widget: it is the tool's input schema,
+ * its output schema, and the type `useWidget()` hands the component. One
+ * schema, so server and UI cannot drift.
+ */
+export type WidgetDefinition<S extends Shape = Shape> = {
+    title: string;
+    /** LLM-facing. When to show this widget, and how to frame it. */
+    description: string;
+    data: S;
+    hints?: ToolHints;
+    csp?: WidgetCsp;
+    /**
+     * Text handed to the model alongside the rendered widget. Use it to tell
+     * the model what NOT to repeat, and what to wait for.
+     */
+    llmText?: (data: Infer<S>) => string;
+    /**
+     * Optional server-side loader, for widgets whose data comes from an API
+     * rather than from the model. Defaults to echoing the input through.
+     */
+    load?: (input: Infer<S>) => Infer<S> | Promise<Infer<S>>;
+};
+export declare function defineWidget<S extends Shape>(def: WidgetDefinition<S>): WidgetDefinition<S>;
+/** A `docs/<slug>.md` file, parsed at build time and inlined into the bundle. */
+export type DocEntry = {
+    slug: string;
+    title: string;
+    body: string;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,26 @@
+/**
+ * The Waniwani MCP authoring API.
+ *
+ * This is everything an app author imports. There is no server bootstrap, no
+ * transport, no MCP wiring, no build config in an app repo — the runtime owns
+ * all of it (see `./server.ts`) and the CLI generates the glue (see `../cli/`).
+ *
+ * An app is a folder:
+ *
+ *   waniwani.config.ts          defineApp({ ... })
+ *   tools/<name>.ts             export default defineTool({ ... })
+ *   widgets/<name>/widget.ts    export default defineWidget({ ... })
+ *   widgets/<name>/ui.tsx       export default function Component() { ... }
+ *   flows/<name>.ts             export default createFlow({ ... }).compile()
+ *   docs/<slug>.md              searchable knowledge
+ */
+export function defineApp(config) {
+    return config;
+}
+export function defineTool(def) {
+    return def;
+}
+export function defineWidget(def) {
+    return def;
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AA0CH,MAAM,UAAU,SAAS,CAAC,MAAiB;IAC1C,OAAO,MAAM,CAAC;AACf,CAAC;AAwBD,MAAM,UAAU,UAAU,CACzB,GAAyB;IAEzB,OAAO,GAAG,CAAC;AACZ,CAAC;AAuCD,MAAM,UAAU,YAAY,CAAkB,GAAwB;IACrE,OAAO,GAAG,CAAC;AACZ,CAAC"}

package/dist/server.d.ts

@@ -0,0 +1,71 @@
+/**
+ * The shared MCP runtime.
+ *
+ * Every Waniwani MCP app runs this exact code. App repos contain no server
+ * bootstrap, so a runtime fix is one package bump away for all of them — no
+ * 30-repo sweep, no per-repo verification.
+ *
+ * The server itself belongs to the distribution template, which constructs it,
+ * registers whatever tools it ships, and runs it. The CLI generates one file
+ * against that seam — `src/waniwani.ts` — which imports the app's modules and
+ * hands them to `registerApp()`. Nothing else.
+ */
+import { McpServer } from "skybridge/server";
+import type { DocEntry, Shape, ToolHints, WidgetCsp } from "./index.js";
+/**
+ * The manifest holds definitions with unrelated schemas side by side, so the
+ * handler signatures are widened here. `never` in the parameter position
+ * accepts any concrete handler; the call sites cast back.
+ */
+type AnyToolDefinition = {
+    title: string;
+    description: string;
+    input?: Shape;
+    output?: Shape;
+    hints?: ToolHints;
+    run: (input: never) => unknown;
+};
+type AnyWidgetDefinition = {
+    title: string;
+    description: string;
+    data: Shape;
+    hints?: ToolHints;
+    csp?: WidgetCsp;
+    llmText?: (data: never) => string;
+    load?: (input: never) => unknown;
+};
+/** A flow compiled by `createFlow(...).compile()` from `@waniwani/sdk/mcp`. */
+export type CompiledFlow = {
+    name: string;
+    config: any;
+    handler: any;
+};
+export type Manifest = {
+    tools: Array<{
+        name: string;
+        def: AnyToolDefinition;
+    }>;
+    widgets: Array<{
+        name: string;
+        def: AnyWidgetDefinition;
+    }>;
+    flows: CompiledFlow[];
+    docs: DocEntry[];
+    /**
+     * Origins the template's Tailwind entry loads from, read off it at build
+     * time. Every view imports that stylesheet, so every widget needs them.
+     */
+    styleDomains?: string[];
+};
+/**
+ * Register an app's tools, widgets, flows, and docs onto a server the template
+ * built.
+ *
+ * The template owns construction, its own tools, `withWaniwani`, and `run()`.
+ * This adds to that server rather than replacing it, so a tool the template
+ * ships reaches every app built on it — one publish, not thirty edits — and an
+ * app's own tools sit alongside it.
+ */
+export declare function registerApp(server: McpServer, manifest: Manifest): Promise<McpServer>;
+export {};
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,SAAS,EAAiB,MAAM,kBAAkB,CAAC;AAE5D,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAExE;;;;GAIG;AACH,KAAK,iBAAiB,GAAG;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,MAAM,CAAC,EAAE,KAAK,CAAC;IACf,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,GAAG,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC;CAC/B,CAAC;AAEF,KAAK,mBAAmB,GAAG;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,KAAK,CAAC;IACZ,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,GAAG,CAAC,EAAE,SAAS,CAAC;IAChB,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,KAAK,KAAK,MAAM,CAAC;IAClC,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC;CACjC,CAAC;AAEF,+EAA+E;AAC/E,MAAM,MAAM,YAAY,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IAEb,MAAM,EAAE,GAAG,CAAC;IAEZ,OAAO,EAAE,GAAG,CAAC;CACb,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG;IACtB,KAAK,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,iBAAiB,CAAA;KAAE,CAAC,CAAC;IACvD,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,mBAAmB,CAAA;KAAE,CAAC,CAAC;IAC3D,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,IAAI,EAAE,QAAQ,EAAE,CAAC;IACjB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAyHF;;;;;;;;GAQG;AACH,wBAAsB,WAAW,CAAC,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC,CA8F3F"}

package/dist/server.js

@@ -0,0 +1,212 @@
+/**
+ * The shared MCP runtime.
+ *
+ * Every Waniwani MCP app runs this exact code. App repos contain no server
+ * bootstrap, so a runtime fix is one package bump away for all of them — no
+ * 30-repo sweep, no per-repo verification.
+ *
+ * The server itself belongs to the distribution template, which constructs it,
+ * registers whatever tools it ships, and runs it. The CLI generates one file
+ * against that seam — `src/waniwani.ts` — which imports the app's modules and
+ * hands them to `registerApp()`. Nothing else.
+ */
+import { McpServer } from "skybridge/server";
+import { z } from "zod";
+/**
+ * The origins a widget may load assets from: its own, plus the ones its
+ * stylesheet needs.
+ *
+ * A host that enforces the widget CSP drops undeclared requests silently — a
+ * blocked webfont is not an error, just a fallback face — so the base
+ * stylesheet's origins are added for every widget rather than left to each app
+ * to remember. An app's own `csp` is additive, never overwritten.
+ */
+function resourceDomains(csp, styleDomains) {
+    const merged = [...new Set([...(csp?.resourceDomains ?? []), ...styleDomains])];
+    return merged.length > 0 ? merged : undefined;
+}
+/**
+ * Translate `hints` into MCP annotations. `title` is always present because
+ * Claude's Connectors Directory rejects tools without one.
+ */
+function annotations(title, hints, defaults) {
+    const merged = { ...defaults, ...hints };
+    return {
+        title,
+        readOnlyHint: merged.readOnly ?? false,
+        destructiveHint: merged.destructive ?? false,
+        openWorldHint: merged.openWorld ?? false,
+        idempotentHint: merged.idempotent ?? false,
+    };
+}
+/** Normalise whatever a tool handler returned into an MCP `CallToolResult`. */
+function toolResult(value) {
+    if (typeof value === "string") {
+        return { content: [{ type: "text", text: value }] };
+    }
+    if (value && typeof value === "object" && "content" in value) {
+        return value;
+    }
+    const structuredContent = (value ?? {});
+    return {
+        structuredContent,
+        content: [{ type: "text", text: JSON.stringify(structuredContent, null, 2) }],
+    };
+}
+/**
+ * Default model-facing text for a widget. Widgets render their own detail, so
+ * the model is told to stop narrating it — the single most common cause of a
+ * widget being read aloud twice.
+ */
+function defaultWidgetText(name) {
+    return `The ${name} widget is now rendered for the user. It displays all the detail itself — do NOT list or repeat its contents in text. Acknowledge it in one short sentence, then wait for the user to interact with it.`;
+}
+function widgetError(name, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[waniwani] widget "${name}" failed to load:`, error);
+    return {
+        isError: true,
+        content: [
+            {
+                type: "text",
+                text: `The ${name} widget could not load its data (${message}). Tell the user something went wrong on our side and offer to try again — do not invent the data.`,
+            },
+        ],
+    };
+}
+function registerDocsTool(server, docs) {
+    const corpus = docs.map((doc) => ({
+        ...doc,
+        haystack: `${doc.title}\n${doc.body}`.toLowerCase(),
+    }));
+    server.registerTool({
+        name: "search_docs",
+        title: "Search the documentation",
+        description: "Search this product's documentation and answer general questions — pricing, eligibility, policies, how things work. Always search before answering, and answer only from what comes back. Never invent facts that are not in the results.",
+        inputSchema: { question: z.string().describe("The user's question, in their own words.") },
+        outputSchema: {
+            results: z.array(z.object({ slug: z.string(), title: z.string(), body: z.string() })),
+        },
+        annotations: annotations("Search the documentation", undefined, { readOnly: true }),
+    }, async ({ question }) => {
+        const terms = question
+            .toLowerCase()
+            .split(/[^a-z0-9]+/)
+            .filter((term) => term.length > 2);
+        const results = corpus
+            .map((doc) => ({
+            doc,
+            score: terms.reduce((sum, term) => sum + (doc.haystack.includes(term) ? 1 : 0), 0),
+        }))
+            .filter(({ score }) => score > 0)
+            .sort((a, b) => b.score - a.score)
+            .slice(0, 3)
+            .map(({ doc }) => ({ slug: doc.slug, title: doc.title, body: doc.body }));
+        if (results.length === 0) {
+            const text = "Nothing in the documentation covers that question.";
+            return { structuredContent: { results: [] }, content: [{ type: "text", text }] };
+        }
+        return {
+            structuredContent: { results },
+            content: [
+                {
+                    type: "text",
+                    text: results.map((r) => `## ${r.title}\n${r.body}`).join("\n\n---\n\n"),
+                },
+            ],
+        };
+    });
+}
+/**
+ * Register an app's tools, widgets, flows, and docs onto a server the template
+ * built.
+ *
+ * The template owns construction, its own tools, `withWaniwani`, and `run()`.
+ * This adds to that server rather than replacing it, so a tool the template
+ * ships reaches every app built on it — one publish, not thirty edits — and an
+ * app's own tools sit alongside it.
+ */
+export async function registerApp(server, manifest) {
+    const { tools, widgets, flows, docs, styleDomains = [] } = manifest;
+    // Widgets: one `data` schema drives the input schema, the structured output,
+    // and the type the component receives.
+    //
+    // A widget is a tool with a view attached. The view's component name is the
+    // widget's folder name, which is also the name of the entry the generator
+    // writes into `src/views/` — one name, from the filesystem, so a widget
+    // cannot be registered against a component that was never bundled.
+    for (const { name, def } of widgets) {
+        server.registerTool({
+            name,
+            title: def.title,
+            description: def.description,
+            inputSchema: def.data,
+            outputSchema: def.data,
+            annotations: annotations(def.title, def.hints, { readOnly: true }),
+            view: {
+                component: name,
+                description: def.description,
+                csp: {
+                    ...def.csp,
+                    resourceDomains: resourceDomains(def.csp, styleDomains),
+                },
+            },
+        }, async (input) => {
+            try {
+                const data = (def.load ? await def.load(input) : input);
+                return {
+                    structuredContent: data,
+                    content: [
+                        {
+                            type: "text",
+                            text: def.llmText?.(data) ?? defaultWidgetText(name),
+                        },
+                    ],
+                };
+            }
+            catch (error) {
+                return widgetError(name, error);
+            }
+        });
+    }
+    for (const { name, def } of tools) {
+        server.registerTool({
+            name,
+            title: def.title,
+            description: def.description,
+            inputSchema: def.input ?? {},
+            outputSchema: def.output,
+            annotations: annotations(def.title, def.hints, { readOnly: false }),
+        }, async (input) => {
+            try {
+                return toolResult(await def.run(input));
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                console.error(`[waniwani] tool "${name}" failed:`, error);
+                return {
+                    isError: true,
+                    content: [
+                        {
+                            type: "text",
+                            text: `The ${name} tool failed (${message}). Tell the user it did not work and offer to retry — do not invent a result.`,
+                        },
+                    ],
+                };
+            }
+        });
+    }
+    // Flows arrive from the SDK shaped for the MCP SDK's `(name, config, handler)`
+    // call, which the framework replaced with a single config carrying the name.
+    for (const flow of flows) {
+        server.registerTool({ ...flow.config, name: flow.name }, flow.handler);
+    }
+    if (docs.length > 0) {
+        registerDocsTool(server, docs);
+    }
+    // `withWaniwani` is deliberately not called here. It wraps every registered
+    // handler in place, so it has to run after the last registration — which is
+    // the template's, not this function's. `src/server.ts` calls it.
+    return server;
+}
+//# sourceMappingURL=server.js.map