@alt-t4b/pm-mcp 0.1.0

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@alt-t4b/pm-mcp",
+  "version": "0.1.0",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "bin": {
+    "tab-pm-mcp": "./src/standalone.ts"
+  },
+  "files": ["src"],
+  "scripts": {
+    "dev": "bun run --hot src/standalone.ts",
+    "start": "bun run src/standalone.ts"
+  },
+  "dependencies": {
+    "@alt-t4b/pm-domain": "^0.1.0",
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "hono": "^4",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.2",
+    "typescript": "^5"
+  }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export { createMcpServer, handleMcpHttp } from "./server";
+export type { McpServiceContext } from "./server";

package/src/server.ts

@@ -0,0 +1,140 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
+import { z } from "zod";
+import {
+  ServiceError,
+  PROJECT_STATUSES,
+  TASK_STATUSES,
+  type IProjectService,
+  type ITaskService,
+} from "@alt-t4b/pm-domain";
+
+export interface McpServiceContext {
+  projectService: IProjectService;
+  taskService: ITaskService;
+}
+
+function handle<T>(fn: () => T) {
+  try {
+    const result = fn();
+    return { content: [{ type: "text" as const, text: JSON.stringify(result, null, 2) }] };
+  } catch (err) {
+    if (err instanceof ServiceError) {
+      return {
+        content: [{ type: "text" as const, text: err.message }],
+        isError: true,
+      };
+    }
+    throw err;
+  }
+}
+
+/** Create an McpServer with all tools registered. */
+export function createMcpServer(ctx: McpServiceContext): McpServer {
+  const { projectService, taskService } = ctx;
+
+  const server = new McpServer({
+    name: "tab-pm",
+    version: "0.1.0",
+  });
+
+  // ── Projects ──────────────────────────────────────────────
+
+  server.registerTool("list_projects", { description: "List all projects" }, () =>
+    handle(() => projectService.findAll())
+  );
+
+  server.registerTool(
+    "get_project",
+    { description: "Get a project by slug", inputSchema: { slug: z.string() } },
+    ({ slug }) => handle(() => projectService.findBySlug(slug))
+  );
+
+  server.registerTool(
+    "create_project",
+    {
+      description: "Create a new project",
+      inputSchema: {
+        name: z.string(),
+        slug: z.string(),
+        description: z.string().optional(),
+        status: z.enum(PROJECT_STATUSES).optional(),
+      },
+    },
+    (input) => handle(() => projectService.create(input))
+  );
+
+  server.registerTool(
+    "update_project",
+    {
+      description: "Update an existing project",
+      inputSchema: {
+        slug: z.string(),
+        name: z.string().optional(),
+        description: z.string().optional(),
+        status: z.enum(PROJECT_STATUSES).optional(),
+      },
+    },
+    ({ slug, ...updates }) => handle(() => projectService.update(slug, updates))
+  );
+
+  server.registerTool(
+    "delete_project",
+    { description: "Delete a project by slug", inputSchema: { slug: z.string() } },
+    ({ slug }) => handle(() => projectService.delete(slug))
+  );
+
+  // ── Tasks ─────────────────────────────────────────────────
+
+  server.registerTool(
+    "list_tasks",
+    { description: "List tasks for a project", inputSchema: { project_slug: z.string() } },
+    ({ project_slug }) => handle(() => taskService.findByProjectSlug(project_slug))
+  );
+
+  server.registerTool(
+    "create_task",
+    {
+      description: "Create a task in a project",
+      inputSchema: {
+        project_slug: z.string(),
+        title: z.string(),
+        description: z.string().optional(),
+        status: z.enum(TASK_STATUSES).optional(),
+      },
+    },
+    ({ project_slug, ...input }) => handle(() => taskService.create(project_slug, input))
+  );
+
+  server.registerTool(
+    "update_task",
+    {
+      description: "Update a task by ID",
+      inputSchema: {
+        id: z.string(),
+        title: z.string().optional(),
+        description: z.string().optional(),
+        status: z.enum(TASK_STATUSES).optional(),
+      },
+    },
+    ({ id, ...updates }) => handle(() => taskService.update(id, updates))
+  );
+
+  server.registerTool(
+    "delete_task",
+    { description: "Delete a task by ID", inputSchema: { id: z.string() } },
+    ({ id }) => handle(() => taskService.delete(id))
+  );
+
+  return server;
+}
+
+/** Handle a single MCP-over-HTTP request (stateless, one server per request). */
+export async function handleMcpHttp(ctx: McpServiceContext, req: Request): Promise<Response> {
+  const server = createMcpServer(ctx);
+  const transport = new WebStandardStreamableHTTPServerTransport();
+  await server.connect(transport);
+  const response = await transport.handleRequest(req);
+  await server.close();
+  return response;
+}

package/src/standalone.ts

@@ -0,0 +1,66 @@
+#!/usr/bin/env bun
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { bootstrap } from "@alt-t4b/pm-domain";
+import { handleMcpHttp } from "./server";
+import { networkInterfaces } from "os";
+
+function parseArgs(): {
+  port: number;
+  host: string;
+  dbPath?: string;
+} {
+  const args = process.argv.slice(2);
+  let port = Number(process.env.PM_MCP_PORT) || 3001;
+  let host = process.env.PM_HOST ?? "127.0.0.1";
+  let dbPath: string | undefined = process.env.SQLITE_PATH;
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--port" && args[i + 1]) port = Number(args[++i]);
+    if (args[i] === "--host" && args[i + 1]) host = args[++i];
+    if (args[i] === "--sqlite-path" && args[i + 1]) dbPath = args[++i];
+  }
+
+  return { port, host, dbPath };
+}
+
+const { port, host, dbPath } = parseArgs();
+const ctx = bootstrap(dbPath);
+
+const app = new Hono();
+app.use(
+  "*",
+  cors({
+    origin: (origin) =>
+      origin?.startsWith("http://localhost") || origin?.startsWith("http://127.0.0.1")
+        ? origin
+        : null,
+    allowMethods: ["GET", "POST", "DELETE", "OPTIONS"],
+    allowHeaders: ["Content-Type", "mcp-session-id", "Last-Event-ID", "mcp-protocol-version"],
+    exposeHeaders: ["mcp-session-id", "mcp-protocol-version"],
+  })
+);
+app.all("/*", (c) => handleMcpHttp(ctx, c.req.raw));
+
+function getNetworkAddress(): string | undefined {
+  for (const addrs of Object.values(networkInterfaces())) {
+    for (const addr of addrs ?? []) {
+      if (addr.family === "IPv4" && !addr.internal) return addr.address;
+    }
+  }
+}
+
+const displayHost = host === "0.0.0.0" ? "localhost" : host;
+console.error(`tab-pm mcp listening on http://${displayHost}:${port}`);
+if (host === "0.0.0.0") {
+  const networkAddr = getNetworkAddress();
+  if (networkAddr) {
+    console.error(`tab-pm mcp network: http://${networkAddr}:${port}`);
+  }
+}
+
+export default {
+  port,
+  hostname: host,
+  fetch: app.fetch,
+};