@guuey/create-agentic-app 0.9.0 → 0.11.0

package/dist/templates/base/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",
+    "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/base/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/base/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/base/claude-agent-sdk/mcps/todo/tsup.config.ts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'tsup';
+
+// Self-contained ON PURPOSE — do not delete this file. Without a local
+// config, tsup's upward config discovery finds the scaffold ROOT
+// tsup.config.ts; its bundled form imports 'tsup' from the scaffold root,
+// which the platform image build deliberately leaves un-installed when the
+// bundled guuey.worker.js skips the root install — every colocated build
+// then dies with ERR_MODULE_NOT_FOUND (guuey#19). A config here stops the
+// walk; `defineConfig` resolves from this package's own devDependencies.
+export default defineConfig({
+  entry: ['src/server.ts'],
+  format: 'esm',
+  outDir: 'dist',
+});

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

@@ -0,0 +1,30 @@
+{
+  "name": "agentic-app-template",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "node scripts/dev.mjs",
+    "bootstrap": "node scripts/bootstrap.mjs",
+    "status": "guuey apps get && guuey agent status",
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.3.199",
+    "@guuey/config": "0.11.0",
+    "@guuey/worker": "0.11.0"
+  },
+  "devDependencies": {
+    "@ggui-ai/cli": "0.6.3",
+    "@guuey/cli": "0.11.0",
+    "tsup": "^8.5.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.8.0"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "esbuild"
+    ]
+  }
+}

package/dist/templates/base/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/base/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.