fix: scope-aware project deletion + per-project dev-server diagnostics

Per-project delete now cleans up ONLY that project (dev server + port + folder)
instead of destroying the shared per-user sandbox (which would have wiped all
the user's projects). Account deletion (Clerk user.deleted) still fully tears
down the sandbox via scope='account'.

- delete-state route: scope 'project'|'account' discriminator; project scope ->
  ProjectSandbox.cleanupProjectWorkspace(workspaceSlug) (kills app-preview:<slug>,
  frees its port, rm -rf /workspace/<slug>); account scope -> destroySandbox once
- gateway deleteProjectRoute sends workspaceSlug + scope:project
- webhooks user.deleted sends scope:account
- preview.ts: keep dev_server_port_allocated/error observability

Verified live: deleting one project leaves the other (its DB row + chat) intact;
sandbox not destroyed. KNOWN follow-up: preview-status/wake still per-sandbox,
not per-project — a project's preview can read 'running' while its dev server is
down (blank preview after idle-stop until re-triggered).

Author: iamjr15

apps/agent-worker/src/agent-routing.ts

@@ -96,7 +96,7 @@ export async function sandboxForProject(
   return sandboxForUser(env, userId);
 }
 
-async function sandboxForUser(
+export async function sandboxForUser(
   env: AgentEnv,
   userId: string,
 ): Promise<DurableObjectStub<ProjectSandbox>> {

apps/agent-worker/src/durable-objects/project-sandbox-runtime.ts

@@ -234,6 +234,15 @@ export const ProjectRestoreBackupInputSchema = z
   })
   .strict();
 
+// Per-project teardown inside the shared per-user sandbox: names ONE project's workspace folder
+// (/workspace/<workspaceSlug>) whose dev server, port, and folder should be reclaimed — without
+// ever touching the shared sandbox itself.
+export const ProjectCleanupWorkspaceInputSchema = z
+  .object({
+    workspaceSlug: z.string().min(1).max(200),
+  })
+  .strict();
+
 export type ProjectExecInput = z.input<typeof ProjectExecInputSchema>;
 export type ProjectStartProcessInput = z.input<typeof ProjectStartProcessInputSchema>;
 export type ProjectPreviewFileInput = z.input<typeof ProjectPreviewFileInputSchema>;
@@ -269,6 +278,7 @@ export interface ProjectSandboxRuntimeState {
 }
 export type ProjectCreateBackupInput = z.input<typeof ProjectCreateBackupInputSchema>;
 export type ProjectRestoreBackupInput = z.input<typeof ProjectRestoreBackupInputSchema>;
+export type ProjectCleanupWorkspaceInput = z.input<typeof ProjectCleanupWorkspaceInputSchema>;
 
 export interface NormalizedRunCodeResult {
   stdout: string;

apps/agent-worker/src/durable-objects/project-sandbox.ts

@@ -1,6 +1,6 @@
 import { DurableObject } from "cloudflare:workers";
 import { resolveWorkerSecret, type WorkerSecret } from "@cheatcode/env";
-import { APIError, normalizeUnknownError } from "@cheatcode/observability";
+import { APIError, createLogger, normalizeUnknownError } from "@cheatcode/observability";
 import {
   DaytonaApiError,
   DaytonaClient,
@@ -36,6 +36,8 @@ import {
   commandToShellString,
   type ProjectAllocatePortInput,
   ProjectAllocatePortInputSchema,
+  type ProjectCleanupWorkspaceInput,
+  ProjectCleanupWorkspaceInputSchema,
   type ProjectCodeServerInput,
   ProjectCodeServerInputSchema,
   type ProjectCreateBackupInput,
@@ -879,6 +881,62 @@ export class ProjectSandbox extends DurableObject<ProjectSandboxEnv> {
     this.startedVerifiedAtMs = 0;
   }
 
+  // Best-effort teardown of ONE project's footprint inside the shared per-user sandbox: kills the
+  // project's dev server, frees its port allocation, and removes its /workspace/<slug> folder. It
+  // deliberately never destroys the sandbox or wipes DO state (that would nuke the user's OTHER
+  // projects). Project deletion must not fail on cleanup, so every step is catch-and-log.
+  public async cleanupProjectWorkspace(input: ProjectCleanupWorkspaceInput): Promise<void> {
+    try {
+      const { workspaceSlug } = ProjectCleanupWorkspaceInputSchema.parse(input);
+      const id = await this.existingSandboxId();
+      if (!id) {
+        // Nothing provisioned — no dev server, port, or folder to reclaim.
+        return;
+      }
+      const slot = `${APP_PREVIEW_SLOT_PREFIX}${workspaceSlug}`;
+      const port = (await this.portAllocation()).ports[workspaceSlug];
+      await this.deleteProcessRecord(id, slot);
+      if (port !== undefined) {
+        await this.deleteProcessesOnPort(id, port, slot);
+        await this.unexposePort({ port });
+      }
+      await this.freeProjectPort(workspaceSlug);
+      await this.removeWorkspaceFolder(id, workspaceSlug);
+    } catch (error) {
+      createLogger().warn("project_workspace_cleanup_failed", {
+        error: error instanceof Error ? error.message : "Unknown cleanup error",
+      });
+    }
+  }
+
+  // Drop a project's dev-server port from the DO allocation table. webNext/mobileNext are left as-is
+  // so freed ports are never recycled — a rebuilt project always takes the next fresh port.
+  private async freeProjectPort(workspaceSlug: string): Promise<void> {
+    const alloc = await this.portAllocation();
+    if (alloc.ports[workspaceSlug] === undefined) {
+      return;
+    }
+    const ports = Object.fromEntries(
+      Object.entries(alloc.ports).filter(([slug]) => slug !== workspaceSlug),
+    );
+    await this.ctx.storage.put(PORT_ALLOC_KEY, { ...alloc, ports });
+  }
+
+  // Best-effort `rm -rf` of a single project's folder. Guarded so the target is always a non-empty
+  // child of /workspace and can never resolve to /workspace itself or escape it.
+  private async removeWorkspaceFolder(id: string, workspaceSlug: string): Promise<void> {
+    if (!isSingleWorkspaceSegment(workspaceSlug)) {
+      return;
+    }
+    const path = `${WORKSPACE_DIR}/${workspaceSlug}`;
+    await this.client()
+      .execute(id, {
+        command: `rm -rf ${shellQuote(path)}`,
+        timeout: timeoutSeconds(DEFAULT_EXEC_TIMEOUT_MS),
+      })
+      .catch(() => undefined);
+  }
+
   // ----- internals -----
 
   private client(): DaytonaClient {
@@ -1417,6 +1475,12 @@ function shellQuote(arg: string): string {
   return `'${arg.replaceAll("'", "'\\''")}'`;
 }
 
+// A workspace slug must be a single path segment so `/workspace/<slug>` cannot escape /workspace
+// or resolve to /workspace itself (rm -rf guard).
+function isSingleWorkspaceSegment(slug: string): boolean {
+  return slug.length > 0 && !slug.includes("/") && slug !== "." && slug !== "..";
+}
+
 function lowercaseExtension(path: string): string {
   const filename = basename(path).toLowerCase();
   const dot = filename.lastIndexOf(".");

apps/agent-worker/src/index.ts

@@ -52,6 +52,7 @@ import {
   runForRoute,
   sandboxForProject,
   sandboxForThread,
+  sandboxForUser,
   saveTakeoverState,
   startAgentRun,
   startLegacyThreadRun,
@@ -137,8 +138,22 @@ const SandboxFileListQuerySchema = z
 const SandboxReadEncodingQuerySchema = z.enum(["utf8", "base64"]).optional();
 const InternalUserStateDeleteBodySchema = z
   .object({
-    projectIds: z.array(z.string().uuid()).max(1_000),
+    // Per project: id, plus the workspace slug so per-project cleanup can target /workspace/<slug>
+    // in the shared per-user sandbox. `scope` distinguishes the two callers:
+    //   - "project": one project deleted → reclaim ONLY its folder; never destroy the sandbox.
+    //   - "account": user deleted → tear the whole per-user sandbox down exactly once.
+    projects: z
+      .array(
+        z
+          .object({
+            id: z.string().uuid(),
+            workspaceSlug: z.string().min(1).max(200).optional(),
+          })
+          .strict(),
+      )
+      .max(1_000),
     runIds: z.array(z.string().uuid()).max(10_000),
+    scope: z.enum(["project", "account"]).default("account"),
   })
   .strict();
 const InternalUserStateDeleteResponseSchema = z
@@ -281,23 +296,28 @@ agentApp.post("/internal/users/:userId/delete-state", async (c) => {
     }
   }
 
+  // One sandbox per user: resolve it once. Account deletion tears it down; per-project deletion
+  // only reclaims each project's own workspace so the user's OTHER projects survive.
+  const sandbox = await sandboxForUser(c.env, userId);
   let projectStatesDeleted = 0;
-  let projectVolumesDeleted = 0;
-  for (const projectId of body.projectIds) {
-    const sandbox = await sandboxForProject(c.env, userId, projectId);
+  if (body.scope === "account") {
     await sandbox.destroySandbox();
-    if (await sandbox.deleteProjectVolume()) {
-      projectVolumesDeleted += 1;
-    }
     await sandbox.deleteDurableState();
-    projectStatesDeleted += 1;
+    projectStatesDeleted = body.projects.length;
+  } else {
+    for (const project of body.projects) {
+      if (project.workspaceSlug) {
+        await sandbox.cleanupProjectWorkspace({ workspaceSlug: project.workspaceSlug });
+      }
+      projectStatesDeleted += 1;
+    }
   }
 
   return c.json(
     InternalUserStateDeleteResponseSchema.parse({
       ok: true,
       projectStatesDeleted,
-      projectVolumesDeleted,
+      projectVolumesDeleted: 0,
       runStatesDeleted,
     }),
   );

apps/gateway-worker/src/project-routes.ts

@@ -163,10 +163,28 @@ export async function deleteProjectRoute(
   projectId: ProjectIdType,
   userId: UserId,
 ): Promise<Response> {
-  const cleanupBody = JSON.stringify({ projectIds: [projectId], runIds: [] });
-  const cleanupHeaders = await internalMaintenanceHeaders(env, cleanupBody);
   const { db, close } = createDb(env.HYPERDRIVE);
   try {
+    // Read the workspace slug BEFORE soft-deleting (getProject filters deleted rows out) so the
+    // agent worker can reclaim ONLY this project's /workspace/<slug> folder — scope "project"
+    // guarantees it never destroys the shared per-user sandbox and the user's other projects.
+    const project = await withUserContext(db, userId, (tx) =>
+      getProject(tx, { projectId, userId }),
+    );
+    if (!project) {
+      throw notFound("Project not found");
+    }
+    const cleanupBody = JSON.stringify({
+      projects: [
+        {
+          id: projectId,
+          ...(project.workspaceSlug ? { workspaceSlug: project.workspaceSlug } : {}),
+        },
+      ],
+      runIds: [],
+      scope: "project",
+    });
+    const cleanupHeaders = await internalMaintenanceHeaders(env, cleanupBody);
     const deleted = await withUserContext(db, userId, (tx) =>
       softDeleteProject(tx, { projectId, userId }),
     );

apps/web/next-env.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./.next/types/routes.d.ts";
+import "./.next/dev/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

apps/webhooks-worker/src/lifecycle-adapters.ts

@@ -141,8 +141,9 @@ async function deleteAgentDurableState(
     return { projectStatesDeleted, projectVolumesDeleted: 0, runStatesDeleted: 0 };
   }
   const body = JSON.stringify({
-    projectIds: manifest.projectIds,
+    projects: manifest.projectIds.map((id) => ({ id })),
     runIds: manifest.runIds,
+    scope: "account",
   });
   const headers = await internalMaintenanceHeaders(env, body);
   const response = await env.AGENT.fetch(