@guuey/create-agentic-app 0.1.0

package/dist/templates/claude-agent-sdk/mcps/todo/Dockerfile

@@ -0,0 +1,46 @@
+# todo-mcp — guuey hosted MCP server image.
+#
+# Self-sufficient multi-stage build: `guuey mcp deploy` packs this directory
+# into a tarball and hands it straight to the builder with no external
+# pre-build step and no build args — this Dockerfile installs its own deps
+# and builds itself. (Different from guuey's own first-party MCP servers,
+# which use a "copy-prebuilt" pattern that expects `dist/` + `node_modules/`
+# to already exist before `docker build` runs — that pattern does not apply
+# to a standalone project like this one.)
+#
+# Build + run locally:
+#
+#   docker build -t todo-mcp .
+#   docker run -p 8080:8080 todo-mcp
+#   curl http://localhost:8080/health
+#
+# Deploy to guuey:
+#
+#   cd mcps/todo && guuey mcp deploy
+
+FROM node:22-slim AS build
+WORKDIR /app
+COPY package.json ./
+RUN npm install
+COPY tsconfig.json ./
+COPY src ./src
+RUN npm run build
+
+FROM node:22-slim
+WORKDIR /app
+ENV NODE_ENV=production
+# guuey's hosted-MCP runtime injects PORT=8080 and probes GET /health at that
+# port — this default matches so `docker run` alone also works.
+ENV PORT=8080
+
+COPY package.json ./
+RUN npm install --omit=dev
+COPY --from=build /app/dist ./dist
+
+USER node
+EXPOSE 8080
+
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
+  CMD node -e "fetch('http://localhost:' + (process.env.PORT || 8080) + '/health').then(r => { if (!r.ok) throw 1 }).catch(() => process.exit(1))"
+
+CMD ["node", "dist/server.js"]

package/dist/templates/claude-agent-sdk/mcps/todo/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@agentic-app-template/todo-mcp",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "tsx src/server.ts",
+    "build": "tsup src/server.ts --format esm -d dist",
+    "start": "node dist/server.js",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.0",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.0"
+  }
+}

package/dist/templates/claude-agent-sdk/mcps/todo/src/server.ts

@@ -0,0 +1,173 @@
+/**
+ * todo-mcp — the copy-me example MCP server for @agentic-app-template.
+ *
+ * A minimal, stateless Streamable HTTP MCP server: four tools over an
+ * in-memory todo list. Swap the `Map` for a real database when you outgrow
+ * a single replica; everything else (transport wiring, tool shape) stays
+ * the same.
+ *
+ * Transport pattern mirrors guuey's canonical hosted-MCP scaffold
+ * (`mcp-servers/_template` in the guuey monorepo): a fresh `McpServer` +
+ * `StreamableHTTPServerTransport` are created **per request** and torn down
+ * when the response closes. Stateless mode — the guuey proxy (and, locally,
+ * whatever MCP client you point at this server) handles sessions, so this
+ * server never keeps request state around between calls.
+ *
+ * Runtime contract when deployed via `guuey mcp deploy` (see mcps/todo's
+ * Dockerfile): the platform injects `PORT=8080` and probes `GET /health`
+ * for both liveness and readiness. Locally, `pnpm dev` runs this on
+ * `PORT=6782` (see ../../scripts/dev.mjs).
+ */
+import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
+import { randomUUID } from "node:crypto";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { z } from "zod";
+
+interface Todo {
+  id: string;
+  title: string;
+  done: boolean;
+}
+
+const todos = new Map<string, Todo>();
+
+const todoShape = {
+  id: z.string(),
+  title: z.string(),
+  done: z.boolean(),
+};
+
+/** Wrap a structured result as both `structuredContent` and a text block. */
+function toolResult(data: Record<string, unknown>) {
+  return {
+    structuredContent: data,
+    content: [{ type: "text" as const, text: JSON.stringify(data) }],
+  };
+}
+
+function buildMcpServer(): McpServer {
+  const server = new McpServer({
+    name: "todo-mcp",
+    version: "0.0.0",
+    description: "Create, list, toggle, and delete todos.",
+  });
+
+  server.registerTool(
+    "todo_list",
+    {
+      title: "List todos",
+      description: "List every todo, in creation order.",
+      inputSchema: {},
+      outputSchema: { todos: z.array(z.object(todoShape)) },
+    },
+    async () => toolResult({ todos: [...todos.values()] }),
+  );
+
+  server.registerTool(
+    "todo_create",
+    {
+      title: "Create todo",
+      description: "Create a new todo item.",
+      inputSchema: { title: z.string().min(1).describe("Todo title.") },
+      outputSchema: todoShape,
+    },
+    async ({ title }) => {
+      const todo: Todo = { id: randomUUID(), title, done: false };
+      todos.set(todo.id, todo);
+      // Spread into a fresh object literal — `toolResult` takes
+      // `Record<string, unknown>`, and a named interface like `Todo` isn't
+      // structurally assignable to that without an (unwanted) index
+      // signature of its own; a fresh literal is.
+      return toolResult({ ...todo });
+    },
+  );
+
+  server.registerTool(
+    "todo_toggle",
+    {
+      title: "Toggle todo",
+      description: "Flip a todo's done state.",
+      inputSchema: { id: z.string().describe("Todo id.") },
+      outputSchema: todoShape,
+    },
+    async ({ id }) => {
+      const todo = todos.get(id);
+      if (!todo) throw new Error(`todo not found: ${id}`);
+      todo.done = !todo.done;
+      return toolResult({ ...todo }); // fresh literal — see the create() comment above
+    },
+  );
+
+  server.registerTool(
+    "todo_delete",
+    {
+      title: "Delete todo",
+      description: "Delete a todo by id.",
+      inputSchema: { id: z.string().describe("Todo id.") },
+      outputSchema: { id: z.string(), deleted: z.boolean() },
+    },
+    async ({ id }) => {
+      const deleted = todos.delete(id);
+      return toolResult({ id, deleted });
+    },
+  );
+
+  return server;
+}
+
+const PORT = Number(process.env.PORT ?? 6782);
+
+const httpServer = createServer(async (req: IncomingMessage, res: ServerResponse) => {
+  if (req.method === "GET" && req.url === "/health") {
+    res.writeHead(200, { "content-type": "application/json" });
+    res.end(JSON.stringify({ status: "ok", server: "todo-mcp", version: "0.0.0" }));
+    return;
+  }
+
+  if (req.url !== "/mcp") {
+    res.writeHead(404, { "content-type": "application/json" }).end(
+      JSON.stringify({ error: "not found" }),
+    );
+    return;
+  }
+
+  // Fresh server + transport per request (stateless mode) — see module doc.
+  const mcp = buildMcpServer();
+  const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+
+  res.on("close", () => {
+    transport.close().catch(() => undefined);
+    mcp.close().catch(() => undefined);
+  });
+
+  try {
+    await mcp.connect(transport);
+    await transport.handleRequest(req, res);
+  } catch (err) {
+    console.error("mcp_handle_failed", err);
+    if (!res.headersSent) {
+      res.writeHead(500, { "content-type": "application/json" });
+      res.end(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          error: { code: -32603, message: "Internal server error" },
+          id: null,
+        }),
+      );
+    }
+  }
+});
+
+httpServer.listen(PORT, () => {
+  console.log(`todo-mcp listening on :${PORT}`);
+});
+
+function shutdown(signal: string): void {
+  console.log(`${signal} received — shutting down`);
+  httpServer.close(() => process.exit(0));
+  // Force-exit if connections don't drain in time.
+  setTimeout(() => process.exit(1), 10_000).unref();
+}
+process.on("SIGTERM", () => shutdown("SIGTERM"));
+process.on("SIGINT", () => shutdown("SIGINT"));

package/dist/templates/claude-agent-sdk/mcps/todo/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2023",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/dist/templates/claude-agent-sdk/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "agentic-app-template",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "node scripts/dev.mjs",
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.3.199",
+    "@guuey/config": "0.0.1",
+    "@guuey/worker": "0.0.1"
+  },
+  "devDependencies": {
+    "@guuey/cli": "0.0.1",
+    "tsup": "^8.5.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.8.0"
+  }
+}

package/dist/templates/claude-agent-sdk/pnpm-workspace.yaml

@@ -0,0 +1,24 @@
+packages:
+  - "mcps/*"
+  - "web"
+
+# pnpm 11 default `strictDepBuilds: true` blocks install scripts for any
+# dependency with a build script (esbuild's native binary fetch, sharp,
+# etc.) unless individually allowlisted, and fails the whole `install`
+# with ERR_PNPM_IGNORED_BUILDS otherwise. Scaffolded apps pull in build-
+# script deps transitively (tsup/vite -> esbuild, mcp/ui deps, etc.) that
+# we can't enumerate up front, so match pnpm 9/10 behavior here.
+strictDepBuilds: false
+
+# pnpm 11 default `verifyDepsBeforeRun: 'install'` re-verifies the
+# lockfile against supply-chain policies (including minimumReleaseAge)
+# before every `pnpm run <script>`, hitting the registry even for
+# already-installed deps. That check 404s for any dependency that only
+# exists as a local tarball (not yet published), which is expected
+# during local/dev/CI installs. Restore pnpm 9/10 behavior: only verify
+# on an explicit `pnpm install`.
+verifyDepsBeforeRun: false
+
+# See above — same registry-lookback problem hits a plain `pnpm install`
+# too when minimumReleaseAge is nonzero; disable it for scaffolded apps.
+minimumReleaseAge: 0

package/dist/templates/claude-agent-sdk/prompts/system.md

@@ -0,0 +1,4 @@
+You are the agentic-app-template assistant. You have a todo tool server —
+use it to create, list, toggle, and delete the user's todos. When the ggui
+server is available, prefer rendering rich UI for lists and forms over
+plain text.

package/dist/templates/claude-agent-sdk/scripts/dev.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+// pnpm dev — boots the whole local stack. Ctrl-C tears everything down.
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+
+const procs = [];
+function boot(name, command, args, opts = {}) {
+  const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"], ...opts });
+  const prefix = `[${name}]`.padEnd(9);
+  child.stdout.on("data", (d) => process.stdout.write(String(d).replace(/^/gm, prefix)));
+  child.stderr.on("data", (d) => process.stderr.write(String(d).replace(/^/gm, prefix)));
+  child.on("exit", (code) => {
+    if (code !== 0 && !shuttingDown) shutdown(`${name} exited (${code})`, 1);
+  });
+  procs.push(child);
+}
+let shuttingDown = false;
+function shutdown(reason, code = 0) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  console.log(`\n${reason} — shutting down`);
+  for (const p of procs) p.kill("SIGTERM");
+  setTimeout(() => process.exit(code), 500);
+}
+process.on("SIGINT", () => shutdown("interrupted"));
+process.on("SIGTERM", () => shutdown("terminated"));
+
+if (!existsSync(".env.local"))
+  console.warn("hint: cp .env.example .env.local and set your LLM key");
+
+boot("worker", "pnpm", ["exec", "tsup", "--watch"]); // rebuilds guuey.worker.js on change
+boot("agent", "pnpm", ["exec", "guuey", "dev", "--serve", "--port", "6790"]);
+boot("todo", "pnpm", ["--filter", "@agentic-app-template/todo-mcp", "dev"], {
+  env: { ...process.env, PORT: "6782" },
+});
+boot("ggui", "pnpm", ["exec", "ggui", "serve", "--mcp-only", "--dev-allow-all", "--port", "6781"], {
+  cwd: "ggui",
+});
+boot("web", "pnpm", ["--filter", "@agentic-app-template/web", "dev"], {
+  env: { ...process.env, PORT: "6890" },
+});
+
+console.log("\n  agent  http://localhost:6790   todo-mcp http://localhost:6782");
+console.log("  ggui   http://localhost:6781   web      http://localhost:6890\n");

package/dist/templates/claude-agent-sdk/src/agent-config.ts

@@ -0,0 +1,70 @@
+/**
+ * Snapshot + system-prompt + MCP-endpoint resolution shared by both framework
+ * overlays. Duplicated verbatim in `templates-src/frameworks/openai-agents-sdk`
+ * by design — template code must be self-contained (no cross-overlay imports),
+ * so keep the two copies byte-identical when editing either one.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseGuueyJson, type GuueyAgent } from "@guuey/config";
+import type { Invoke } from "@guuey/worker";
+
+/** GUUEY_AGENT_SNAPSHOT (set by the platform pod and by `guuey dev`) wins; guuey.json is the fallback. */
+export function loadAgent(invoke: Invoke): GuueyAgent {
+  const env = process.env.GUUEY_AGENT_SNAPSHOT;
+  if (env) return JSON.parse(env) as GuueyAgent;
+  const raw = JSON.parse(readFileSync(join(invoke.fs.app, "guuey.json"), "utf8"));
+  return parseGuueyJson(raw).agent;
+}
+
+export function systemPrompt(invoke: Invoke, agent: GuueyAgent): string | undefined {
+  const sp = agent.systemPrompt;
+  if (typeof sp === "string") return sp;
+  if (sp?.file) return readFileSync(join(invoke.fs.app, sp.file), "utf8");
+  return undefined;
+}
+
+/**
+ * One resolved MCP endpoint this worker may connect to. `transport` rides
+ * alongside `url`/`headers` (not hardcoded to `"http"`) because a federation
+ * credential file — `<session>/.guuey/credentials/<name>.json`, shape
+ * `{url, transport, headers}` per `@guuey/host`'s `CredentialFile` — may
+ * resolve a server onto the `sse` transport arm.
+ */
+export interface McpEndpoint {
+  url: string;
+  transport: "http" | "sse";
+  headers: Record<string, string>;
+}
+
+/** Lowered entries are `external`; federation credentials (if any) arrive as per-session files. */
+export function mcpEndpoints(invoke: Invoke, agent: GuueyAgent): Record<string, McpEndpoint> {
+  const out: Record<string, McpEndpoint> = {};
+  for (const [name, entry] of Object.entries(agent.mcpServers ?? {})) {
+    if (entry.kind !== "external") continue; // hosted/proxied are lowered to external before a worker ever runs
+    let url = entry.url;
+    let transport: "http" | "sse" = entry.transport ?? "http";
+    let headers: Record<string, string> = { ...(entry.headers ?? {}) };
+    try {
+      const cred = JSON.parse(
+        readFileSync(join(invoke.fs.session, ".guuey", "credentials", `${name}.json`), "utf8")
+      ) as { url: string; transport: "http" | "sse"; headers: Record<string, string> };
+      url = cred.url;
+      transport = cred.transport;
+      headers = cred.headers;
+    } catch {
+      // no credential file — plain external endpoint; static headers apply
+    }
+    out[name] = { url, transport, headers };
+  }
+  return out;
+}
+
+/** Fold prior turns into a prompt preamble (v1 keep-it-simple history handling). */
+export function withHistory(invoke: Invoke): string {
+  if (invoke.history.length === 0) return invoke.input;
+  const lines = invoke.history.map(
+    (h) => `${h.role === "agent" ? "Assistant" : "User"}: ${h.text}`
+  );
+  return `<conversation_history>\n${lines.join("\n")}\n</conversation_history>\n\n${invoke.input}`;
+}

package/dist/templates/claude-agent-sdk/src/worker.ts

@@ -0,0 +1,89 @@
+/**
+ * agentic-app-template's code-mode worker entry (Claude Agent SDK). Reads the
+ * resolved agent snapshot + MCP endpoints via `./agent-config.js`, drives one
+ * `query()` per invoke, and streams every native SDK message to the Router
+ * via `emit.native` (the field spellings below — `mcpServers`/`systemPrompt`/
+ * `allowedTools`/`maxTurns`, and the `type === "result" && subtype ===
+ * "success"` result-detection — mirror `@guuey/host`'s `buildOptions` /
+ * `runInvoke`, the platform's own consumer of this exact snapshot shape).
+ */
+import { createRequire } from "node:module";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { serveNative } from "@guuey/worker";
+import { loadAgent, systemPrompt, mcpEndpoints, withHistory } from "./agent-config.js";
+
+/**
+ * This worker is tsup-bundled (`noExternal`), which breaks the SDK's own
+ * native-CLI lookup: the SDK resolves `claude-agent-sdk-<platform>-<arch>`
+ * relative to its OWN module location, and once inlined into
+ * `guuey.worker.js` that location is the bundle's — where no node_modules
+ * has the binary. Resolution order here:
+ *   1. `GUUEY_CLAUDE_CODE_EXECUTABLE` — set by the guuey pod Router, pointing
+ *      at the platform image's binary (a deployed `/worker` has no
+ *      node_modules at all).
+ *   2. Anchored resolve — find the *installed* SDK from the bundle's location
+ *      (it is this app's direct dependency), then resolve the platform binary
+ *      package from the SDK's real location, exactly as the unbundled SDK
+ *      would. Covers local `guuey dev --serve`, where the bundle runs next to
+ *      the app's node_modules.
+ *   3. undefined — let the SDK try (and fail with its actionable error).
+ */
+function claudeExecutable(): string | undefined {
+  if (process.env.GUUEY_CLAUDE_CODE_EXECUTABLE) return process.env.GUUEY_CLAUDE_CODE_EXECUTABLE;
+  try {
+    const sdkEntry = createRequire(import.meta.url).resolve("@anthropic-ai/claude-agent-sdk");
+    return createRequire(sdkEntry).resolve(
+      `@anthropic-ai/claude-agent-sdk-${process.platform}-${process.arch}/claude`
+    );
+  } catch {
+    return undefined;
+  }
+}
+const pathToClaudeCodeExecutable = claudeExecutable();
+
+await serveNative(
+  async (invoke, emit) => {
+    const agent = loadAgent(invoke);
+    const mcpServers = Object.fromEntries(
+      Object.entries(mcpEndpoints(invoke, agent)).map(([name, ep]) => [
+        name,
+        // `alwaysLoad` — this agent's declared MCP servers ARE its tool
+        // surface; without it the CLI defers MCP tools behind its ToolSearch
+        // built-in (absent here — see `tools: []` below), leaving the model
+        // tool-less.
+        { type: ep.transport, url: ep.url, headers: ep.headers, alwaysLoad: true },
+      ])
+    );
+    let result = "";
+    for await (const message of query({
+      prompt: withHistory(invoke),
+      options: {
+        ...(agent.model ? { model: agent.model } : {}),
+        ...(systemPrompt(invoke, agent) ? { systemPrompt: systemPrompt(invoke, agent) } : {}),
+        mcpServers,
+        // Same posture as `@guuey/host`'s `buildOptions` (options.ts):
+        // - allowedTools: the snapshot allowlist verbatim, else every tool
+        //   from every declared server (`mcp__<server>` prefix match) — MCP
+        //   calls would otherwise hit the SDK's interactive ask stage, which
+        //   nothing answers headless, so they'd be silently denied.
+        // - tools: [] — purely MCP-driven; no Bash/file/search built-ins.
+        // - settingSources: [] — never load the machine's ~/.claude or
+        //   project settings into this worker (a dev box's logged-in Claude
+        //   Code MCPs/plugins would leak into the tool catalog).
+        // - strictMcpConfig: true — the snapshot's servers only; ignore
+        //   .mcp.json / user settings / plugins.
+        allowedTools: agent.tools?.allowlist ?? Object.keys(mcpServers).map((s) => `mcp__${s}`),
+        tools: [],
+        settingSources: [],
+        strictMcpConfig: true,
+        ...(agent.runtime?.maxTurns ? { maxTurns: agent.runtime.maxTurns } : {}),
+        ...(pathToClaudeCodeExecutable ? { pathToClaudeCodeExecutable } : {}),
+      },
+    })) {
+      emit.native(JSON.parse(JSON.stringify(message)));
+      if (message.type === "result" && message.subtype === "success") result = message.result;
+    }
+    return result;
+  },
+  { framework: "claude-agent-sdk", sdkName: "@anthropic-ai/claude-agent-sdk" }
+);

package/dist/templates/claude-agent-sdk/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2023",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}

package/dist/templates/claude-agent-sdk/tsup.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: { "guuey.worker": "src/worker.ts" },
+  format: ["esm"],
+  outDir: ".",
+  clean: false,
+  noExternal: [/./], // bundle everything — the deploy tarball must be runnable via `node guuey.worker.js`
+});

package/dist/templates/claude-agent-sdk/web/.env.example

@@ -0,0 +1,17 @@
+# Vite env for the web chat client. Copy to `web/.env.local` and UNCOMMENT
+# the vars you want to override. (Vite reads env files from this directory —
+# not the project root. Keep unused vars commented out: an empty
+# `VITE_X=` declaration loads as "" — not undefined.)
+
+# Agent base URL. Defaults to the local `guuey dev` router (:6790).
+# VITE_AGENT_ENDPOINT_URL=http://localhost:6790
+
+# Second-origin MCP-Apps sandbox page for @mcp-ui/client's <AppRenderer>.
+# The MCP Apps spec requires UI resources to mount from a DIFFERENT origin
+# than the app itself (double-iframe sandbox). In local dev this is served
+# automatically on http://127.0.0.1:6891/sandbox.html by the
+# sandboxProxyPlugin in vite.config.ts — leave unset. For a DEPLOYED build,
+# host ../sandbox-proxy.ts's sandbox page on its own origin and point this
+# at it; if unset in production, UI resources show a plain-text notice
+# instead of rendering.
+# VITE_SANDBOX_URL=https://sandbox.example.com/sandbox.html

package/dist/templates/claude-agent-sdk/web/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>agentic-app-template</title>
+    <meta name="description" content="Local dev chat client for your guuey agent." />
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>

package/dist/templates/claude-agent-sdk/web/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@agentic-app-template/web",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite --port 6890",
+    "build": "tsc && vite build",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@mcp-ui/client": "^7.1.1",
+    "@silverprotocol/core": "0.1.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "@vitejs/plugin-react": "^4.3.0",
+    "typescript": "^5.8.0",
+    "vite": "^6.0.0"
+  }
+}