Merge remote-tracking branch 'origin/staging' into fix/stream-continuity

Author: waleedlatif1

apps/sim/app/api/cron/cleanup-stale-executions/route.ts

@@ -32,6 +32,7 @@ import {
   STALE_SWEEPABLE_EXECUTION_STATUSES,
   type StaleSweepableExecutionStatus,
 } from '@/lib/logs/types'
+import { sweepOrphanedRuns } from '@/lib/mothership/async-runs/orphaned-runs'
 import { cancelStaleDispatches } from '@/lib/table/dispatcher'
 import { deleteFile } from '@/lib/uploads/core/storage-service'
 import {
@@ -738,6 +739,20 @@ export const GET = withRouteHandler(async (request: NextRequest) => {
       })
     }
 
+    /**
+     * Settle Chat runs no controller will finish: their process died, their
+     * controller was superseded without a successor, or Stop found none. Without
+     * this they stay unfinished forever and keep their chat marked as busy.
+     */
+    let orphanedRunsSettled = 0
+    try {
+      orphanedRunsSettled = (await sweepOrphanedRuns()).settledRunIds.length
+    } catch (error) {
+      logger.error('Failed to settle orphaned Chat runs:', {
+        error: toError(error).message,
+      })
+    }
+
     return NextResponse.json({
       success: true,
       executions: {
@@ -768,6 +783,9 @@ export const GET = withRouteHandler(async (request: NextRequest) => {
         pruned: deploymentOperationsPruned,
         retentionDays: DEPLOYMENT_OPERATION_RETENTION_DAYS,
       },
+      chatRuns: {
+        orphanedSettled: orphanedRunsSettled,
+      },
     })
   } catch (error) {
     logger.error('Error in stale execution cleanup job:', error)

apps/sim/app/api/workflows/[id]/execute/route.test.ts

@@ -1,3 +1,5 @@
+import { flushMacrotask } from '@sim/testing/helpers/async'
+import { createDeferred } from '@sim/testing/helpers/deferred'
 import { createRouteContext } from '@sim/testing/helpers/http'
 import { asyncJobsMock, asyncJobsMockFns } from '@sim/testing/mocks/async-jobs.mock'
 import {
@@ -551,6 +553,29 @@ describe('workflow execute async route', () => {
     expect(executionOptions.snapshot.input).not.toHaveProperty(PRIVATE_SECRET_PROVENANCE_FIELD)
   })
 
+  it('holds a synchronous response until the run log and its cost are finalized', async () => {
+    configureExecutionCaller(EXECUTION_CALLERS[4])
+    const finalizer = createDeferred<void>()
+    loggingSessionMockFns.mockWaitForPostExecution.mockReturnValue(finalizer.promise)
+
+    let responded = false
+    const pending = POST(
+      createInternalProvenanceRequest(),
+      createRouteContext({ id: 'workflow-1' })
+    )
+    void pending.then(() => {
+      responded = true
+    })
+    await vi.waitFor(() => {
+      expect(loggingSessionMockFns.mockWaitForPostExecution).toHaveBeenCalled()
+    })
+    await flushMacrotask()
+    expect(responded).toBe(false)
+
+    finalizer.resolve()
+    expect((await pending).status).toBe(200)
+  })
+
   it('queues authenticated workflow input provenance without exposing the private sidecar as input', async () => {
     configureExecutionCaller(EXECUTION_CALLERS[4])
 

apps/sim/app/api/workflows/[id]/execute/route.ts

@@ -1636,6 +1636,12 @@ async function handleExecutePost(
             reqLogger.error('Failed to cleanup base64 cache', { error })
           })
         }
+        /**
+         * The sync response is the run's receipt: callers read its log and cost as soon
+         * as it lands. The core finalizes both in the background, so hold the response
+         * until they are durable.
+         */
+        await loggingSession.waitForPostExecution()
       }
     }
 

apps/sim/content/library/best-ai-agent-builders-slack-crm-automation-2026/index.mdx

@@ -891,7 +891,9 @@ async function executeInSandboxWithinBudget(
       await recordSessionFileInput(
         req.session.key,
         { providerId: created.providerId, sandboxId },
-        sandboxSessionInputsSafe() && !Object.keys(selected?.envs ?? {}).length
+        sandboxSessionInputsSafe() &&
+          !req.session.unprovenancedInputs &&
+          !Object.keys(selected?.envs ?? {}).length
       )
     await provisionWithinBudget(sandbox, selected, signal)
     await writeSandboxInputs(sandbox, req.sandboxFiles, {
@@ -1078,7 +1080,9 @@ async function executeShellInSandboxWithinBudget(
       await recordSessionFileInput(
         req.session.key,
         { providerId: created.providerId, sandboxId },
-        sandboxSessionInputsSafe() && !Object.keys(selected?.envs ?? {}).length
+        sandboxSessionInputsSafe() &&
+          !req.session.unprovenancedInputs &&
+          !Object.keys(selected?.envs ?? {}).length
       )
     await provisionWithinBudget(sandbox, selected, signal)
     await writeSandboxInputs(sandbox, req.sandboxFiles, {

apps/sim/content/library/best-ai-automation-tools-2026/index.mdx

@@ -0,0 +1,126 @@
+/**
+ * The persistent workbench's input history is what lets a scratch file reach the model. This runs
+ * the real code boundary against the real history script in a disposable Redis, so a mount the
+ * caller could not classify has to leave the machine uncertified. Only the sandbox provider is a
+ * stand-in: it hands back an existing machine that executes nothing.
+ *
+ * Set TEST_REDIS_URL to an isolated local Redis service.
+ */
+import { createHash } from 'node:crypto'
+import {
+  remoteSandboxProviderMock,
+  remoteSandboxProviderMockFns,
+} from '@sim/testing/mocks/remote-sandbox-provider.mock'
+import { generateShortId } from '@sim/utils/id'
+import { afterAll, describe, expect, it, vi } from 'vitest'
+
+const { redisUrl, inheritedRedisUrl, mockFindSessionSandbox } = await vi.hoisted(async () => {
+  const { readTestRedisUrl } = await import('@sim/db/testing/test-infrastructure')
+  const url = readTestRedisUrl()
+  const inheritedRedisUrl = process.env.REDIS_URL
+  /** The real Redis module reads this at import. */
+  if (url) process.env.REDIS_URL = url
+  return { redisUrl: url, inheritedRedisUrl, mockFindSessionSandbox: vi.fn() }
+})
+
+vi.mock('@/lib/execution/remote-sandbox/provider', () => remoteSandboxProviderMock)
+vi.mock('@/lib/execution/remote-sandbox/resolve', () => ({
+  resolveWorkspaceSandbox: async () => null,
+  provisionRuntimeDependencies: async () => {},
+  repairMissingSandboxImage: async () => null,
+  RUNTIME_INSTALL_TIMEOUT_MS: 60_000,
+}))
+
+import { closeRedisConnection, getRedisClient } from '@/lib/core/config/redis'
+import { CodeLanguage } from '@/lib/execution/languages'
+import {
+  executeInSandbox,
+  executeShellInSandbox,
+  SIM_RESULT_PREFIX,
+} from '@/lib/execution/remote-sandbox'
+import { observeSandboxSessionInputs } from '@/lib/execution/remote-sandbox/execution-observer'
+import {
+  initializeSessionFileProvenance,
+  isSessionFileProvenanceClean,
+} from '@/lib/execution/remote-sandbox/session-file-provenance'
+import type { SandboxHandle, SandboxProvider } from '@/lib/execution/remote-sandbox/types'
+
+remoteSandboxProviderMockFns.mockResolveProvider.mockImplementation(
+  () =>
+    ({
+      id: 'e2b',
+      dependencyStrategy: 'prebuilt',
+      resolveLifetimeMs: (ms: number) => ms,
+      create: async () => {
+        throw new Error('The certification fixture only reuses an existing machine')
+      },
+      findSessionSandbox: mockFindSessionSandbox,
+    }) satisfies SandboxProvider
+)
+
+function machine(sandboxId: string): SandboxHandle {
+  return {
+    sandboxId,
+    runCode: async () => ({ text: `${SIM_RESULT_PREFIX}{"ok":true}`, stdout: '', stderr: '' }),
+    runCommand: async () => ({ stdout: '', stderr: '', exitCode: 0 }),
+    extendLifetime: async () => {},
+    getFileSize: async () => 0,
+    readFile: async () => '',
+    readFileWithLimit: async () => ({ content: '', byteLength: 0 }),
+    writeFile: async () => {},
+    removeFile: async () => {},
+    listFiles: async () => [],
+    kill: async () => {},
+  }
+}
+
+/** Machine-history keys this suite created, so cleanup never touches another suite's state. */
+const createdKeys: string[] = []
+
+afterAll(async () => {
+  if (redisUrl && createdKeys.length) {
+    const redis = getRedisClient()
+    if (redis) await redis.del(...createdKeys)
+  }
+  if (redisUrl) await closeRedisConnection()
+  // Only restore what the hoisted setup changed; assigning undefined would store the string "undefined".
+  if (!redisUrl) return
+  if (inheritedRedisUrl === undefined) Reflect.deleteProperty(process.env, 'REDIS_URL')
+  else process.env.REDIS_URL = inheritedRedisUrl
+})
+
+describe.skipIf(!redisUrl)('workbench certification at the code boundary', () => {
+  it.each([
+    ['code', false],
+    ['code', true],
+    ['shell', false],
+    ['shell', true],
+  ] as const)('%s with unprovenanced mounts %s', async (kind, unprovenanced) => {
+    const sandboxId = `machine-${generateShortId(12)}`
+    const key = `certification-${generateShortId(12)}`
+    const identity = { providerId: 'e2b', sandboxId } as const
+    createdKeys.push(
+      `mothership:workbench-provenance:v1:${createHash('sha256')
+        .update(JSON.stringify([key, identity.providerId, sandboxId]))
+        .digest('hex')}`
+    )
+    mockFindSessionSandbox.mockResolvedValue(machine(sandboxId))
+    await initializeSessionFileProvenance(key, identity)
+    expect(await isSessionFileProvenanceClean(key, identity)).toBe(true)
+
+    const request = {
+      code: 'print(1)',
+      language: CodeLanguage.Python,
+      timeoutMs: 30_000,
+      session: { key, ...(unprovenanced ? { unprovenancedInputs: true } : {}) },
+    }
+    await observeSandboxSessionInputs(
+      () => true,
+      () =>
+        kind === 'code'
+          ? executeInSandbox(request)
+          : executeShellInSandbox({ ...request, envs: {} })
+    )
+    expect(await isSessionFileProvenanceClean(key, identity)).toBe(!unprovenanced)
+  })
+})

apps/sim/content/library/best-gumloop-alternatives-in-2026/index.mdx

@@ -91,6 +91,11 @@ export interface SandboxSessionRequest {
   cli?: { path: string; content: string; runtime?: { path: string; content: string } }
   /** Extra environment variables present on every execution in the session. */
   envs?: Record<string, string>
+  /**
+   * This execution mounts bytes whose secret provenance is unknown, so the machine's input
+   * history must not stay certified clean even when the caller's own inputs are.
+   */
+  unprovenancedInputs?: boolean
 }
 
 export interface SandboxShellExecutionRequest {