feat(copilot): let the mothership manage workspace sandboxes

Adds the manage_sandbox handler (add/edit/delete/list), following the
manage_custom_tool precedent, plus the display title and generated
catalog bindings.

Sandbox create/update/delete moves out of the two REST route files into
workspace-sandboxes.ts as createWorkspaceSandbox/updateWorkspaceSandbox/
deleteWorkspaceSandbox, returning a typed failure the caller renders for
its own surface: the routes map it to 409/400/404, the tool to a
sentence. The routes previously owned the name-conflict pre-check, the
unique-index race catch, the unconditional build enqueue, and the
detached image release; sharing them is what keeps the tool from
drifting from the UI.

The handler reproduces the routes' gate exactly — workspace admin, then
the Max/Enterprise entitlement, then the same per-workspace mutation
bucket — so a sandbox cannot be created through chat that the same user
could not create in Settings > Sandboxes. `list` needs only read access,
matching GET, because a downgraded workspace must still see what it
built. workspaceId comes from server context only.

Author: waleedlatif1

apps/sim/app/api/workspaces/[id]/sandboxes/[sandboxId]/route.ts

@@ -1,28 +1,16 @@
-import { db } from '@sim/db'
-import { workspaceSandbox } from '@sim/db/schema'
-import { createLogger } from '@sim/logger'
-import { and, eq } from 'drizzle-orm'
 import { type NextRequest, NextResponse } from 'next/server'
 import { deleteSandboxContract, updateSandboxContract } from '@/lib/api/contracts/sandboxes'
 import { parseRequest } from '@/lib/api/server'
-import { runDetached } from '@/lib/core/utils/background'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
-import { releaseSandboxImage } from '@/lib/execution/remote-sandbox/image-registry'
-import { invalidateSandboxResolution } from '@/lib/execution/remote-sandbox/resolve'
 import {
-  isSandboxNameTaken,
-  readWorkspaceSandbox,
-  scheduleSandboxBuild,
+  deleteWorkspaceSandbox,
+  updateWorkspaceSandbox,
 } from '@/lib/execution/remote-sandbox/workspace-sandboxes'
 import {
   authorizeSandboxMutation,
-  buildSpecOrResponse,
-  isNameConflictError,
-  nameConflictResponse,
+  sandboxFailureResponse,
 } from '@/app/api/workspaces/[id]/sandboxes/authorize'
 
-const logger = createLogger('WorkspaceSandboxAPI')
-
 type SandboxContext = { params: Promise<{ id: string; sandboxId: string }> }
 
 export const PATCH = withRouteHandler(async (request: NextRequest, context: SandboxContext) => {
@@ -35,77 +23,16 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: Sand
   if (!parsed.success) return parsed.response
   const { name, language, dependencies } = parsed.data.body
 
-  const [existing] = await db
-    .select({
-      id: workspaceSandbox.id,
-      name: workspaceSandbox.name,
-      language: workspaceSandbox.language,
-      dependencies: workspaceSandbox.dependencies,
-      specHash: workspaceSandbox.specHash,
-    })
-    .from(workspaceSandbox)
-    .where(and(eq(workspaceSandbox.id, sandboxId), eq(workspaceSandbox.workspaceId, workspaceId)))
-    .limit(1)
-
-  if (!existing) {
-    return NextResponse.json({ error: 'Sandbox not found' }, { status: 404 })
-  }
-
-  const nextName = name ?? existing.name
-  if (name && name !== existing.name && (await isSandboxNameTaken(workspaceId, name, sandboxId))) {
-    return nameConflictResponse(name)
-  }
-
-  // Both halves are revalidated together even when only one changed: switching
-  // language has to re-check the existing list against the new language's rules,
-  // and editing dependencies has to check them against the stored language.
-  const nextLanguage = language ?? (existing.language as 'javascript' | 'python')
-  const nextDependencies = dependencies ?? existing.dependencies ?? []
-
-  const built = buildSpecOrResponse(nextLanguage, nextDependencies)
-  if (!built.ok) return built.response
-  const { spec } = built
+  const result = await updateWorkspaceSandbox({
+    workspaceId,
+    sandboxId,
+    name,
+    language,
+    dependencies,
+  })
+  if (!result.ok) return sandboxFailureResponse(result.failure)
 
-  try {
-    await db
-      .update(workspaceSandbox)
-      .set({
-        name: nextName,
-        language: spec.language,
-        dependencies: spec.dependencies,
-        specHash: spec.specHash,
-        updatedAt: new Date(),
-      })
-      // Scoped by workspace as well as id: every other query here is, and relying on
-      // the SELECT above to have 404'd first makes authz an ordering invariant.
-      .where(and(eq(workspaceSandbox.id, sandboxId), eq(workspaceSandbox.workspaceId, workspaceId)))
-  } catch (error) {
-    // The pre-check above can lose a race with a concurrent rename; the unique
-    // index is the real arbiter, and losing it is a conflict, not a server fault.
-    if (isNameConflictError(error)) return nameConflictResponse(nextName)
-    throw error
-  }
-
-  // Unconditional, because the registry decides what a save costs: a `ready` or
-  // in-flight row is left alone, so renaming or re-saving an unchanged spec
-  // enqueues nothing, while a failed one gets the immediate retry a person saving
-  // is asking for. Gating this on a changed hash meant a same-spec save silently
-  // did nothing, and the only way to retry a failed build was to edit the package
-  // list into a different hash.
-  await scheduleSandboxBuild(spec)
-
-  if (spec.specHash !== existing.specHash) {
-    // The previous content address is unreferenced by this sandbox now. Release
-    // no-ops when another sandbox still declares the same package list.
-    runDetached('release-sandbox-image', () => releaseSandboxImage(existing.specHash))
-    logger.info('Sandbox spec changed, scheduled a build', { workspaceId, sandboxId })
-  }
-
-  const sandbox = await readWorkspaceSandbox(workspaceId, sandboxId)
-  if (!sandbox) {
-    return NextResponse.json({ error: 'Failed to read back the updated sandbox' }, { status: 500 })
-  }
-  return NextResponse.json({ sandbox })
+  return NextResponse.json({ sandbox: result.sandbox })
 })
 
 export const DELETE = withRouteHandler(async (request: NextRequest, context: SandboxContext) => {
@@ -117,23 +44,8 @@ export const DELETE = withRouteHandler(async (request: NextRequest, context: San
   const parsed = await parseRequest(deleteSandboxContract, request, context)
   if (!parsed.success) return parsed.response
 
-  // A block may still reference this sandbox. Deleting is allowed anyway; that
-  // execution then fails closed with a message naming the missing sandbox,
-  // rather than silently falling back to an image without its dependencies.
-  const deleted = await db
-    .delete(workspaceSandbox)
-    .where(and(eq(workspaceSandbox.id, sandboxId), eq(workspaceSandbox.workspaceId, workspaceId)))
-    .returning({ id: workspaceSandbox.id, specHash: workspaceSandbox.specHash })
-
-  if (deleted.length === 0) {
-    return NextResponse.json({ error: 'Sandbox not found' }, { status: 404 })
-  }
+  const result = await deleteWorkspaceSandbox(workspaceId, sandboxId)
+  if (!result.ok) return sandboxFailureResponse(result.failure)
 
-  invalidateSandboxResolution()
-  // Detached: the row is already gone, so the caller's delete succeeded whatever
-  // the provider says. Awaiting would hold a UI delete open on a remote call the
-  // retention sweep would retry anyway.
-  runDetached('release-sandbox-image', () => releaseSandboxImage(deleted[0].specHash))
-  logger.info('Deleted workspace sandbox', { workspaceId, sandboxId })
   return NextResponse.json({ success: true })
 })

apps/sim/app/api/workspaces/[id]/sandboxes/authorize.ts

@@ -1,17 +1,12 @@
-import { getErrorMessage } from '@sim/utils/errors'
-import { type NextRequest, NextResponse } from 'next/server'
+import { NextResponse } from 'next/server'
 import { getSession } from '@/lib/auth'
 import { hasWorkspaceSandboxAccess } from '@/lib/billing/core/subscription'
 import { enforceWorkspaceRateLimit } from '@/lib/core/rate-limiter/route-helpers'
-import type { SandboxLanguage } from '@/lib/execution/remote-sandbox/sandbox-spec'
 import {
-  buildSpecUpdate,
   MAX_PLAN_REQUIRED,
   SANDBOX_ADMIN_REQUIRED,
   SANDBOX_MUTATION_LIMIT,
-  SandboxDependencyError,
-  type SandboxSpecUpdate,
-  WORKSPACE_SANDBOX_NAME_INDEX,
+  type SandboxWriteFailure,
 } from '@/lib/execution/remote-sandbox/workspace-sandboxes'
 import { getUserEntityPermissions } from '@/lib/workspaces/permissions/utils'
 
@@ -22,57 +17,32 @@ export interface SandboxMutationActor {
 }
 
 /**
- * The 409 both write paths return for a duplicate name. Shared so the pre-check
- * and the unique-index catch cannot describe the same conflict differently.
- */
-export function nameConflictResponse(name: string): NextResponse {
-  return NextResponse.json(
-    { error: `A sandbox named "${name}" already exists in this workspace` },
-    { status: 409 }
-  )
-}
-
-/**
- * Validates a submitted dependency list, returning the 400 the editor knows how
- * to read — `issues` carries a line number per rejected row, which the generic
- * validation error does not.
+ * Maps a refused write onto the status code the editor expects. Shared by both
+ * route files so the create path and the edit/delete path cannot describe the
+ * same failure differently.
+ *
+ * `invalid_dependencies` carries a line number per rejected row, which the
+ * generic validation error does not — the editor marks those inline.
  */
-export function buildSpecOrResponse(
-  language: SandboxLanguage,
-  dependencies: readonly string[]
-): { ok: true; spec: SandboxSpecUpdate } | { ok: false; response: NextResponse } {
-  try {
-    return { ok: true, spec: buildSpecUpdate(language, dependencies) }
-  } catch (error) {
-    if (error instanceof SandboxDependencyError) {
-      return {
-        ok: false,
-        response: NextResponse.json(
-          { error: error.message, issues: error.issues },
-          { status: 400 }
-        ),
-      }
-    }
-    throw error
+export function sandboxFailureResponse(failure: SandboxWriteFailure): NextResponse {
+  switch (failure.code) {
+    case 'name_conflict':
+      return NextResponse.json(
+        { error: `A sandbox named "${failure.name}" already exists in this workspace` },
+        { status: 409 }
+      )
+    case 'invalid_dependencies':
+      return NextResponse.json({ error: failure.message, issues: failure.issues }, { status: 400 })
+    case 'not_found':
+      return NextResponse.json({ error: 'Sandbox not found' }, { status: 404 })
+    case 'read_back_failed':
+      return NextResponse.json({ error: 'Failed to read back the saved sandbox' }, { status: 500 })
   }
 }
 
-/**
- * Whether a write failed because it collided with the workspace/name unique
- * index. Both paths pre-check the name, but the index is the real arbiter and a
- * concurrent write can still lose the race — which is a 409, not a 500.
- */
-export function isNameConflictError(error: unknown): boolean {
-  const message = getErrorMessage(error)
-  return message.includes(WORKSPACE_SANDBOX_NAME_INDEX) || message.includes('23505')
-}
-
 /**
  * Authenticates, authorizes, entitles, and rate-limits a sandbox mutation — in
  * that order, and always before any untrusted input is parsed.
- *
- * Shared by both route files so the create path and the edit/delete path cannot
- * drift into different checks.
  */
 export async function authorizeSandboxMutation(
   workspaceId: string
@@ -109,7 +79,6 @@ export async function authorizeSandboxMutation(
 
 /** Reads a workspace sandbox list; any member may look, only admins may write. */
 export async function authorizeSandboxRead(
-  _request: NextRequest,
   workspaceId: string
 ): Promise<{ ok: true; userId: string } | { ok: false; response: NextResponse }> {
   const session = await getSession()

apps/sim/app/api/workspaces/[id]/sandboxes/route.ts

@@ -1,26 +1,18 @@
-import { db } from '@sim/db'
-import { workspaceSandbox } from '@sim/db/schema'
 import { createLogger } from '@sim/logger'
-import { getErrorMessage } from '@sim/utils/errors'
-import { generateId } from '@sim/utils/id'
 import { type NextRequest, NextResponse } from 'next/server'
 import { createSandboxContract } from '@/lib/api/contracts/sandboxes'
 import { parseRequest } from '@/lib/api/server'
 import { hasWorkspaceSandboxAccess } from '@/lib/billing/core/subscription'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import {
+  createWorkspaceSandbox,
   currentSandboxStrategy,
-  isSandboxNameTaken,
   listWorkspaceSandboxes,
-  readWorkspaceSandbox,
-  scheduleSandboxBuild,
 } from '@/lib/execution/remote-sandbox/workspace-sandboxes'
 import {
   authorizeSandboxMutation,
   authorizeSandboxRead,
-  buildSpecOrResponse,
-  isNameConflictError,
-  nameConflictResponse,
+  sandboxFailureResponse,
 } from '@/app/api/workspaces/[id]/sandboxes/authorize'
 
 const logger = createLogger('WorkspaceSandboxesAPI')
@@ -29,7 +21,7 @@ export const GET = withRouteHandler(
   async (request: NextRequest, context: { params: Promise<{ id: string }> }) => {
     const workspaceId = (await context.params).id
 
-    const viewer = await authorizeSandboxRead(request, workspaceId)
+    const viewer = await authorizeSandboxRead(workspaceId)
     if (!viewer.ok) return viewer.response
 
     // The list itself is not plan-gated: a workspace that downgraded must still
@@ -59,43 +51,20 @@ export const POST = withRouteHandler(
     if (!parsed.success) return parsed.response
     const { name, language, dependencies } = parsed.data.body
 
-    const built = buildSpecOrResponse(language, dependencies)
-    if (!built.ok) return built.response
-    const { spec } = built
-
-    if (await isSandboxNameTaken(workspaceId, name)) {
-      return nameConflictResponse(name)
-    }
-
-    const id = generateId()
-    try {
-      await db.insert(workspaceSandbox).values({
-        id,
-        workspaceId,
-        name,
-        language: spec.language,
-        dependencies: spec.dependencies,
-        specHash: spec.specHash,
-        createdBy: authorized.actor.userId,
-      })
-    } catch (error) {
-      // The unique index is the real arbiter — the pre-check above only exists to
-      // return a friendlier message when there is no race.
-      if (isNameConflictError(error)) return nameConflictResponse(name)
-      logger.error('Failed to insert sandbox', { workspaceId, error: getErrorMessage(error) })
-      throw error
-    }
-
-    await scheduleSandboxBuild(spec)
-    logger.info('Created workspace sandbox', { workspaceId, sandboxId: id, language })
+    const result = await createWorkspaceSandbox({
+      workspaceId,
+      userId: authorized.actor.userId,
+      name,
+      language,
+      dependencies,
+    })
+    if (!result.ok) return sandboxFailureResponse(result.failure)
 
-    const sandbox = await readWorkspaceSandbox(workspaceId, id)
-    if (!sandbox) {
-      return NextResponse.json(
-        { error: 'Failed to read back the created sandbox' },
-        { status: 500 }
-      )
-    }
-    return NextResponse.json({ sandbox })
+    logger.info('Created workspace sandbox', {
+      workspaceId,
+      sandboxId: result.sandbox.id,
+      language,
+    })
+    return NextResponse.json({ sandbox: result.sandbox })
   }
 )