fix(executor): widen the condition environment read to any mention

A member-access pattern decides whether a condition keeps the full secret
map, and every shape it fails to anticipate — `environmentVariables?.FLAG`,
a read through `Object.keys` — silently narrows what that expression can
see and routes the run down a branch the author did not write. Matching the
bare identifier inside the expressions costs only the narrowing, and never
mounts more than this path mounted before it existed.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: icecrasher321

apps/sim/executor/handlers/condition/condition-handler.test.ts

@@ -254,17 +254,28 @@ describe('ConditionBlockHandler', () => {
   })
 
   it('keeps the whole environment for a condition that reads the environment directly', async () => {
-    mockExecuteTool.mockResolvedValueOnce(matchedAt(0))
-
-    const conditions = [
-      { id: 'cond1', title: 'if', value: 'environmentVariables.ROUTE_KEY === "beta"' },
-      { id: 'else1', title: 'else', value: '' },
+    // Every shape an expression can reach the map through, including the ones a member-access
+    // pattern would miss — narrowing one of those would route the run silently.
+    const reads = [
+      'environmentVariables.ROUTE_KEY === "beta"',
+      'environmentVariables["ROUTE_KEY"] === "beta"',
+      'environmentVariables?.ROUTE_KEY === "beta"',
+      'Object.keys(environmentVariables).length > 0',
     ]
 
-    await handler.execute(mockContext, mockBlock, { conditions: JSON.stringify(conditions) })
+    for (const value of reads) {
+      mockExecuteTool.mockReset()
+      mockExecuteTool.mockResolvedValueOnce(matchedAt(0))
+      const conditions = [
+        { id: 'cond1', title: 'if', value },
+        { id: 'else1', title: 'else', value: '' },
+      ]
 
-    const [, toolParams] = mockExecuteTool.mock.calls[0]
-    expect(toolParams.secretScope).toBe('all')
+      await handler.execute(mockContext, mockBlock, { conditions: JSON.stringify(conditions) })
+
+      const [, toolParams] = mockExecuteTool.mock.calls[0]
+      expect(toolParams.secretScope, `condition ${value}`).toBe('all')
+    }
   })
 
   it('should never forward collected block outputs in the request body', async () => {

apps/sim/executor/handlers/condition/condition-handler.ts

@@ -100,9 +100,15 @@ function buildConditionScript(expressions: string[], evalContext: Record<string,
  * The two scans read different text on purpose. Placeholders are read from the built script,
  * which is exactly what the compiler substitutes over, so a mounted set derived from anything
  * narrower would silently stop resolving a placeholder the compiler still expands. The direct
- * `environmentVariables` read is looked for in the expressions alone, and only as a member
- * access: the script also carries the source block's output as data, so scanning it would let
- * a payload that merely contains the word restore the full map.
+ * `environmentVariables` read is looked for in the expressions alone: the script also carries
+ * the source block's output as data, so scanning that too would let a payload which merely
+ * contains the word restore the full map.
+ *
+ * Within an expression the bare identifier is enough, rather than a member access. Narrowing
+ * the secrets an expression can see when it does reach for the map by some shape the pattern
+ * did not anticipate — `environmentVariables?.FLAG`, or a read through `Object.keys` — would
+ * route the run down a branch the author did not write, silently. Matching too widely only
+ * costs the narrowing itself, and never mounts more than this path already mounted.
  */
 function scopeConditionSecrets(
   code: string,
@@ -111,7 +117,7 @@ function scopeConditionSecrets(
   secretScope: 'all' | 'selected'
   mountedSecrets: string[]
 } {
-  if (expressions.some((expression) => /\benvironmentVariables\s*[.[]/.test(expression))) {
+  if (expressions.some((expression) => /\benvironmentVariables\b/.test(expression))) {
     return { secretScope: 'all', mountedSecrets: [] }
   }