feat(project): add DELETE /project/:id endpoint (#25004)

packages/opencode/src/project/project.ts

@@ -1,7 +1,8 @@
 import z from "zod"
 import { and } from "drizzle-orm"
 import { Database } from "@/storage/db"
-import { eq } from "drizzle-orm"
+import { eq, sql } from "drizzle-orm"
+import { NotFoundError } from "@/storage/storage"
 import { ProjectTable } from "./project.sql"
 import { SessionTable } from "../session/session.sql"
 import * as Log from "@opencode-ai/core/util/log"
@@ -127,6 +128,7 @@ export interface Interface {
   readonly sandboxes: (id: ProjectID) => Effect.Effect<string[]>
   readonly addSandbox: (id: ProjectID, directory: string) => Effect.Effect<void>
   readonly removeSandbox: (id: ProjectID, directory: string) => Effect.Effect<void>
+  readonly remove: (id: ProjectID) => Effect.Effect<{ deleted: boolean; sessionsRemoved: number }>
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/Project") {}
@@ -490,6 +492,21 @@ export const layer: Layer.Layer<
       yield* emitUpdated(fromRow(result))
     })
 
+    const remove = Effect.fn("Project.remove")(function* (id: ProjectID) {
+      const sessionsRow = yield* db((d) =>
+        d
+          .select({ count: sql<number>`count(*)` })
+          .from(SessionTable)
+          .where(eq(SessionTable.project_id, id))
+          .get(),
+      )
+      const result = yield* db(
+        (d) => d.delete(ProjectTable).where(eq(ProjectTable.id, id)).run() as unknown as { changes: number },
+      )
+      if (result.changes === 0) throw new NotFoundError({ message: `Project not found: ${id}` })
+      return { deleted: true, sessionsRemoved: sessionsRow?.count ?? 0 }
+    })
+
     return Service.of({
       init,
       fromDirectory,
@@ -502,6 +519,7 @@ export const layer: Layer.Layer<
       sandboxes,
       addSandbox,
       removeSandbox,
+      remove,
     })
   }),
 )

packages/opencode/src/server/routes/instance/httpapi/groups/project.ts

@@ -57,6 +57,20 @@ export const ProjectApi = HttpApi.make("project")
             description: "Update project properties such as name, icon, and commands.",
           }),
         ),
+        HttpApiEndpoint.delete("remove", `${root}/:projectID`, {
+          params: { projectID: ProjectID },
+          success: Schema.Struct({
+            deleted: Schema.Boolean,
+            sessionsRemoved: Schema.Number,
+          }),
+        }).annotateMerge(
+          OpenApi.annotations({
+            identifier: "project.delete",
+            summary: "Delete project",
+            description:
+              "Delete a project and permanently remove all associated data including sessions, messages, and history.",
+          }),
+        ),
       )
       .annotateMerge(
         OpenApi.annotations({
@@ -75,3 +89,4 @@ export const ProjectApi = HttpApi.make("project")
       description: "Experimental HttpApi surface for selected instance routes.",
     }),
   )
+

packages/opencode/src/server/routes/instance/httpapi/handlers/project.ts

@@ -5,7 +5,7 @@ import { ProjectID } from "@/project/schema"
 import { Effect } from "effect"
 import { HttpApiBuilder } from "effect/unstable/httpapi"
 import { InstanceHttpApi } from "../api"
-import { markInstanceForReload } from "../lifecycle"
+import { markInstanceForDisposal, markInstanceForReload } from "../lifecycle"
 
 export const projectHandlers = HttpApiBuilder.group(InstanceHttpApi, "project", (handlers) =>
   Effect.gen(function* () {
@@ -39,6 +39,22 @@ export const projectHandlers = HttpApiBuilder.group(InstanceHttpApi, "project",
       return yield* svc.update({ ...ctx.payload, projectID: ctx.params.projectID })
     })
 
-    return handlers.handle("list", list).handle("current", current).handle("initGit", initGit).handle("update", update)
+    const remove_ = Effect.fn("ProjectHttpApi.remove")(function* (ctx: {
+      params: { projectID: ProjectID }
+    }) {
+      const instance = yield* InstanceState.context
+      const result = yield* svc.remove(ctx.params.projectID)
+      if (ctx.params.projectID === instance.project.id) {
+        yield* markInstanceForDisposal(instance)
+      }
+      return result
+    })
+
+    return handlers
+      .handle("list", list)
+      .handle("current", current)
+      .handle("initGit", initGit)
+      .handle("update", update)
+      .handle("remove", remove_)
   }),
 )

packages/opencode/src/server/routes/instance/project.ts

@@ -112,5 +112,43 @@ export const ProjectRoutes = lazy(() =>
           const svc = yield* Project.Service
           return yield* svc.update({ ...body, projectID })
         }),
+    )
+    .delete(
+      "/:projectID",
+      describeRoute({
+        summary: "Delete project",
+        description:
+          "Delete a project and permanently remove all associated data including sessions, messages, and history. Cascading foreign keys handle all child data.",
+        operationId: "project.delete",
+        responses: {
+          200: {
+            description: "Successfully deleted project with cascade count",
+            content: {
+              "application/json": {
+                schema: resolver(
+                  z.object({
+                    deleted: z.boolean(),
+                    sessionsRemoved: z.number(),
+                  }),
+                ),
+              },
+            },
+          },
+          ...errors(400, 404),
+        },
+      }),
+      validator("param", z.object({ projectID: ProjectID.zod })),
+      async (c) => {
+        const projectID = c.req.valid("param").projectID
+        const result = await runRequest(
+          "ProjectRoutes.delete",
+          c,
+          Project.Service.use((svc) => svc.remove(projectID)),
+        )
+        if (projectID === Instance.project.id) {
+          await Instance.dispose()
+        }
+        return c.json(result)
+      },
     ),
 )

packages/opencode/test/project/project.test.ts

@@ -601,3 +601,34 @@ describe("Project.fromDirectory with bare repos", () => {
     }
   })
 })
+
+describe("Project.remove", () => {
+  test("should remove a project", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
+
+    const result = await run((svc) => svc.remove(project.id))
+
+    expect(result).toEqual({ deleted: true, sessionsRemoved: 0 })
+    expect(Project.get(project.id)).toBeUndefined()
+  })
+
+  test("should throw error when project not found", async () => {
+    await expect(
+      run((svc) => svc.remove(ProjectID.make("nonexistent-project-id"))),
+    ).rejects.toThrow("NotFoundError")
+  })
+
+  test("should remove project from list", async () => {
+    await using tmp = await tmpdir({ git: true })
+    const { project } = await run((svc) => svc.fromDirectory(tmp.path))
+
+    const before = Project.list()
+    expect(before.find((p) => p.id === project.id)).toBeDefined()
+
+    await run((svc) => svc.remove(project.id))
+
+    const after = Project.list()
+    expect(after.find((p) => p.id === project.id)).toBeUndefined()
+  })
+})

packages/opencode/test/server/httpapi-instance.test.ts

@@ -80,4 +80,34 @@ describe("instance HttpApi", () => {
       )
     }),
   )
+
+  it.live("serves project delete", () =>
+    Effect.gen(function* () {
+      const dir = yield* tmpdirScoped({ git: true })
+
+      const current = yield* HttpClientRequest.get("/project/current").pipe(
+        directoryHeader(dir),
+        HttpClient.execute,
+      )
+      expect(current.status).toBe(200)
+      const project = (yield* current.json) as { id: string }
+
+      const response = yield* HttpClientRequest.make("DELETE")(`/project/${project.id}`).pipe(
+        directoryHeader(dir),
+        HttpClient.execute,
+      )
+      expect(response.status).toBe(200)
+      expect(yield* response.json).toMatchObject({ deleted: true, sessionsRemoved: 0 })
+
+      const list = yield* HttpClientRequest.get("/project").pipe(
+        directoryHeader(dir),
+        HttpClient.execute,
+      )
+      expect(list.status).toBe(200)
+      const projects = (yield* list.json) as Array<{ id: string }>
+      expect(projects).not.toContainEqual(
+        expect.objectContaining({ id: project.id }),
+      )
+    }),
+  )
 })