Merge remote-tracking branch 'origin/staging' into feat/unified-server-selector-execution

Author: Bill Leoutsakos

apps/docs/content/docs/integrations/elasticsearch.mdx

@@ -306,7 +306,7 @@ Retrieve index information including settings, mappings, and aliases.
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
-| `index` | json | Index information including aliases, mappings, and settings |
+| `indices` | json | Matched indices keyed by index name, each with its aliases, mappings, and settings |
 
 ### Elasticsearch Cluster Health
 
@@ -324,7 +324,7 @@ Get the health status of the Elasticsearch cluster.
 | `username` | string | No | Username for basic auth |
 | `password` | string | No | Password for basic auth |
 | `waitForStatus` | string | No | Wait until cluster reaches this status: green, yellow, or red |
-| `timeout` | string | No | Timeout for the wait operation \(e.g., 30s, 1m\) |
+| `clusterTimeout` | string | No | How long Elasticsearch waits for the cluster to reach the requested status, as an Elasticsearch time value \(e.g., 30s, 1m\). Not named "timeout": that name is reserved by the tool transport as a client-side abort deadline in milliseconds. |
 
 #### Output
 
@@ -377,12 +377,13 @@ List all indices in the Elasticsearch cluster with their health, status, and sta
 | `apiKey` | string | No | Elasticsearch API key |
 | `username` | string | No | Username for basic auth |
 | `password` | string | No | Password for basic auth |
+| `includeSystemIndices` | boolean | No | Include Elasticsearch system indices \(names starting with "."\). Omitted by default. |
 
 #### Output
 
 | Parameter | Type | Description |
 | --------- | ---- | ----------- |
 | `message` | string | Summary message about the indices |
-| `indices` | json | Array of index information objects |
+| `indices` | json | Array of index information objects \(index, health, status, docsCount, storeSize, primaryShards, replicaShards\). System indices are omitted unless includeSystemIndices is set. |
 
 

apps/sim/app/(landing)/integrations/data/seo-content.ts

@@ -58,15 +58,17 @@ export const INTEGRATION_SEO: Record<string, IntegrationSeoContent> = {
       'slack workflow automation',
       'slack integration',
     ],
-    h1: 'Slack Integrations for Workflow Automation',
+    h1: 'Slack Workflow Automation with Sim',
     tagline:
       'Build Slack workflow automation in Sim. Send, update, delete, and read messages; manage channels, users, canvases, and modals; and trigger AI agents from mentions, messages, and reactions in real time.',
     overview:
-      'Use Sim as your Slack integration for team communication and operations. Build Slack automation that routes requests, posts alerts, summarises threads, updates tickets, and keeps work moving. Sim supports messages, reactions, canvases, views, channel and user lookups, file downloads, and real-time Slack workflows in one workspace.',
+      'Sim automates Slack workflows that depend on conversation context, including message routing, alerts, thread summaries, ticket updates, and incident response. Slack messages and events start agent workflows that interpret what was said and choose the next action in Slack or a connected tool, so routine coordination and time-sensitive operations keep moving without anyone relaying details by hand.',
     triggersIntro:
-      'Connect the Slack Webhook trigger to Sim and run Slack workflow automation the moment a mention, message, or reaction happens, no polling, no delay.',
+      'Sim supports one real-time Slack trigger. Select the Slack events you care about, such as mentions, messages, and reactions, and Sim starts the connected workflow the moment one arrives instead of waiting for a scheduled check. A monitoring alert posted in Slack can open an incident-response workflow, and a ticketing update posted in Slack can be summarised and passed to another connected tool.',
     templatesIntro:
-      'Ready-to-use Slack automation templates for Q&A bots, sales alerts, incident response, standups, digests, and CRM updates. Click any template to launch a workflow faster.',
+      'Pre-built agent templates turn common Slack workflows into editable starting points: routing templates classify messages and send them to the right channel or owner, summarisation templates condense long threads into updates that preserve decisions and action items, and ticket sync and incident response templates update connected records and coordinate follow-up. Every template is editable, so you can adapt its channels, routing rules, data sources, and approval requirements.',
+    toolsSubtitleSuffix:
+      ' across messaging, channels, threads, users, reactions and files, and canvases and views. Combine multiple Slack actions in one workflow to summarise a message, route it, update a ticket, and post the ticket update back in Slack',
   },
   airtable: {
     title: 'Airtable Automation with Sim',

apps/sim/blocks/blocks/elasticsearch.ts

@@ -483,15 +483,32 @@ Return ONLY valid JSON - no explanations, no markdown code blocks.`,
       condition: { field: 'operation', value: 'elasticsearch_cluster_health' },
     },
 
-    // Cluster health timeout
+    // Cluster health timeout. The subBlock id stays `timeout` so saved workflow
+    // state keeps resolving; `tools.config.params` remaps it to `clusterTimeout`
+    // and clears the transport's reserved `timeout` key.
     {
       id: 'timeout',
-      title: 'Timeout (seconds)',
+      title: 'Timeout',
       type: 'short-input',
-      placeholder: '30',
+      placeholder: '30s',
+      mode: 'advanced',
       condition: { field: 'operation', value: 'elasticsearch_cluster_health' },
     },
 
+    // Include system indices
+    {
+      id: 'includeSystemIndices',
+      title: 'Include System Indices',
+      type: 'dropdown',
+      options: [
+        { label: 'No', id: '' },
+        { label: 'Yes', id: 'true' },
+      ],
+      value: () => '',
+      mode: 'advanced',
+      condition: { field: 'operation', value: 'elasticsearch_list_indices' },
+    },
+
     // Retry on conflict
     {
       id: 'retryOnConflict',
@@ -528,9 +545,15 @@ Return ONLY valid JSON - no explanations, no markdown code blocks.`,
         if (params.size) result.size = Number(params.size)
         if (params.from) result.from = Number(params.from)
         if (params.retryOnConflict) result.retryOnConflict = Number(params.retryOnConflict)
-        if (params.timeout && typeof params.timeout === 'string') {
-          result.timeout = params.timeout.endsWith('s') ? params.timeout : `${params.timeout}s`
+
+        if (params.includeSystemIndices === 'true') result.includeSystemIndices = true
+
+        const rawTimeout = typeof params.timeout === 'string' ? params.timeout.trim() : ''
+        if (rawTimeout) {
+          result.clusterTimeout = /^\d+$/.test(rawTimeout) ? `${rawTimeout}s` : rawTimeout
         }
+        result.timeout = undefined
+
         return result
       },
     },
@@ -559,7 +582,14 @@ Return ONLY valid JSON - no explanations, no markdown code blocks.`,
     mappings: { type: 'string', description: 'Index mappings as JSON' },
     refresh: { type: 'string', description: 'Refresh policy' },
     waitForStatus: { type: 'string', description: 'Wait for cluster status' },
-    timeout: { type: 'string', description: 'Timeout for wait operations' },
+    timeout: {
+      type: 'string',
+      description: 'How long Elasticsearch waits for the cluster to reach the requested status',
+    },
+    includeSystemIndices: {
+      type: 'string',
+      description: 'Include Elasticsearch system indices when listing',
+    },
     retryOnConflict: { type: 'number', description: 'Retry attempts on conflict' },
   },
 
@@ -581,8 +611,14 @@ Return ONLY valid JSON - no explanations, no markdown code blocks.`,
     items: { type: 'json', description: 'Bulk operation results' },
     // Count outputs
     count: { type: 'number', description: 'Document count' },
+    _shards: {
+      type: 'json',
+      description: 'Shard statistics (total, successful, skipped, failed)',
+    },
     // Index outputs
     acknowledged: { type: 'boolean', description: 'Whether operation was acknowledged' },
+    // List indices outputs
+    message: { type: 'string', description: 'Summary message about the indices listed' },
     // Cluster outputs
     cluster_name: { type: 'string', description: 'Cluster name' },
     status: { type: 'string', description: 'Cluster health status' },

apps/sim/executor/variables/resolver.ts

@@ -694,9 +694,10 @@ export class VariableResolver {
       return null
     }
 
-    // Reuse an existing marker for the same file so referencing one path twice
-    // mounts it once, rather than transferring a second copy under a
-    // collision-suffixed name and spending the mount budget twice.
+    // Reuse the marker already standing for this file so a path referenced twice
+    // costs one context variable rather than two. What keeps it to one mount is
+    // `planUserFileMounts`, which collapses by storage key across every source —
+    // this only keeps the duplicate out of the request body.
     const existing = Object.entries(contextVarAccumulator).find(
       ([, value]) => isSandboxFileMountRef(value) && value.file.key === file.key
     )

apps/sim/lib/charts/spec.test.ts

@@ -95,6 +95,7 @@ describe('shapeTableRows', () => {
 })
 
 const XSS_FORMATTER = '<img src=x onerror="alert(1)">'
+const XSS_LINK = 'javascript:alert(document.domain)'
 
 describe('parseChartSpec option confinement', () => {
   it('forces the tooltip off the innerHTML path, keeping the formatter template', () => {
@@ -175,6 +176,23 @@ describe('parseChartSpec option confinement', () => {
     expect(media[0].option.toolbox).toBeUndefined()
   })
 
+  it('drops every navigation sink — title link/sublink and treemap/sunburst item links', () => {
+    const option = parse({
+      schema_version: 1,
+      option: {
+        title: { text: 'click me', link: XSS_LINK, sublink: XSS_LINK, target: 'self' },
+        series: [
+          { type: 'treemap', data: [{ name: 'a', value: 1, link: XSS_LINK }] },
+          { type: 'sunburst', data: [{ name: 'b', value: 1, link: XSS_LINK }] },
+        ],
+        baseOption: { title: { link: XSS_LINK } },
+        media: [{ query: { minWidth: 100 }, option: { title: { link: XSS_LINK } } }],
+      },
+    })
+    expect(JSON.stringify(option)).not.toContain('javascript:')
+    expect(option.title).toEqual({ text: 'click me', target: 'self' })
+  })
+
   it('adds no tooltip to a document that declares none', () => {
     const option = parse({ schema_version: 1, option: { series: [{ type: 'bar', data: [1] }] } })
     expect('tooltip' in option).toBe(false)
@@ -191,7 +209,7 @@ describe('parseChartSpec option confinement', () => {
   })
 
   it('leaves dataset rows alone — they hold data, not components', () => {
-    const rows = [{ tooltip: 'ok', toolbox: 'ok' }]
+    const rows = [{ tooltip: 'ok', toolbox: 'ok', link: 'ok' }]
     const option = parse({ schema_version: 1, option: { dataset: { source: rows } } })
     expect((option.dataset as Record<string, unknown>).source).toEqual(rows)
   })
@@ -268,6 +286,24 @@ describe('chart option confinement against echarts', () => {
     )
     expect(model.getComponent('toolbox')).toBeUndefined()
   })
+
+  it('leaves the title component no link to hand to windowOpen', () => {
+    const model = renderModel(
+      parse({
+        schema_version: 1,
+        option: {
+          xAxis: {},
+          yAxis: {},
+          series: [{ type: 'bar', data: [1] }],
+          title: { text: 'click me', link: XSS_LINK, sublink: XSS_LINK },
+        },
+      })
+    )
+    const title = model.getComponent('title')
+    expect(title?.get('text')).toBe('click me')
+    expect(title?.get('link')).toBeUndefined()
+    expect(title?.get('sublink')).toBeUndefined()
+  })
 })
 
 describe('parseChartSpec table-shaping validation', () => {

apps/sim/lib/charts/spec.ts

@@ -52,6 +52,9 @@ export interface ChartSpec {
 /** ECharts' tooltip render mode that draws into the chart canvas instead of the DOM. */
 const CANVAS_TOOLTIP_RENDER_MODE = 'richText'
 
+/** Option keys stripped at every level: the `toolbox` DOM sink and the `link`/`sublink` navigation sinks. */
+const DROPPED_KEYS = ['toolbox', 'link', 'sublink'] as const
+
 /**
  * Closes the paths by which an ECharts option reaches the DOM, so a `.chart`
  * document cannot inject markup into the page that renders it. A document is
@@ -63,7 +66,14 @@ const CANVAS_TOOLTIP_RENDER_MODE = 'richText'
  * string `formatter` is used as that content's template verbatim — only the
  * values substituted into it are escaped. A `toolbox` assigns `dataView.lang`
  * entries to `innerHTML` and fills a `saveAsImage` popup with `document.write`.
- * Forcing the render mode and dropping the toolbox leaves the document no DOM
+ * Forcing the render mode and dropping the toolbox leaves it no DOM sink.
+ *
+ * ECharts also navigates: `title.link`, `title.sublink`, and a `link` on a
+ * treemap or sunburst data item each reach `windowOpen`, which assigns the URL
+ * to `location.href` — so a `javascript:` URL runs on this origin on a single
+ * click. A chart has no reason to navigate its viewer, so the keys are dropped
+ * everywhere rather than scheme-checked, which would still leave an open
+ * redirect on an authenticated origin. Between them the document is left no
  * sink at all, which holds whatever any individual option value contains.
  *
  * The walk is deep because `tooltip` is not only a top-level component:
@@ -79,8 +89,9 @@ function confineOptionToCanvas(node: unknown): void {
   }
   if (node === null || typeof node !== 'object') return
   const record = node as Record<string, unknown>
-  // biome-ignore lint/performance/noDelete: the key must be absent, not undefined-valued
-  if ('toolbox' in record) delete record.toolbox
+  for (const key of DROPPED_KEYS) {
+    if (key in record) delete record[key]
+  }
   for (const key of Object.keys(record)) {
     if (key === 'dataset') continue
     const value = record[key]

apps/sim/lib/execution/remote-sandbox/conformance.test.ts

@@ -868,6 +868,59 @@ describe.each(PROVIDERS)('sandbox conformance [%s]', (provider) => {
     ).rejects.toThrow(/over the 20-file export limit/)
   })
 
+  it('spends one file ceiling across declared and harvested outputs', async () => {
+    // The limit is what an execution exports, not what one directory holds, so a
+    // request that both declares and harvests cannot take 20 of each.
+    stubCodeRun(provider, `__SIM_RESULT__=${JSON.stringify('done')}`)
+    stubOutputFileSizes(provider, 1, 1)
+    stubOutputDirListing(
+      Array.from({ length: MAX_SANDBOX_OUTPUT_FILES - 1 }, (_, index) => ({
+        path: `/tmp/sim/outputs/file-${index}.txt`,
+        size: 1,
+      }))
+    )
+
+    await expect(
+      executeInSandbox({
+        code: 'x',
+        language: CodeLanguage.Python,
+        timeoutMs: 1000,
+        outputSandboxPaths: ['/out/first.txt', '/out/second.txt'],
+        outputSandboxDir: '/tmp/sim/outputs',
+      })
+    ).rejects.toThrow(/produced 21 files .* over the 20-file export limit/)
+  })
+
+  it('does not charge a declared path inside the harvest directory to the ceiling twice', async () => {
+    // The directory holds exactly the limit and the request names one of those
+    // files. Charging it on both sides would refuse a run exporting 20 files.
+    stubCodeRun(provider, `__SIM_RESULT__=${JSON.stringify('done')}`)
+    // One inspection for the declared path, then one per file actually read.
+    stubOutputFileSizes(provider, ...Array.from({ length: MAX_SANDBOX_OUTPUT_FILES + 1 }, () => 1))
+    stubOutputDirListing(
+      Array.from({ length: MAX_SANDBOX_OUTPUT_FILES }, (_, index) => ({
+        path: `/tmp/sim/outputs/file-${index}.txt`,
+        size: 1,
+      }))
+    )
+    for (let index = 0; index < MAX_SANDBOX_OUTPUT_FILES; index += 1) {
+      stubOutputFileRead(provider, 'x')
+    }
+
+    const result = await executeInSandbox({
+      code: 'x',
+      language: CodeLanguage.Python,
+      timeoutMs: 1000,
+      outputSandboxPath: '/tmp/sim/outputs/file-0.txt',
+      outputSandboxDir: '/tmp/sim/outputs',
+    })
+
+    // Exported once as a declared path, rather than a second time as a harvest.
+    expect(Object.keys(result.exportedFiles ?? {})).toEqual(['/tmp/sim/outputs/file-0.txt'])
+    expect(result.collectedFiles).toHaveLength(MAX_SANDBOX_OUTPUT_FILES - 1)
+    expect(result.collectedFiles?.map((file) => file.relativePath)).not.toContain('file-0.txt')
+  })
+
   it('does not list the output directory when no harvest was requested', async () => {
     stubCodeRun(provider, `__SIM_RESULT__=${JSON.stringify('done')}`)
 

apps/sim/lib/execution/remote-sandbox/index.ts

@@ -554,10 +554,16 @@ function requestedOutputSandboxPaths(req: {
  * too many files, or nesting past what the listing reaches — before a single
  * byte is read. Sorted so a multi-file result is stable run to run rather than
  * inheriting whatever order the provider happened to return.
+ *
+ * `declaredPaths` are the files the request already named. One sitting inside the
+ * directory is dropped rather than harvested a second time, and the rest count
+ * toward the ceiling: the limit is what one execution exports, not what one
+ * directory holds, so declaring and harvesting cannot spend it twice.
  */
 async function listOutputDirectoryFiles(
   sandbox: SandboxHandle,
   outputSandboxDir: string,
+  declaredPaths: ReadonlySet<string>,
   signal: AbortSignal
 ): Promise<SandboxDirectoryEntry[]> {
   let listed: SandboxDirectoryEntry[]
@@ -593,9 +599,10 @@ async function listOutputDirectoryFiles(
     )
   }
 
-  const files = entries.filter((entry) => entry.kind === 'file')
-  if (files.length > MAX_SANDBOX_OUTPUT_FILES) {
-    throw new SandboxOutputFileCountError(files.length, outputSandboxDir)
+  const files = entries.filter((entry) => entry.kind === 'file' && !declaredPaths.has(entry.path))
+  const exported = declaredPaths.size + files.length
+  if (exported > MAX_SANDBOX_OUTPUT_FILES) {
+    throw new SandboxOutputFileCountError(exported, outputSandboxDir)
   }
   return files.sort((a, b) => a.path.localeCompare(b.path))
 }
@@ -640,16 +647,14 @@ async function collectExportedFiles(
   }
 
   // Sized into the same running total as the declared paths, so an execution
-  // cannot spend the ceiling twice by both declaring and harvesting. A declared
-  // path that happens to sit inside the harvest directory is dropped from the
-  // discovered set rather than counted again — double-billing it would reject a
-  // single output larger than half the ceiling as oversized.
+  // cannot spend the byte ceiling twice by both declaring and harvesting. The
+  // listing applies the same rule to the file-count ceiling and drops a declared
+  // path that happens to sit inside the harvest directory — double-billing it
+  // would reject a single output larger than half the ceiling as oversized.
   const declaredPaths = new Set(readablePaths)
-  const discovered = (
-    req.outputSandboxDir
-      ? await listOutputDirectoryFiles(sandbox, req.outputSandboxDir, options.signal)
-      : []
-  ).filter((entry) => !declaredPaths.has(entry.path))
+  const discovered = req.outputSandboxDir
+    ? await listOutputDirectoryFiles(sandbox, req.outputSandboxDir, declaredPaths, options.signal)
+    : []
   for (const entry of discovered) {
     totalOutputBytes += entry.size
     if (totalOutputBytes > MAX_SANDBOX_OUTPUT_BYTES) {