@x4lt7ab/tab-for-projects 0.1.0 → 0.1.1

package/src/domain/services/tasks.ts

@@ -1,23 +1,36 @@
 import type { Task } from "../entities";
 import type { CreateTaskInput, UpdateTaskInput } from "../inputs";
-import type { ITaskService } from "../services";
+import type { ITaskService, Paginated, TaskFilter } from "../services";
 import { ServiceError } from "../errors";
 import type { TaskRepository } from "../repositories/tasks";
 import type { ProjectRepository } from "../repositories/projects";
 import { TASK_STATUSES } from "../statuses";
+import type { EventBus } from "../events";
 
 export class TaskService implements ITaskService {
   constructor(
     private taskRepo: TaskRepository,
-    private projectRepo: ProjectRepository
+    private projectRepo: ProjectRepository,
+    private eventBus?: EventBus,
   ) {}
 
-  findByProjectSlug(projectSlug: string): Task[] {
+  findByProjectSlug(projectSlug: string, limit = 100, offset = 0, filter?: TaskFilter): Paginated<Task> {
     const project = this.projectRepo.findBySlug(projectSlug);
     if (!project) {
       throw new ServiceError("project not found", 404);
     }
-    return this.taskRepo.findByProject(project.id);
+    return {
+      data: this.taskRepo.findByProject(project.id, limit, offset, filter),
+      total: this.taskRepo.countByProject(project.id, filter),
+    };
+  }
+
+  findByNumber(projectSlug: string, number: number): Task | null {
+    const project = this.projectRepo.findBySlug(projectSlug);
+    if (!project) {
+      throw new ServiceError("project not found", 404);
+    }
+    return this.taskRepo.findByNumber(project.id, number);
   }
 
   create(projectSlug: string, input: CreateTaskInput): Task {
@@ -37,10 +50,21 @@ export class TaskService implements ITaskService {
     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);
+    if (input.priority !== undefined && input.priority !== null) {
+      if (!Number.isInteger(input.priority) || input.priority < 1 || input.priority > 10) {
+        throw new ServiceError("priority must be an integer between 1 and 10", 400);
+      }
+    }
+    const task = this.taskRepo.create(project.id, input);
+    this.eventBus?.emit({ entity: "task", action: "created", payload: task });
+    return task;
   }
 
-  update(id: string, input: UpdateTaskInput): Task | null {
+  update(projectSlug: string, id: string, input: UpdateTaskInput): Task | null {
+    const project = this.projectRepo.findBySlug(projectSlug);
+    if (!project) {
+      throw new ServiceError("project not found", 404);
+    }
     if (input.title !== undefined && !input.title.trim()) {
       throw new ServiceError("title cannot be empty", 400);
     }
@@ -53,10 +77,27 @@ export class TaskService implements ITaskService {
     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);
+    if (input.priority !== undefined && input.priority !== null) {
+      if (!Number.isInteger(input.priority) || input.priority < 1 || input.priority > 10) {
+        throw new ServiceError("priority must be an integer between 1 and 10", 400);
+      }
+    }
+    const task = this.taskRepo.update(id, project.id, input);
+    if (task) {
+      this.eventBus?.emit({ entity: "task", action: "updated", payload: task });
+    }
+    return task;
   }
 
-  delete(id: string): boolean {
-    return this.taskRepo.delete(id);
+  delete(projectSlug: string, id: string): boolean {
+    const project = this.projectRepo.findBySlug(projectSlug);
+    if (!project) {
+      throw new ServiceError("project not found", 404);
+    }
+    const deleted = this.taskRepo.delete(id, project.id);
+    if (deleted) {
+      this.eventBus?.emit({ entity: "task", action: "deleted", payload: { id } });
+    }
+    return deleted;
   }
 }

package/src/domain/services.ts

@@ -1,4 +1,5 @@
-import type { Project, Task } from "./entities";
+import type { Project, Task, Tag } from "./entities";
+import type { ProjectStatus, TaskStatus } from "./statuses";
 import type {
   CreateProjectInput,
   UpdateProjectInput,
@@ -6,8 +7,22 @@ import type {
   UpdateTaskInput,
 } from "./inputs";
 
+export interface Paginated<T> {
+  data: T[];
+  total: number;
+}
+
+export interface ProjectFilter {
+  status?: ProjectStatus;
+}
+
+export interface TaskFilter {
+  status?: TaskStatus;
+  tag?: string;
+}
+
 export interface IProjectService {
-  findAll(): Project[];
+  findAll(limit?: number, offset?: number, filter?: ProjectFilter): Paginated<Project>;
   findBySlug(slug: string): Project | null;
   create(input: CreateProjectInput): Project;
   update(slug: string, input: UpdateProjectInput): Project | null;
@@ -15,8 +30,20 @@ export interface IProjectService {
 }
 
 export interface ITaskService {
-  findByProjectSlug(projectSlug: string): Task[];
+  findByProjectSlug(projectSlug: string, limit?: number, offset?: number, filter?: TaskFilter): Paginated<Task>;
+  findByNumber(projectSlug: string, number: number): Task | null;
   create(projectSlug: string, input: CreateTaskInput): Task;
-  update(id: string, input: UpdateTaskInput): Task | null;
+  update(projectSlug: string, id: string, input: UpdateTaskInput): Task | null;
+  delete(projectSlug: string, id: string): boolean;
+}
+
+export interface ITagService {
+  findAll(limit?: number, offset?: number): Paginated<Tag>;
+  findByName(name: string): Tag | null;
+  create(name: string): Tag;
   delete(id: string): boolean;
+  addTagToTask(taskId: string, tagName: string): Tag;
+  removeTagFromTask(taskId: string, tagId: string): boolean;
+  getTagsForTask(taskId: string): Tag[];
+  findTasksByTag(tagName: string, limit?: number, offset?: number): Paginated<Task>;
 }

package/src/mcp/index.ts

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

package/src/mcp/server.ts

@@ -7,11 +7,13 @@ import {
   TASK_STATUSES,
   type IProjectService,
   type ITaskService,
+  type ITagService,
 } from "../domain";
 
 export interface McpServiceContext {
   projectService: IProjectService;
   taskService: ITaskService;
+  tagService: ITagService;
 }
 
 function handle<T>(fn: () => T) {
@@ -25,13 +27,17 @@ function handle<T>(fn: () => T) {
         isError: true,
       };
     }
-    throw err;
+    console.error(err);
+    return {
+      content: [{ type: "text" as const, text: "internal server error" }],
+      isError: true,
+    };
   }
 }
 
 /** Create an McpServer with all tools registered. */
 export function createMcpServer(ctx: McpServiceContext): McpServer {
-  const { projectService, taskService } = ctx;
+  const { projectService, taskService, tagService } = ctx;
 
   const server = new McpServer({
     name: "tab-for-projects",
@@ -40,13 +46,23 @@ export function createMcpServer(ctx: McpServiceContext): McpServer {
 
   // ── Projects ──────────────────────────────────────────────
 
-  server.registerTool("list_projects", { description: "List all projects" }, () =>
-    handle(() => projectService.findAll())
+  server.registerTool(
+    "list_projects",
+    {
+      description: "List projects (paginated, filterable)",
+      inputSchema: {
+        limit: z.number().int().min(1).max(200).optional(),
+        offset: z.number().int().min(0).optional(),
+        status: z.enum(PROJECT_STATUSES).optional(),
+      },
+    },
+    ({ limit, offset, status }) =>
+      handle(() => projectService.findAll(limit, offset, status ? { status } : undefined))
   );
 
   server.registerTool(
     "get_project",
-    { description: "Get a project by slug", inputSchema: { slug: z.string() } },
+    { description: "Get a project by slug", inputSchema: { slug: z.string().max(100) } },
     ({ slug }) => handle(() => projectService.findBySlug(slug))
   );
 
@@ -55,9 +71,9 @@ export function createMcpServer(ctx: McpServiceContext): McpServer {
     {
       description: "Create a new project",
       inputSchema: {
-        name: z.string(),
-        slug: z.string(),
-        description: z.string().optional(),
+        name: z.string().max(255),
+        slug: z.string().max(100),
+        description: z.string().max(10000).optional(),
         status: z.enum(PROJECT_STATUSES).optional(),
       },
     },
@@ -69,9 +85,9 @@ export function createMcpServer(ctx: McpServiceContext): McpServer {
     {
       description: "Update an existing project",
       inputSchema: {
-        slug: z.string(),
-        name: z.string().optional(),
-        description: z.string().optional(),
+        slug: z.string().max(100),
+        name: z.string().max(255).optional(),
+        description: z.string().max(10000).optional(),
         status: z.enum(PROJECT_STATUSES).optional(),
       },
     },
@@ -80,7 +96,7 @@ export function createMcpServer(ctx: McpServiceContext): McpServer {
 
   server.registerTool(
     "delete_project",
-    { description: "Delete a project by slug", inputSchema: { slug: z.string() } },
+    { description: "Delete a project by slug", inputSchema: { slug: z.string().max(100) } },
     ({ slug }) => handle(() => projectService.delete(slug))
   );
 
@@ -88,8 +104,34 @@ export function createMcpServer(ctx: McpServiceContext): McpServer {
 
   server.registerTool(
     "list_tasks",
-    { description: "List tasks for a project", inputSchema: { project_slug: z.string() } },
-    ({ project_slug }) => handle(() => taskService.findByProjectSlug(project_slug))
+    {
+      description: "List tasks for a project (paginated, filterable by status and tag)",
+      inputSchema: {
+        project_slug: z.string().max(100),
+        limit: z.number().int().min(1).max(500).optional(),
+        offset: z.number().int().min(0).optional(),
+        status: z.enum(TASK_STATUSES).optional(),
+        tag: z.string().max(50).optional(),
+      },
+    },
+    ({ project_slug, limit, offset, status, tag }) => {
+      const filter: { status?: typeof status; tag?: string } = {};
+      if (status) filter.status = status;
+      if (tag) filter.tag = tag;
+      return handle(() => taskService.findByProjectSlug(project_slug, limit, offset, Object.keys(filter).length ? filter : undefined));
+    }
+  );
+
+  server.registerTool(
+    "get_task_by_number",
+    {
+      description: "Get a task by its project-scoped number",
+      inputSchema: {
+        project_slug: z.string().max(100),
+        number: z.number().int().min(1),
+      },
+    },
+    ({ project_slug, number }) => handle(() => taskService.findByNumber(project_slug, number))
   );
 
   server.registerTool(
@@ -97,10 +139,11 @@ export function createMcpServer(ctx: McpServiceContext): McpServer {
     {
       description: "Create a task in a project",
       inputSchema: {
-        project_slug: z.string(),
-        title: z.string(),
-        description: z.string().optional(),
+        project_slug: z.string().max(100),
+        title: z.string().max(500),
+        description: z.string().max(10000).optional(),
         status: z.enum(TASK_STATUSES).optional(),
+        priority: z.number().int().min(1).max(10).optional(),
       },
     },
     ({ project_slug, ...input }) => handle(() => taskService.create(project_slug, input))
@@ -109,32 +152,133 @@ export function createMcpServer(ctx: McpServiceContext): McpServer {
   server.registerTool(
     "update_task",
     {
-      description: "Update a task by ID",
+      description: "Update a task by ID (must specify the project it belongs to). Supports priority (1-10 or null to clear).",
       inputSchema: {
-        id: z.string(),
-        title: z.string().optional(),
-        description: z.string().optional(),
+        project_slug: z.string().max(100),
+        id: z.string().max(26),
+        title: z.string().max(500).optional(),
+        description: z.string().max(10000).optional(),
         status: z.enum(TASK_STATUSES).optional(),
+        priority: z.number().int().min(1).max(10).nullable().optional(),
       },
     },
-    ({ id, ...updates }) => handle(() => taskService.update(id, updates))
+    ({ project_slug, id, ...updates }) => handle(() => taskService.update(project_slug, id, updates))
   );
 
   server.registerTool(
     "delete_task",
-    { description: "Delete a task by ID", inputSchema: { id: z.string() } },
-    ({ id }) => handle(() => taskService.delete(id))
+    {
+      description: "Delete a task by ID (must specify the project it belongs to)",
+      inputSchema: { project_slug: z.string().max(100), id: z.string().max(26) },
+    },
+    ({ project_slug, id }) => handle(() => taskService.delete(project_slug, id))
+  );
+
+  // ── Tags ──────────────────────────────────────────────────
+
+  server.registerTool(
+    "list_tags",
+    {
+      description: "List all tags (paginated)",
+      inputSchema: {
+        limit: z.number().int().min(1).max(500).optional(),
+        offset: z.number().int().min(0).optional(),
+      },
+    },
+    ({ limit, offset }) => handle(() => tagService.findAll(limit, offset))
+  );
+
+  server.registerTool(
+    "create_tag",
+    {
+      description: "Create a new tag (lowercase alphanumeric with hyphens)",
+      inputSchema: { name: z.string().max(50) },
+    },
+    ({ name }) => handle(() => tagService.create(name))
+  );
+
+  server.registerTool(
+    "delete_tag",
+    {
+      description: "Delete a tag by ID",
+      inputSchema: { id: z.string().max(26) },
+    },
+    ({ id }) => handle(() => tagService.delete(id))
+  );
+
+  server.registerTool(
+    "add_tag_to_task",
+    {
+      description: "Add a tag to a task (auto-creates tag if it doesn't exist)",
+      inputSchema: {
+        task_id: z.string().max(26),
+        tag_name: z.string().max(50),
+      },
+    },
+    ({ task_id, tag_name }) => handle(() => tagService.addTagToTask(task_id, tag_name))
+  );
+
+  server.registerTool(
+    "remove_tag_from_task",
+    {
+      description: "Remove a tag from a task",
+      inputSchema: {
+        task_id: z.string().max(26),
+        tag_id: z.string().max(26),
+      },
+    },
+    ({ task_id, tag_id }) => handle(() => tagService.removeTagFromTask(task_id, tag_id))
+  );
+
+  server.registerTool(
+    "get_task_tags",
+    {
+      description: "Get all tags for a task",
+      inputSchema: { task_id: z.string().max(26) },
+    },
+    ({ task_id }) => handle(() => tagService.getTagsForTask(task_id))
+  );
+
+  server.registerTool(
+    "find_tasks_by_tag",
+    {
+      description: "Find all tasks with a given tag (cross-project)",
+      inputSchema: {
+        tag_name: z.string().max(50),
+        limit: z.number().int().min(1).max(500).optional(),
+        offset: z.number().int().min(0).optional(),
+      },
+    },
+    ({ tag_name, limit, offset }) => handle(() => tagService.findTasksByTag(tag_name, limit, offset))
   );
 
   return server;
 }
 
-/** Handle a single MCP-over-HTTP request (stateless, one server per request). */
-export async function handleMcpHttp(ctx: McpServiceContext, req: Request): Promise<Response> {
+/**
+ * Create a stateless HTTP handler that reuses a single McpServer instance.
+ *
+ * McpServer supports sequential connect → handle → close cycles (close() resets
+ * the internal transport reference), but does NOT support concurrent connections.
+ * A promise chain serializes requests so connect() is never called while a
+ * previous transport is still active.
+ */
+export function createMcpHttpHandler(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;
+  let pending: Promise<unknown> = Promise.resolve();
+
+  return (req: Request): Promise<Response> => {
+    const result = pending.then(async () => {
+      const transport = new WebStandardStreamableHTTPServerTransport({ enableJsonResponse: true });
+      try {
+        await server.connect(transport);
+        const response = await transport.handleRequest(req);
+        return response;
+      } finally {
+        await server.close();
+      }
+    });
+    pending = result.catch(() => {});
+    return result;
+  };
 }

package/src/mcp/standalone.ts

@@ -1,9 +1,11 @@
 #!/usr/bin/env bun
 import { Hono } from "hono";
+import { logger } from "hono/logger";
 import { cors } from "hono/cors";
+import { secureHeaders } from "hono/secure-headers";
 import { bootstrap } from "../domain";
-import { parseArgs, logListening, type ServerOptions } from "../domain/args";
-import { handleMcpHttp } from "./server";
+import { parseArgs, parseCorsOrigins, logListening, type ServerOptions } from "../domain/args";
+import { createMcpHttpHandler } from "./server";
 
 export class McpStandaloneServer {
   private options: ServerOptions;
@@ -18,19 +20,20 @@ export class McpStandaloneServer {
     const ctx = bootstrap(dbPath);
 
     const app = new Hono();
+    const isAllowedOrigin = parseCorsOrigins(process.env.PM_CORS_ORIGINS);
+    app.use("*", secureHeaders());
     app.use(
       "*",
       cors({
-        origin: (origin) =>
-          origin?.startsWith("http://localhost") || origin?.startsWith("http://127.0.0.1")
-            ? origin
-            : null,
+        origin: (origin) => (origin && isAllowedOrigin(origin)) ? 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));
+    app.use("*", logger((str) => process.stderr.write(str + "\n")));
+    const handleMcp = createMcpHttpHandler(ctx);
+    app.all("/*", (c) => handleMcp(c.req.raw));
 
     logListening("tab-for-projects mcp (standalone)", host, port);
 

package/src/server/index.ts

@@ -5,15 +5,19 @@ import { cors } from "hono/cors";
 import { serveStatic } from "hono/bun";
 import { compress } from "hono/compress";
 import { secureHeaders } from "hono/secure-headers";
+import { bodyLimit } from "hono/body-limit";
 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 { DomainEvent } from "../domain/events";
+import { parseArgs, parseCorsOrigins, 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";
+import { tagRoutes } from "./routes/tags";
+import { createMcpHttpHandler } from "../mcp/server";
+import type { ServerWebSocket } from "bun";
 
 export class Server {
   private options: ServerOptions;
@@ -28,17 +32,16 @@ export class Server {
     const ctx = bootstrap(dbPath);
 
     const app = new Hono();
+    const isAllowedOrigin = parseCorsOrigins(process.env.PM_CORS_ORIGINS);
 
     // ── Global middleware ──────────────────────────────────
     app.use("*", secureHeaders());
     app.use("*", compress());
+    app.use("/api/*", bodyLimit({ maxSize: 1 * 1024 * 1024 }));
     app.use(
       "*",
       cors({
-        origin: (origin) =>
-          origin?.startsWith("http://localhost") || origin?.startsWith("http://127.0.0.1")
-            ? origin
-            : null,
+        origin: (origin) => (origin && isAllowedOrigin(origin)) ? 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"],
@@ -47,12 +50,15 @@ export class Server {
 
     // ── 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/:projectSlug/tasks", taskRoutes(ctx.taskService, ctx.tagService));
     app.route("/api/projects", projectRoutes(ctx.projectService));
+    app.route("/api/tags", tagRoutes(ctx.tagService));
     app.get("/api/health", (c) => c.json({ status: "ok" }));
 
-    // ── MCP (no logging) ──────────────────────────────────
-    app.all("/mcp", (c) => handleMcpHttp(ctx, c.req.raw));
+    // ── MCP ────────────────────────────────────────────────
+    app.use("/mcp", logger((str) => process.stderr.write(str + "\n")));
+    const handleMcp = createMcpHttpHandler(ctx);
+    app.all("/mcp", (c) => handleMcp(c.req.raw));
 
     // ── Static web assets ─────────────────────────────────
     const dist = join(import.meta.dir, "../web/dist");
@@ -86,12 +92,40 @@ export class Server {
       return c.json({ error: "internal server error" }, 500);
     });
 
+    // ── WebSocket client tracking ─────────────────────────
+    const wsClients = new Set<ServerWebSocket<unknown>>();
+
+    ctx.eventBus.subscribe((event: DomainEvent) => {
+      const msg = JSON.stringify(event);
+      for (const ws of wsClients) {
+        ws.send(msg);
+      }
+    });
+
     logListening("tab-for-projects", host, port);
 
     Bun.serve({
       port,
       hostname: host,
-      fetch: app.fetch,
+      fetch(req, server) {
+        // WebSocket upgrade
+        if (new URL(req.url).pathname === "/ws") {
+          if (server.upgrade(req)) return undefined;
+          return new Response("WebSocket upgrade failed", { status: 400 });
+        }
+        return app.fetch(req, server);
+      },
+      websocket: {
+        open(ws) {
+          wsClients.add(ws);
+        },
+        close(ws) {
+          wsClients.delete(ws);
+        },
+        message() {
+          // broadcast-only — client messages are ignored
+        },
+      },
     });
   }
 }

package/src/server/routes/projects.ts

@@ -2,7 +2,9 @@ import { Hono } from "hono";
 import type { ContentfulStatusCode } from "hono/utils/http-status";
 import {
   ServiceError,
+  PROJECT_STATUSES,
   type IProjectService,
+  type ProjectFilter,
   type CreateProjectInput,
   type UpdateProjectInput,
 } from "../../domain";
@@ -12,14 +14,23 @@ export function projectRoutes(service: IProjectService): Hono {
 
   // GET /api/projects
   app.get("/", (c) => {
-    return c.json(service.findAll());
+    const rawLimit = parseInt(c.req.query("limit") ?? "", 10);
+    const limit = Number.isFinite(rawLimit) && rawLimit >= 1 ? Math.min(rawLimit, 200) : 50;
+    const rawOffset = parseInt(c.req.query("offset") ?? "", 10);
+    const offset = Number.isFinite(rawOffset) && rawOffset >= 0 ? rawOffset : 0;
+    const filter: ProjectFilter = {};
+    const status = c.req.query("status");
+    if (status && (PROJECT_STATUSES as readonly string[]).includes(status)) {
+      filter.status = status as ProjectFilter["status"];
+    }
+    return c.json(service.findAll(limit, offset, filter));
   });
 
   // POST /api/projects
   app.post("/", async (c) => {
-    const body = await c.req.json<CreateProjectInput>();
     try {
-      const project = service.create(body);
+      const { name, slug, description, status } = await c.req.json<CreateProjectInput>();
+      const project = service.create({ name, slug, description, status });
       return c.json(project, 201);
     } catch (e: unknown) {
       if (e instanceof ServiceError) return c.json({ error: e.message }, e.statusCode as ContentfulStatusCode);
@@ -36,9 +47,9 @@ export function projectRoutes(service: IProjectService): Hono {
 
   // 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);
+      const { name, description, status } = await c.req.json<UpdateProjectInput>();
+      const project = service.update(c.req.param("slug"), { name, description, status });
       if (!project) return c.json({ error: "project not found" }, 404);
       return c.json(project);
     } catch (e: unknown) {