fix(copilot): keep sandbox config visible

Author: Sg312

apps/sim/blocks/blocks/function.ts

@@ -164,7 +164,8 @@ try {
     timeout: { type: 'number', description: 'Execution timeout' },
     sandboxId: {
       type: 'string',
-      description: 'Sim sandbox providing dependencies, system packages, and managed CLIs',
+      description:
+        'Sim sandbox providing dependencies, system packages, and managed CLIs. Selecting or clearing it requires an active Max or Enterprise plan.',
     },
     secretScope: { type: 'string', description: 'Secret access mode: all or selected' },
     mountedSecrets: {

apps/sim/lib/copilot/sim-sandbox-projection.ts

@@ -1,8 +1,15 @@
-import type { CopilotSanitizationOptions } from '@/lib/workflows/sanitization/json-sanitizer'
+import { SIM_SANDBOXES_ENTITLEMENT } from '@/lib/copilot/entitlements'
 
-export const HIDE_SIM_SANDBOX_INPUTS: CopilotSanitizationOptions = {
-  hiddenInputIdsByBlockType: new Map([['function', new Set(['sandboxId'])]]),
-}
+export const RESTRICTED_SIM_SANDBOX_INPUTS = new Map([
+  [
+    'sandboxId',
+    {
+      requiredEntitlement: SIM_SANDBOXES_ENTITLEMENT,
+      reason:
+        'Selecting or clearing a Sim sandbox requires an active Max or Enterprise plan. Preserve any existing selection unless the user upgrades.',
+    },
+  ],
+])
 
 /** Whether an edit_workflow operation tries to set or clear Function sandboxId. */
 export function operationsReferenceSimSandbox(

apps/sim/lib/copilot/tools/handlers/workflow/queries.ts

@@ -1,8 +1,6 @@
 import { toError } from '@sim/utils/errors'
 import { mergeSubblockStateWithValues } from '@sim/workflow-persistence/subblocks'
-import { hasWorkspaceSandboxAccess } from '@/lib/billing/core/subscription'
 import type { ExecutionContext, ToolCallResult } from '@/lib/copilot/request/types'
-import { HIDE_SIM_SANDBOX_INPUTS } from '@/lib/copilot/sim-sandbox-projection'
 import { formatNormalizedWorkflowForCopilot } from '@/lib/copilot/tools/shared/workflow-utils'
 import { mcpService } from '@/lib/mcp/service'
 import { listWorkspaceFiles } from '@/lib/uploads/contexts/workspace'
@@ -505,24 +503,16 @@ export async function executeGetDeployedWorkflowState(
       return { success: false, error: 'workflowId is required' }
     }
 
-    const { workflow: workflowRecord, workspaceId } = await ensureWorkflowAccess(
-      workflowId,
-      context.userId
-    )
+    const { workflow: workflowRecord } = await ensureWorkflowAccess(workflowId, context.userId)
 
     try {
       const deployedState = await loadDeployedWorkflowState(workflowId)
-      const formatted = formatNormalizedWorkflowForCopilot(
-        {
-          blocks: deployedState.blocks,
-          edges: deployedState.edges,
-          loops: deployedState.loops as Record<string, Loop>,
-          parallels: deployedState.parallels as Record<string, Parallel>,
-        },
-        workspaceId && (await hasWorkspaceSandboxAccess(workspaceId))
-          ? undefined
-          : HIDE_SIM_SANDBOX_INPUTS
-      )
+      const formatted = formatNormalizedWorkflowForCopilot({
+        blocks: deployedState.blocks,
+        edges: deployedState.edges,
+        loops: deployedState.loops as Record<string, Loop>,
+        parallels: deployedState.parallels as Record<string, Parallel>,
+      })
 
       return {
         success: true,

apps/sim/lib/copilot/vfs/serializers.test.ts

@@ -177,7 +177,7 @@ describe('VFS metadata serializers', () => {
 })
 
 describe('entitlement-projected block schemas', () => {
-  it('removes a gated input from both subBlocks and inputs', () => {
+  it('keeps a gated input readable while marking it unavailable for mutation', () => {
     const block = {
       type: 'function',
       name: 'Function',
@@ -198,12 +198,35 @@ describe('entitlement-projected block schemas', () => {
     } as unknown as BlockConfig
 
     const schema = JSON.parse(
-      serializeBlockSchema(block, { hiddenInputIds: new Set(['sandboxId']) })
+      serializeBlockSchema(block, {
+        restrictedInputs: new Map([
+          [
+            'sandboxId',
+            {
+              requiredEntitlement: 'sim-sandboxes',
+              reason: 'Requires an active Max or Enterprise plan.',
+            },
+          ],
+        ]),
+      })
     )
 
-    expect(schema.subBlocks.map((subBlock: { id: string }) => subBlock.id)).toEqual(['code'])
+    expect(schema.subBlocks.map((subBlock: { id: string }) => subBlock.id)).toEqual([
+      'code',
+      'sandboxId',
+    ])
+    expect(schema.subBlocks[1]).toMatchObject({
+      readOnly: true,
+      requiredEntitlement: 'sim-sandboxes',
+      restrictionReason: 'Requires an active Max or Enterprise plan.',
+    })
     expect(schema.inputs).toHaveProperty('code')
-    expect(schema.inputs).not.toHaveProperty('sandboxId')
+    expect(schema.inputs.sandboxId).toMatchObject({
+      type: 'string',
+      readOnly: true,
+      requiredEntitlement: 'sim-sandboxes',
+      restrictionReason: 'Requires an active Max or Enterprise plan.',
+    })
   })
 })
 

apps/sim/lib/copilot/vfs/serializers.ts

@@ -90,6 +90,14 @@ export interface ComponentSerializationOptions {
   ownerBlockType?: string
   /** Product-gated inputs removed from both subBlocks and the input schema. */
   hiddenInputIds?: ReadonlySet<string>
+  /** Product-gated inputs that remain discoverable but cannot be mutated by this viewer. */
+  restrictedInputs?: ReadonlyMap<
+    string,
+    {
+      requiredEntitlement: string
+      reason: string
+    }
+  >
 }
 
 /**
@@ -616,6 +624,12 @@ export function serializeBlockSchema(
 
   const subBlocks = visibleSubBlocks.map((sb) => {
     const serialized = serializeSubBlock(sb)
+    const restriction = options?.restrictedInputs?.get(sb.id)
+    if (restriction) {
+      serialized.readOnly = true
+      serialized.requiredEntitlement = restriction.requiredEntitlement
+      serialized.restrictionReason = restriction.reason
+    }
 
     if (sb.id === 'model' && sb.type === 'combobox' && typeof sb.options === 'function') {
       serialized.options = getStaticModelOptionsForVFS()
@@ -633,10 +647,28 @@ export function serializeBlockSchema(
     if (auth) toolAuth[toolId] = auth
   }
 
-  const inputs =
+  const visibleInputs =
     block.inputs && hiddenIds.size > 0
       ? Object.fromEntries(Object.entries(block.inputs).filter(([key]) => !hiddenIds.has(key)))
       : block.inputs
+  const inputs = visibleInputs
+    ? Object.fromEntries(
+        Object.entries(visibleInputs).map(([key, input]) => {
+          const restriction = options?.restrictedInputs?.get(key)
+          return restriction
+            ? [
+                key,
+                {
+                  ...input,
+                  readOnly: true,
+                  requiredEntitlement: restriction.requiredEntitlement,
+                  restrictionReason: restriction.reason,
+                },
+              ]
+            : [key, input]
+        })
+      )
+    : visibleInputs
 
   return JSON.stringify(
     {

apps/sim/lib/copilot/vfs/workspace-vfs.ts

@@ -38,7 +38,7 @@ import {
   filterSecretNamesByMountPolicy,
   type SecretMountPolicy,
 } from '@/lib/copilot/secret-mount-policy'
-import { HIDE_SIM_SANDBOX_INPUTS } from '@/lib/copilot/sim-sandbox-projection'
+import { RESTRICTED_SIM_SANDBOX_INPUTS } from '@/lib/copilot/sim-sandbox-projection'
 import { compileDoc, getE2BDocFormat } from '@/lib/copilot/tools/server/files/doc-compile'
 import { extractDocText, isExtractableDocExt } from '@/lib/copilot/tools/server/files/doc-extract'
 import { runE2BCompiledCheck } from '@/lib/copilot/tools/server/files/doc-recalc'
@@ -166,7 +166,7 @@ const MAX_COMPILED_ATTACHMENT_BYTES = 5 * 1024 * 1024
  * (see {@link isStaticFileHidden}).
  */
 let staticComponentFiles: Map<string, string> | null = null
-let staticFunctionSchemaWithoutSimSandboxes: string | null = null
+let staticFunctionSchemaWithRestrictedSimSandboxes: string | null = null
 
 /**
  * Owning block for each `components/integrations/**` file, recorded at build
@@ -363,9 +363,9 @@ function getStaticComponentFiles(): Map<string, string> {
     const path = `components/blocks/${block.type}.json`
     files.set(path, serializeBlockSchema(block, { toolConfigs }))
     if (block.type === 'function') {
-      staticFunctionSchemaWithoutSimSandboxes = serializeBlockSchema(block, {
+      staticFunctionSchemaWithRestrictedSimSandboxes = serializeBlockSchema(block, {
         toolConfigs,
-        hiddenInputIds: new Set(['sandboxId']),
+        restrictedInputs: RESTRICTED_SIM_SANDBOX_INPUTS,
       })
     }
   }
@@ -572,9 +572,6 @@ export class WorkspaceVFS {
   >()
   private deploymentCache = new Map<string, Promise<DeploymentData | null>>()
   private _workspaceId = ''
-  // Defaults to hidden so partial/failed materialization cannot leak a gated
-  // Function input. Set from the live Sim entitlement before the VFS is used.
-  private _simSandboxEntitled = false
   /**
    * Types of the org's CURRENT custom blocks (enabled + disabled — a disabled block
    * still resolves/renders). Populated by {@link materializeCustomBlocks}; used to
@@ -817,8 +814,6 @@ export class WorkspaceVFS {
               // prompt prefix), so nothing is destructured from this one.
               timed('tasks', this.materializeTasks(workspaceId, userId)),
             ])
-            this._simSandboxEntitled = sandboxEntitled
-
             const workspaceMdData: WorkspaceMdData = {
               workspace: wsRow,
               members,
@@ -853,7 +848,7 @@ export class WorkspaceVFS {
               if (isStaticFileHidden(path, blockVisibility, allowedIntegrationTypes)) continue
               const projectedContent =
                 path === 'components/blocks/function.json' && !sandboxEntitled
-                  ? (staticFunctionSchemaWithoutSimSandboxes ?? content)
+                  ? (staticFunctionSchemaWithRestrictedSimSandboxes ?? content)
                   : content
               this.files.set(path, projectedContent)
             }
@@ -1546,15 +1541,12 @@ export class WorkspaceVFS {
           // workflow; it still exists and must be readable, so emit an
           // empty-but-valid state.json rather than a 404.
           const sanitized = normalized
-            ? sanitizeForCopilot(
-                {
-                  blocks: normalized.blocks,
-                  edges: normalized.edges,
-                  loops: normalized.loops,
-                  parallels: normalized.parallels,
-                } as any,
-                this._simSandboxEntitled ? undefined : HIDE_SIM_SANDBOX_INPUTS
-              )
+            ? sanitizeForCopilot({
+                blocks: normalized.blocks,
+                edges: normalized.edges,
+                loops: normalized.loops,
+                parallels: normalized.parallels,
+              } as any)
             : sanitizeForCopilot({ blocks: {}, edges: [], loops: {}, parallels: {} } as any)
           return JSON.stringify(sanitized, null, 2)
         })

apps/sim/lib/workflows/sanitization/json-sanitizer.test.ts

@@ -3,7 +3,6 @@
  */
 import { resetUrlsMock, urlsMockFns } from '@sim/testing'
 import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
-import { HIDE_SIM_SANDBOX_INPUTS } from '@/lib/copilot/sim-sandbox-projection'
 import { sanitizeForCopilot } from '@/lib/workflows/sanitization/json-sanitizer'
 import type { WorkflowState } from '@/stores/workflows/workflow/types'
 import { TRIGGER_WEBHOOK_URL_FIELD } from '@/triggers/constants'
@@ -165,7 +164,7 @@ describe('sanitizeForCopilot server-only block inputs', () => {
 })
 
 describe('sanitizeForCopilot product-gated block inputs', () => {
-  it('can hide a persisted Function sandbox selection without hiding ordinary inputs', () => {
+  it('retains a persisted Function sandbox selection for model-visible read access', () => {
     const state = makeSingleBlockWorkflow('function-1', {
       type: 'function',
       name: 'Function 1',
@@ -177,13 +176,10 @@ describe('sanitizeForCopilot product-gated block inputs', () => {
       },
     })
 
-    expect(sanitizeForCopilot(state).blocks['function-1'].inputs).toHaveProperty(
-      'sandboxId',
-      'sandbox-1'
-    )
-    expect(sanitizeForCopilot(state, HIDE_SIM_SANDBOX_INPUTS).blocks['function-1'].inputs).toEqual({
+    expect(sanitizeForCopilot(state).blocks['function-1'].inputs).toEqual({
       code: 'return 1',
       language: 'javascript',
+      sandboxId: 'sandbox-1',
     })
   })
 })