feat(copilot): expose Sim sandboxes to mothership

Author: Sg312

apps/sim/app/api/function/execute/route.test.ts

@@ -291,6 +291,116 @@ describe('Function Execute API Route', () => {
       )
     })
 
+    it.each([
+      { language: 'javascript', code: 'return 42' },
+      { language: 'python', code: '__sim_result__ = 42' },
+    ])(
+      'runs trusted Mothership $language in the selected Function-based Sim sandbox',
+      async ({ language, code }) => {
+        envFlagsMock.isRemoteSandboxEnabled = true
+        hybridAuthMockFns.mockCheckInternalAuth.mockResolvedValueOnce({
+          success: true,
+          userId: 'user-123',
+          authType: 'internal_jwt',
+          sandboxProfile: 'mothership',
+        })
+
+        const response = await POST(
+          createMockRequest('POST', {
+            code,
+            language,
+            workspaceId: 'workspace-1',
+            sandboxId: 'sandbox-1',
+          })
+        )
+
+        expect(response.status).toBe(200)
+        const request = mockExecuteInSandbox.mock.calls.at(-1)?.[0]
+        expect(request).toMatchObject({
+          language,
+          workspaceId: 'workspace-1',
+          sandboxId: 'sandbox-1',
+        })
+        expect(request).not.toHaveProperty('sandboxKind')
+      }
+    )
+
+    it('runs trusted Mothership Shell in the selected Sim sandbox', async () => {
+      envFlagsMock.isRemoteSandboxEnabled = true
+      hybridAuthMockFns.mockCheckInternalAuth.mockResolvedValueOnce({
+        success: true,
+        userId: 'user-123',
+        authType: 'internal_jwt',
+        sandboxProfile: 'mothership',
+      })
+
+      const response = await POST(
+        createMockRequest('POST', {
+          code: 'kubectl version --client',
+          language: 'shell',
+          workspaceId: 'workspace-1',
+          sandboxId: 'sandbox-1',
+        })
+      )
+
+      expect(response.status).toBe(200)
+      const request = mockExecuteShellInSandbox.mock.calls.at(-1)?.[0]
+      expect(request).toMatchObject({
+        workspaceId: 'workspace-1',
+        sandboxId: 'sandbox-1',
+      })
+      expect(request).not.toHaveProperty('sandboxKind')
+    })
+
+    it('does not treat the Mothership base as a fallback for a selected Sim sandbox', async () => {
+      envFlagsMock.isMothershipSandboxEnabled = true
+      hybridAuthMockFns.mockCheckInternalAuth.mockResolvedValueOnce({
+        success: true,
+        userId: 'user-123',
+        authType: 'internal_jwt',
+        sandboxProfile: 'mothership',
+      })
+
+      const response = await POST(
+        createMockRequest('POST', {
+          code: 'return 42',
+          language: 'javascript',
+          workspaceId: 'workspace-1',
+          sandboxId: 'sandbox-1',
+        })
+      )
+
+      expect(response.status).toBe(503)
+      await expect(response.json()).resolves.toMatchObject({
+        error: 'The Function code sandbox is not configured',
+      })
+      expect(mockExecuteInSandbox).not.toHaveBeenCalled()
+      expect(mockExecuteInIsolatedVM).not.toHaveBeenCalled()
+    })
+
+    it('forces import-free JavaScript into the remote runtime when a Sim sandbox is selected', async () => {
+      envFlagsMock.isRemoteSandboxEnabled = true
+
+      const response = await POST(
+        createMockRequest('POST', {
+          code: 'return 42',
+          language: 'javascript',
+          workspaceId: 'workspace-1',
+          sandboxId: 'sandbox-1',
+        })
+      )
+
+      expect(response.status).toBe(200)
+      expect(mockExecuteInSandbox).toHaveBeenCalledWith(
+        expect.objectContaining({
+          language: 'javascript',
+          workspaceId: 'workspace-1',
+          sandboxId: 'sandbox-1',
+        })
+      )
+      expect(mockExecuteInIsolatedVM).not.toHaveBeenCalled()
+    })
+
     it('should prevent VM escape via constructor chain', async () => {
       mockExecuteInIsolatedVM.mockResolvedValueOnce({ result: undefined, stdout: '' })
 

apps/sim/app/api/function/execute/route.ts

@@ -1688,15 +1688,6 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
       return NextResponse.json({ error: auth.error || 'Unauthorized' }, { status: 401 })
     }
     const usesMothershipSandbox = auth.sandboxProfile === 'mothership'
-    if (usesMothershipSandbox && !isMothershipSandboxEnabled) {
-      return NextResponse.json(
-        { success: false, error: 'Mothership code sandbox is not configured' },
-        { status: 503 }
-      )
-    }
-    const remoteSandboxEnabled = usesMothershipSandbox
-      ? isMothershipSandboxEnabled
-      : isRemoteSandboxEnabled
 
     executionDeadlineAt = parseExecutionDeadlineHeader(req.headers)
     includePrivateResolvedSecretNames = requestsPrivateToolMetadata(
@@ -1746,6 +1737,26 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
       isCustomTool = false,
       _sandboxFiles,
     } = body
+    if (selectedSandboxId && !isRemoteSandboxEnabled) {
+      return NextResponse.json(
+        { success: false, error: 'The Function code sandbox is not configured' },
+        { status: 503 }
+      )
+    }
+    if (usesMothershipSandbox && !selectedSandboxId && !isMothershipSandboxEnabled) {
+      return NextResponse.json(
+        { success: false, error: 'Mothership code sandbox is not configured' },
+        { status: 503 }
+      )
+    }
+    // A selected Sim sandbox is layered on the Function base, even for a
+    // trusted Mothership call. Only an unselected Mothership call uses the
+    // separately built Mothership image.
+    const remoteSandboxEnabled = selectedSandboxId
+      ? isRemoteSandboxEnabled
+      : usesMothershipSandbox
+        ? isMothershipSandboxEnabled
+        : isRemoteSandboxEnabled
     const remainingExecutionMs =
       executionDeadlineAt === undefined ? undefined : Math.max(1, executionDeadlineAt - Date.now())
     const timeout =
@@ -1934,7 +1945,9 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
         outputSandboxPaths,
         workspaceId,
         sandboxId: selectedSandboxId,
-        ...(usesMothershipSandbox ? { sandboxKind: 'mothership' as const } : {}),
+        ...(usesMothershipSandbox && !selectedSandboxId
+          ? { sandboxKind: 'mothership' as const }
+          : {}),
         signal: executionSignal,
       })
       const executionTime = Date.now() - execStart
@@ -1998,7 +2011,8 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
       usesMothershipSandbox ||
       (remoteSandboxEnabled &&
         !isCustomTool &&
-        (lang === CodeLanguage.Python || (lang === CodeLanguage.JavaScript && hasImports)))
+        (lang === CodeLanguage.Python ||
+          (lang === CodeLanguage.JavaScript && (hasImports || Boolean(selectedSandboxId)))))
 
     if (useRemoteSandbox && containsLargeValueRef(contextVariables)) {
       throw new Error(
@@ -2098,7 +2112,9 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
           outputSandboxPaths,
           workspaceId,
           sandboxId: selectedSandboxId,
-          ...(usesMothershipSandbox ? { sandboxKind: 'mothership' as const } : {}),
+          ...(usesMothershipSandbox && !selectedSandboxId
+            ? { sandboxKind: 'mothership' as const }
+            : {}),
           signal: executionSignal,
         })
         const executionTime = Date.now() - execStart
@@ -2185,7 +2201,9 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
         outputSandboxPaths,
         workspaceId,
         sandboxId: selectedSandboxId,
-        ...(usesMothershipSandbox ? { sandboxKind: 'mothership' as const } : {}),
+        ...(usesMothershipSandbox && !selectedSandboxId
+          ? { sandboxKind: 'mothership' as const }
+          : {}),
         signal: executionSignal,
       })
       const executionTime = Date.now() - execStart

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

@@ -1,24 +1,15 @@
-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,
+  sandboxMutationErrorResponse,
 } from '@/app/api/workspaces/[id]/sandboxes/authorize'
 
 const logger = createLogger('WorkspaceSandboxAPI')
@@ -33,90 +24,15 @@ export const PATCH = withRouteHandler(async (request: NextRequest, context: Sand
 
   const parsed = await parseRequest(updateSandboxContract, request, context)
   if (!parsed.success) return parsed.response
-  const { name, language, dependencies, cliTools, systemPackages } = parsed.data.body
-
-  const [existing] = await db
-    .select({
-      id: workspaceSandbox.id,
-      name: workspaceSandbox.name,
-      language: workspaceSandbox.language,
-      dependencies: workspaceSandbox.dependencies,
-      cliTools: workspaceSandbox.cliTools,
-      systemPackages: workspaceSandbox.systemPackages,
-      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)
-  }
-
-  // The complete spec is revalidated even when only one field 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 nextCliTools = cliTools ?? existing.cliTools ?? []
-  const nextSystemPackages = systemPackages ?? existing.systemPackages ?? []
-
-  const built = buildSpecOrResponse(
-    nextLanguage,
-    nextDependencies,
-    nextCliTools,
-    nextSystemPackages
-  )
-  if (!built.ok) return built.response
-  const { spec } = built
-
   try {
-    await db
-      .update(workspaceSandbox)
-      .set({
-        name: nextName,
-        language: spec.language,
-        dependencies: spec.dependencies,
-        cliTools: spec.cliTools,
-        systemPackages: spec.systemPackages,
-        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)))
+    const sandbox = await updateWorkspaceSandbox(workspaceId, sandboxId, parsed.data.body)
+    logger.info('Updated workspace sandbox', { workspaceId, sandboxId })
+    return NextResponse.json({ sandbox })
   } 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)
+    const response = sandboxMutationErrorResponse(error)
+    if (response) return response
     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 })
 })
 
 export const DELETE = withRouteHandler(async (request: NextRequest, context: SandboxContext) => {
@@ -128,23 +44,14 @@ 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 })
+  try {
+    await deleteWorkspaceSandbox(workspaceId, sandboxId)
+  } catch (error) {
+    const response = sandboxMutationErrorResponse(error)
+    if (response) return response
+    throw error
   }
 
-  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 })
 })