@x4lt7ab/tab-for-projects 0.1.0

package/src/domain/services/projects.ts

@@ -0,0 +1,68 @@
+import type { Project } from "../entities";
+import type { CreateProjectInput, UpdateProjectInput } from "../inputs";
+import type { IProjectService } from "../services";
+import { ServiceError } from "../errors";
+import type { ProjectRepository } from "../repositories/projects";
+import { PROJECT_STATUSES } from "../statuses";
+
+const SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+
+export class ProjectService implements IProjectService {
+  constructor(private repo: ProjectRepository) {}
+
+  findAll(): Project[] {
+    return this.repo.findAll();
+  }
+
+  findBySlug(slug: string): Project | null {
+    return this.repo.findBySlug(slug);
+  }
+
+  create(input: CreateProjectInput): Project {
+    if (!input.name?.trim()) {
+      throw new ServiceError("name is required", 400);
+    }
+    if (input.name.length > 255) {
+      throw new ServiceError("name must be 255 characters or fewer", 400);
+    }
+    if (!input.slug?.trim()) {
+      throw new ServiceError("slug is required", 400);
+    }
+    if (input.slug.length > 100) {
+      throw new ServiceError("slug must be 100 characters or fewer", 400);
+    }
+    if (!SLUG_RE.test(input.slug)) {
+      throw new ServiceError("slug must be lowercase alphanumeric with hyphens only", 400);
+    }
+    if (input.description !== undefined && input.description.length > 10000) {
+      throw new ServiceError("description must be 10000 characters or fewer", 400);
+    }
+    if (input.status !== undefined && !(PROJECT_STATUSES as readonly string[]).includes(input.status)) {
+      throw new ServiceError(`status must be one of: ${PROJECT_STATUSES.join(", ")}`, 400);
+    }
+    if (this.repo.findBySlug(input.slug)) {
+      throw new ServiceError("slug already exists", 409);
+    }
+    return this.repo.create(input);
+  }
+
+  update(slug: string, input: UpdateProjectInput): Project | null {
+    if (input.name !== undefined && !input.name.trim()) {
+      throw new ServiceError("name cannot be empty", 400);
+    }
+    if (input.name !== undefined && input.name.length > 255) {
+      throw new ServiceError("name must be 255 characters or fewer", 400);
+    }
+    if (input.description !== undefined && input.description.length > 10000) {
+      throw new ServiceError("description must be 10000 characters or fewer", 400);
+    }
+    if (input.status !== undefined && !(PROJECT_STATUSES as readonly string[]).includes(input.status)) {
+      throw new ServiceError(`status must be one of: ${PROJECT_STATUSES.join(", ")}`, 400);
+    }
+    return this.repo.update(slug, input);
+  }
+
+  delete(slug: string): boolean {
+    return this.repo.delete(slug);
+  }
+}

package/src/domain/services/tasks.ts

@@ -0,0 +1,62 @@
+import type { Task } from "../entities";
+import type { CreateTaskInput, UpdateTaskInput } from "../inputs";
+import type { ITaskService } from "../services";
+import { ServiceError } from "../errors";
+import type { TaskRepository } from "../repositories/tasks";
+import type { ProjectRepository } from "../repositories/projects";
+import { TASK_STATUSES } from "../statuses";
+
+export class TaskService implements ITaskService {
+  constructor(
+    private taskRepo: TaskRepository,
+    private projectRepo: ProjectRepository
+  ) {}
+
+  findByProjectSlug(projectSlug: string): Task[] {
+    const project = this.projectRepo.findBySlug(projectSlug);
+    if (!project) {
+      throw new ServiceError("project not found", 404);
+    }
+    return this.taskRepo.findByProject(project.id);
+  }
+
+  create(projectSlug: string, input: CreateTaskInput): Task {
+    const project = this.projectRepo.findBySlug(projectSlug);
+    if (!project) {
+      throw new ServiceError("project not found", 404);
+    }
+    if (!input.title?.trim()) {
+      throw new ServiceError("title is required", 400);
+    }
+    if (input.title.length > 500) {
+      throw new ServiceError("title must be 500 characters or fewer", 400);
+    }
+    if (input.description !== undefined && input.description.length > 10000) {
+      throw new ServiceError("description must be 10000 characters or fewer", 400);
+    }
+    if (input.status !== undefined && !(TASK_STATUSES as readonly string[]).includes(input.status)) {
+      throw new ServiceError(`status must be one of: ${TASK_STATUSES.join(", ")}`, 400);
+    }
+    return this.taskRepo.create(project.id, input);
+  }
+
+  update(id: string, input: UpdateTaskInput): Task | null {
+    if (input.title !== undefined && !input.title.trim()) {
+      throw new ServiceError("title cannot be empty", 400);
+    }
+    if (input.title !== undefined && input.title.length > 500) {
+      throw new ServiceError("title must be 500 characters or fewer", 400);
+    }
+    if (input.description !== undefined && input.description.length > 10000) {
+      throw new ServiceError("description must be 10000 characters or fewer", 400);
+    }
+    if (input.status !== undefined && !(TASK_STATUSES as readonly string[]).includes(input.status)) {
+      throw new ServiceError(`status must be one of: ${TASK_STATUSES.join(", ")}`, 400);
+    }
+    return this.taskRepo.update(id, input);
+  }
+
+  delete(id: string): boolean {
+    return this.taskRepo.delete(id);
+  }
+}

package/src/domain/services.ts

@@ -0,0 +1,22 @@
+import type { Project, Task } from "./entities";
+import type {
+  CreateProjectInput,
+  UpdateProjectInput,
+  CreateTaskInput,
+  UpdateTaskInput,
+} from "./inputs";
+
+export interface IProjectService {
+  findAll(): Project[];
+  findBySlug(slug: string): Project | null;
+  create(input: CreateProjectInput): Project;
+  update(slug: string, input: UpdateProjectInput): Project | null;
+  delete(slug: string): boolean;
+}
+
+export interface ITaskService {
+  findByProjectSlug(projectSlug: string): Task[];
+  create(projectSlug: string, input: CreateTaskInput): Task;
+  update(id: string, input: UpdateTaskInput): Task | null;
+  delete(id: string): boolean;
+}

package/src/domain/statuses.ts

@@ -0,0 +1,5 @@
+export const PROJECT_STATUSES = ["active", "paused", "completed", "archived"] as const;
+export type ProjectStatus = (typeof PROJECT_STATUSES)[number];
+
+export const TASK_STATUSES = ["todo", "in_progress", "done"] as const;
+export type TaskStatus = (typeof TASK_STATUSES)[number];

package/src/index.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env bun
+import { Server } from "./server";
+
+new Server().start();

package/src/mcp/index.ts

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

package/src/mcp/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 "../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-for-projects",
+    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/mcp/standalone.ts

@@ -0,0 +1,48 @@
+#!/usr/bin/env bun
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { bootstrap } from "../domain";
+import { parseArgs, logListening, type ServerOptions } from "../domain/args";
+import { handleMcpHttp } from "./server";
+
+export class McpStandaloneServer {
+  private options: ServerOptions;
+
+  constructor(options?: Partial<ServerOptions>) {
+    const defaults = parseArgs({ port: 3001, portEnv: "PM_MCP_PORT" });
+    this.options = { ...defaults, ...options };
+  }
+
+  start(): void {
+    const { port, host, dbPath } = this.options;
+    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));
+
+    logListening("tab-for-projects mcp (standalone)", host, port);
+
+    Bun.serve({
+      port,
+      hostname: host,
+      fetch: app.fetch,
+    });
+  }
+}
+
+// Direct execution
+if (import.meta.main) {
+  new McpStandaloneServer().start();
+}

package/src/server/index.ts

@@ -0,0 +1,102 @@
+#!/usr/bin/env bun
+import { Hono } from "hono";
+import { logger } from "hono/logger";
+import { cors } from "hono/cors";
+import { serveStatic } from "hono/bun";
+import { compress } from "hono/compress";
+import { secureHeaders } from "hono/secure-headers";
+import { etag } from "hono/etag";
+import { join } from "path";
+import { readFileSync, existsSync } from "fs";
+import { bootstrap, ServiceError } from "../domain";
+import { parseArgs, logListening, type ServerOptions } from "../domain/args";
+import type { ContentfulStatusCode } from "hono/utils/http-status";
+import { projectRoutes } from "./routes/projects";
+import { taskRoutes } from "./routes/tasks";
+import { handleMcpHttp } from "../mcp/server";
+
+export class Server {
+  private options: ServerOptions;
+
+  constructor(options?: Partial<ServerOptions>) {
+    const defaults = parseArgs({ port: 3000, portEnv: "PM_PORT" });
+    this.options = { ...defaults, ...options };
+  }
+
+  start(): void {
+    const { port, host, dbPath } = this.options;
+    const ctx = bootstrap(dbPath);
+
+    const app = new Hono();
+
+    // ── Global middleware ──────────────────────────────────
+    app.use("*", secureHeaders());
+    app.use("*", compress());
+    app.use(
+      "*",
+      cors({
+        origin: (origin) =>
+          origin?.startsWith("http://localhost") || origin?.startsWith("http://127.0.0.1")
+            ? origin
+            : null,
+        allowMethods: ["GET", "POST", "PATCH", "DELETE", "OPTIONS"],
+        allowHeaders: ["Content-Type", "mcp-session-id", "Last-Event-ID", "mcp-protocol-version"],
+        exposeHeaders: ["mcp-session-id", "mcp-protocol-version"],
+      })
+    );
+
+    // ── API (with logging) ────────────────────────────────
+    app.use("/api/*", logger((str) => process.stderr.write(str + "\n")));
+    app.route("/api/projects/:projectSlug/tasks", taskRoutes(ctx.taskService));
+    app.route("/api/projects", projectRoutes(ctx.projectService));
+    app.get("/api/health", (c) => c.json({ status: "ok" }));
+
+    // ── MCP (no logging) ──────────────────────────────────
+    app.all("/mcp", (c) => handleMcpHttp(ctx, c.req.raw));
+
+    // ── Static web assets ─────────────────────────────────
+    const dist = join(import.meta.dir, "../web/dist");
+    const indexPath = join(dist, "index.html");
+    const indexHtml = existsSync(indexPath)
+      ? readFileSync(indexPath, "utf-8")
+      : null;
+
+    app.use(
+      "/assets/*",
+      etag(),
+      async (c, next) => {
+        await next();
+        c.header("Cache-Control", "public, max-age=31536000, immutable");
+      }
+    );
+    app.use("/*", etag());
+    app.use("/*", serveStatic({ root: dist }));
+
+    // SPA fallback
+    app.get("/*", (c) => {
+      if (indexHtml) return c.html(indexHtml);
+      return c.text("Not found — run `bun run build` first", 404);
+    });
+
+    // ── Error handling ────────────────────────────────────
+    app.onError((err, c) => {
+      if (err instanceof SyntaxError) return c.json({ error: "invalid JSON body" }, 400);
+      if (err instanceof ServiceError) return c.json({ error: err.message }, err.statusCode as ContentfulStatusCode);
+      console.error(err);
+      return c.json({ error: "internal server error" }, 500);
+    });
+
+    logListening("tab-for-projects", host, port);
+
+    Bun.serve({
+      port,
+      hostname: host,
+      fetch: app.fetch,
+    });
+  }
+}
+
+// Direct execution
+if (import.meta.main) {
+  new Server().start();
+}

package/src/server/routes/projects.ts

@@ -0,0 +1,58 @@
+import { Hono } from "hono";
+import type { ContentfulStatusCode } from "hono/utils/http-status";
+import {
+  ServiceError,
+  type IProjectService,
+  type CreateProjectInput,
+  type UpdateProjectInput,
+} from "../../domain";
+
+export function projectRoutes(service: IProjectService): Hono {
+  const app = new Hono();
+
+  // GET /api/projects
+  app.get("/", (c) => {
+    return c.json(service.findAll());
+  });
+
+  // POST /api/projects
+  app.post("/", async (c) => {
+    const body = await c.req.json<CreateProjectInput>();
+    try {
+      const project = service.create(body);
+      return c.json(project, 201);
+    } catch (e: unknown) {
+      if (e instanceof ServiceError) return c.json({ error: e.message }, e.statusCode as ContentfulStatusCode);
+      throw e;
+    }
+  });
+
+  // GET /api/projects/:slug
+  app.get("/:slug", (c) => {
+    const project = service.findBySlug(c.req.param("slug"));
+    if (!project) return c.json({ error: "project not found" }, 404);
+    return c.json(project);
+  });
+
+  // PATCH /api/projects/:slug
+  app.patch("/:slug", async (c) => {
+    const body = await c.req.json<UpdateProjectInput>();
+    try {
+      const project = service.update(c.req.param("slug"), body);
+      if (!project) return c.json({ error: "project not found" }, 404);
+      return c.json(project);
+    } catch (e: unknown) {
+      if (e instanceof ServiceError) return c.json({ error: e.message }, e.statusCode as ContentfulStatusCode);
+      throw e;
+    }
+  });
+
+  // DELETE /api/projects/:slug
+  app.delete("/:slug", (c) => {
+    const deleted = service.delete(c.req.param("slug"));
+    if (!deleted) return c.json({ error: "project not found" }, 404);
+    return c.json({ ok: true });
+  });
+
+  return app;
+}

package/src/server/routes/tasks.ts

@@ -0,0 +1,58 @@
+import { Hono } from "hono";
+import type { ContentfulStatusCode } from "hono/utils/http-status";
+import {
+  ServiceError,
+  type ITaskService,
+  type CreateTaskInput,
+  type UpdateTaskInput,
+} from "../../domain";
+
+export function taskRoutes(service: ITaskService): Hono {
+  const app = new Hono();
+
+  // GET /api/projects/:projectSlug/tasks
+  app.get("/", (c) => {
+    const projectSlug = c.req.param("projectSlug")!;
+    try {
+      return c.json(service.findByProjectSlug(projectSlug));
+    } catch (e: unknown) {
+      if (e instanceof ServiceError) return c.json({ error: e.message }, e.statusCode as ContentfulStatusCode);
+      throw e;
+    }
+  });
+
+  // POST /api/projects/:projectSlug/tasks
+  app.post("/", async (c) => {
+    const projectSlug = c.req.param("projectSlug")!;
+    const body = await c.req.json<CreateTaskInput>();
+    try {
+      const task = service.create(projectSlug, body);
+      return c.json(task, 201);
+    } catch (e: unknown) {
+      if (e instanceof ServiceError) return c.json({ error: e.message }, e.statusCode as ContentfulStatusCode);
+      throw e;
+    }
+  });
+
+  // PATCH /api/projects/:projectSlug/tasks/:id
+  app.patch("/:id", async (c) => {
+    const body = await c.req.json<UpdateTaskInput>();
+    try {
+      const task = service.update(c.req.param("id")!, body);
+      if (!task) return c.json({ error: "task not found" }, 404);
+      return c.json(task);
+    } catch (e: unknown) {
+      if (e instanceof ServiceError) return c.json({ error: e.message }, e.statusCode as ContentfulStatusCode);
+      throw e;
+    }
+  });
+
+  // DELETE /api/projects/:projectSlug/tasks/:id
+  app.delete("/:id", (c) => {
+    const deleted = service.delete(c.req.param("id")!);
+    if (!deleted) return c.json({ error: "task not found" }, 404);
+    return c.json({ ok: true });
+  });
+
+  return app;
+}