separate out mship template and func template

Author: icecrasher321

apps/docs/content/docs/en/platform/enterprise/self-hosted.mdx

@@ -99,6 +99,25 @@ NEXT_PUBLIC_SANDBOXES_ENABLED=true
 sandbox management in the browser. Set the public flag only after the selected
 provider has credentials and a valid immutable Function base configured.
 
+Mothership's `function_execute` and `run_code` tools use Mothership's separate
+shell image, including for JavaScript without imports. If the deployment uses
+Mothership code tools, also configure the image produced by the Mothership
+release process for the selected provider:
+
+```bash
+# E2B
+MOTHERSHIP_E2B_TEMPLATE_ID=<mothership-shell-template-ref>
+
+# Daytona
+DAYTONA_SHELL_SNAPSHOT_ID=<mothership-shell-snapshot-ref>
+```
+
+These values are selected only for workflow Copilot and workspace Mothership
+code-tool calls. They never replace or act as a fallback for
+`E2B_FUNCTION_TEMPLATE_ID` or
+`DAYTONA_FUNCTION_SNAPSHOT_ID`; Function blocks and custom workspace sandboxes
+continue to use the dedicated Function base.
+
 Use E2B as the release baseline before building or promoting Daytona:
 
 ```bash

apps/sim/.env.example

@@ -27,7 +27,8 @@ NEXT_PUBLIC_APP_URL=http://localhost:3000
 
 # Remote Function sandboxes (Optional)
 # Build a dedicated Function base before enabling JavaScript imports, Python, or Shell.
-# Mothership shell images are separate and are intentionally never used as a fallback.
+# Copilot/Mothership code tools use a separate shell image. It is selected only
+# for those code-tool calls and is never a fallback for Function blocks.
 # SANDBOXES_ENABLED=true                 # Enables custom sandboxes for self-hosted workspaces
 # NEXT_PUBLIC_SANDBOXES_ENABLED=true     # Shows remote Function languages and custom sandbox settings; set only after the provider/base is ready
 #
@@ -38,12 +39,14 @@ NEXT_PUBLIC_APP_URL=http://localhost:3000
 # E2B_API_KEY=
 # E2B_FUNCTION_TEMPLATE_ID=<sim-function-template>:<sim-function-build-id> # Copy the exact ref printed by the builder
 # E2B_FUNCTION_TEMPLATE_GENERATION=<release-epoch-ms> # Copy the monotonic generation printed by the builder
+# MOTHERSHIP_E2B_TEMPLATE_ID=              # Mothership shell template ref, required when Mothership runs code on E2B
 #
 # Daytona
 # Build from an accepted E2B parity manifest with: bun run apps/sim/scripts/build-function-daytona-snapshot.ts --name <name> --parity-manifest <path>
 # SANDBOX_PROVIDER=daytona
 # DAYTONA_API_KEY=
 # DAYTONA_FUNCTION_SNAPSHOT_ID=<snapshot-uuid> # Copy the immutable ID printed by the Daytona builder
+# DAYTONA_SHELL_SNAPSHOT_ID=               # Mothership shell snapshot ref, required when Mothership runs code on Daytona
 
 # Security (Required)
 ENCRYPTION_KEY=your_encryption_key  # Use `openssl rand -hex 32` to generate, used to encrypt environment variables

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

@@ -125,6 +125,7 @@ describe('Function Execute API Route', () => {
   beforeEach(() => {
     vi.clearAllMocks()
     envFlagsMock.isRemoteSandboxEnabled = false
+    envFlagsMock.isMothershipSandboxEnabled = false
 
     hybridAuthMockFns.mockCheckInternalAuth.mockResolvedValue({
       success: true,
@@ -210,6 +211,86 @@ describe('Function Execute API Route', () => {
       expect(data.output.result).toBe('test')
     })
 
+    it('does not accept a Mothership sandbox profile from the request body', async () => {
+      const req = createMockRequest('POST', {
+        code: 'return "test"',
+        sandboxProfile: 'mothership',
+      })
+
+      const response = await POST(req)
+
+      expect(response.status).toBe(200)
+      expect(mockExecuteInIsolatedVM).toHaveBeenCalledTimes(1)
+      expect(mockExecuteInSandbox).not.toHaveBeenCalled()
+    })
+
+    it('fails closed when a trusted Mothership call has no configured image', async () => {
+      hybridAuthMockFns.mockCheckInternalAuth.mockResolvedValueOnce({
+        success: true,
+        userId: 'user-123',
+        authType: 'internal_jwt',
+        sandboxProfile: 'mothership',
+      })
+
+      const response = await POST(
+        createMockRequest('POST', { code: 'return "test"', language: 'javascript' })
+      )
+
+      expect(response.status).toBe(503)
+      await expect(response.json()).resolves.toMatchObject({
+        success: false,
+        error: 'Mothership code sandbox is not configured',
+      })
+      expect(mockExecuteInIsolatedVM).not.toHaveBeenCalled()
+      expect(mockExecuteInSandbox).not.toHaveBeenCalled()
+    })
+
+    it.each([
+      { language: 'javascript', code: 'return 42' },
+      { language: 'python', code: '__sim_result__ = 42' },
+    ])(
+      'runs trusted Mothership $language in the Mothership sandbox image',
+      async ({ language, code }) => {
+        envFlagsMock.isMothershipSandboxEnabled = true
+        hybridAuthMockFns.mockCheckInternalAuth.mockResolvedValueOnce({
+          success: true,
+          userId: 'user-123',
+          authType: 'internal_jwt',
+          sandboxProfile: 'mothership',
+        })
+
+        const response = await POST(createMockRequest('POST', { code, language }))
+
+        expect(response.status).toBe(200)
+        expect(mockExecuteInSandbox).toHaveBeenCalledWith(
+          expect.objectContaining({
+            language,
+            sandboxKind: 'mothership',
+          })
+        )
+        expect(mockExecuteInIsolatedVM).not.toHaveBeenCalled()
+      }
+    )
+
+    it('runs trusted Mothership Shell in the Mothership sandbox image', async () => {
+      envFlagsMock.isMothershipSandboxEnabled = true
+      hybridAuthMockFns.mockCheckInternalAuth.mockResolvedValueOnce({
+        success: true,
+        userId: 'user-123',
+        authType: 'internal_jwt',
+        sandboxProfile: 'mothership',
+      })
+
+      const response = await POST(
+        createMockRequest('POST', { code: 'echo ready', language: 'shell' })
+      )
+
+      expect(response.status).toBe(200)
+      expect(mockExecuteShellInSandbox).toHaveBeenCalledWith(
+        expect.objectContaining({ sandboxKind: 'mothership' })
+      )
+    })
+
     it('should prevent VM escape via constructor chain', async () => {
       mockExecuteInIsolatedVM.mockResolvedValueOnce({ result: undefined, stdout: '' })
 

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

@@ -16,7 +16,7 @@ import {
   validateWorkspaceFileWriteTarget,
   writeWorkspaceFileByPath,
 } from '@/lib/copilot/vfs/resource-writer'
-import { isRemoteSandboxEnabled } from '@/lib/core/config/env-flags'
+import { isMothershipSandboxEnabled, isRemoteSandboxEnabled } from '@/lib/core/config/env-flags'
 import {
   createTimeoutAbortController,
   isTimeoutAbortReason,
@@ -1687,6 +1687,16 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
       logger.warn(`[${requestId}] Unauthorized function execution attempt`)
       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(
@@ -1886,7 +1896,7 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
     }
 
     if (lang === CodeLanguage.Shell) {
-      if (!isRemoteSandboxEnabled) {
+      if (!remoteSandboxEnabled) {
         throw new Error(
           'Shell execution requires a remote code sandbox to be enabled. Please contact your administrator to enable it.'
         )
@@ -1901,7 +1911,7 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
       }
 
       logger.info(`[${requestId}] E2B shell execution`, {
-        enabled: isRemoteSandboxEnabled,
+        enabled: remoteSandboxEnabled,
         hasApiKey: Boolean(process.env.E2B_API_KEY),
         envVarCount: Object.keys(shellEnvs).length,
       })
@@ -1924,6 +1934,7 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
         outputSandboxPaths,
         workspaceId,
         sandboxId: selectedSandboxId,
+        ...(usesMothershipSandbox ? { sandboxKind: 'mothership' as const } : {}),
         signal: executionSignal,
       })
       const executionTime = Date.now() - execStart
@@ -1971,22 +1982,23 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
       )
     }
 
-    if (lang === CodeLanguage.Python && !isRemoteSandboxEnabled) {
+    if (lang === CodeLanguage.Python && !remoteSandboxEnabled) {
       throw new Error(
         'Python execution requires a remote code sandbox to be enabled. Please contact your administrator to enable it, or use JavaScript instead.'
       )
     }
 
-    if (lang === CodeLanguage.JavaScript && hasImports && !isRemoteSandboxEnabled) {
+    if (lang === CodeLanguage.JavaScript && hasImports && !remoteSandboxEnabled) {
       throw new Error(
         'JavaScript code with import statements requires a remote code sandbox to be enabled. Please remove the import statements, or contact your administrator to enable it.'
       )
     }
 
     const useRemoteSandbox =
-      isRemoteSandboxEnabled &&
-      !isCustomTool &&
-      (lang === CodeLanguage.Python || (lang === CodeLanguage.JavaScript && hasImports))
+      usesMothershipSandbox ||
+      (remoteSandboxEnabled &&
+        !isCustomTool &&
+        (lang === CodeLanguage.Python || (lang === CodeLanguage.JavaScript && hasImports)))
 
     if (useRemoteSandbox && containsLargeValueRef(contextVariables)) {
       throw new Error(
@@ -2004,7 +2016,7 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
       !useRemoteSandbox &&
       (outputSandboxPaths.length > 0 || outputSandboxPath || _sandboxFiles?.length)
     ) {
-      const remediation = !isRemoteSandboxEnabled
+      const remediation = !remoteSandboxEnabled
         ? "No remote code sandbox is enabled on this deployment, so there is no sandbox filesystem for any language. Pass input data via params and return output as the code's return value with outputs.files[].path (no sandboxPath)."
         : isCustomTool
           ? "custom tools always run in the isolated JavaScript VM, which has no sandbox filesystem. Pass input data via params and return output as the code's return value."
@@ -2022,7 +2034,7 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
 
     if (useRemoteSandbox) {
       logger.info(`[${requestId}] E2B status`, {
-        enabled: isRemoteSandboxEnabled,
+        enabled: remoteSandboxEnabled,
         hasApiKey: Boolean(process.env.E2B_API_KEY),
         language: lang,
       })
@@ -2086,6 +2098,7 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
           outputSandboxPaths,
           workspaceId,
           sandboxId: selectedSandboxId,
+          ...(usesMothershipSandbox ? { sandboxKind: 'mothership' as const } : {}),
           signal: executionSignal,
         })
         const executionTime = Date.now() - execStart
@@ -2172,6 +2185,7 @@ export const POST = withRouteHandler(async (req: NextRequest) => {
         outputSandboxPaths,
         workspaceId,
         sandboxId: selectedSandboxId,
+        ...(usesMothershipSandbox ? { sandboxKind: 'mothership' as const } : {}),
         signal: executionSignal,
       })
       const executionTime = Date.now() - execStart

apps/sim/lib/auth/hybrid.test.ts

@@ -30,7 +30,7 @@ vi.mock('@/lib/auth/internal', () => ({
   verifyInternalToken: mockVerifyInternalToken,
 }))
 
-import { AuthType, checkHybridAuth } from '@/lib/auth/hybrid'
+import { AuthType, checkHybridAuth, checkInternalAuth } from '@/lib/auth/hybrid'
 
 function createRequest(headers: Record<string, string>): NextRequest {
   return new NextRequest('http://localhost/api/test', { headers })
@@ -111,4 +111,23 @@ describe('checkHybridAuth credential precedence', () => {
     expect(mockAuthenticateApiKeyFromHeader).not.toHaveBeenCalled()
     expect(mockGetSession).not.toHaveBeenCalled()
   })
+
+  it('propagates a signed Mothership sandbox profile through internal auth', async () => {
+    mockVerifyInternalToken.mockResolvedValue({
+      valid: true,
+      userId: 'internal-user',
+      sandboxProfile: 'mothership',
+    })
+
+    const result = await checkInternalAuth(
+      createRequest({ authorization: 'Bearer internal-token' })
+    )
+
+    expect(result).toEqual({
+      success: true,
+      userId: 'internal-user',
+      authType: AuthType.INTERNAL_JWT,
+      sandboxProfile: 'mothership',
+    })
+  })
 })

apps/sim/lib/auth/hybrid.ts

@@ -2,7 +2,7 @@ import { createLogger } from '@sim/logger'
 import type { NextRequest } from 'next/server'
 import { authenticateApiKeyFromHeader, updateApiKeyLastUsed } from '@/lib/api-key/service'
 import { getSession } from '@/lib/auth'
-import { verifyInternalToken } from '@/lib/auth/internal'
+import { type InternalSandboxProfile, verifyInternalToken } from '@/lib/auth/internal'
 
 const logger = createLogger('HybridAuth')
 
@@ -36,6 +36,7 @@ export interface AuthResult {
   userEmail?: string | null
   authType?: AuthTypeValue
   apiKeyType?: 'personal' | 'workspace'
+  sandboxProfile?: InternalSandboxProfile
   error?: string
 }
 
@@ -44,18 +45,27 @@ export interface AuthResult {
  * Only trusts the userId embedded in the JWT payload — never from user-controlled sources.
  */
 function resolveUserFromJwt(
-  verificationUserId: string | null,
+  verification: { userId?: string; sandboxProfile?: InternalSandboxProfile },
   options: { requireWorkflowId?: boolean }
 ): AuthResult {
-  if (verificationUserId) {
-    return { success: true, userId: verificationUserId, authType: AuthType.INTERNAL_JWT }
+  if (verification.userId) {
+    return {
+      success: true,
+      userId: verification.userId,
+      authType: AuthType.INTERNAL_JWT,
+      ...(verification.sandboxProfile ? { sandboxProfile: verification.sandboxProfile } : {}),
+    }
   }
 
   if (options.requireWorkflowId !== false) {
     return { success: false, error: 'userId required but not present in JWT' }
   }
 
-  return { success: true, authType: AuthType.INTERNAL_JWT }
+  return {
+    success: true,
+    authType: AuthType.INTERNAL_JWT,
+    ...(verification.sandboxProfile ? { sandboxProfile: verification.sandboxProfile } : {}),
+  }
 }
 
 /**
@@ -96,7 +106,7 @@ export async function checkInternalAuth(
       return { success: false, error: 'Invalid internal token' }
     }
 
-    return resolveUserFromJwt(verification.userId || null, options)
+    return resolveUserFromJwt(verification, options)
   } catch (error) {
     logger.error('Error in internal authentication:', error)
     return {
@@ -136,7 +146,7 @@ export async function checkSessionOrInternalAuth(
       const verification = await verifyInternalToken(token)
 
       if (verification.valid) {
-        return resolveUserFromJwt(verification.userId || null, options)
+        return resolveUserFromJwt(verification, options)
       }
     }
 
@@ -184,7 +194,7 @@ export async function checkHybridAuth(
       const verification = await verifyInternalToken(token)
 
       if (verification.valid) {
-        return resolveUserFromJwt(verification.userId || null, options)
+        return resolveUserFromJwt(verification, options)
       }
     }