workflow lint, block catalog, tables, files, sandbox tools: fixes from exploration run 5

Lint: trigger-category blocks are entry blocks (schedule was an orphan); references inside Function code are checked with the runtime tokenizer; the agent-cli lint and grep read the draft state instead of the sanitized export. Catalog: operation inputs publish sub-block ids only (no canonical-param aliases); trigger-category blocks expose their trigger-mode fields. Tables: dispatch processedCount counts unlimited dispatches; json-language code fields accept objects. Files: restore keeps the folder when it still exists. Sandbox tools: outputTable failures report the files already written and the per-language result shape; the file writer keeps the computed result.

Author: Sg312

apps/docs/openapi-v2-files-audit.json

@@ -1265,7 +1265,7 @@
       "post": {
         "operationId": "restoreFile",
         "summary": "Restore File",
-        "description": "Reverse a soft delete and return the file to the workspace. Not a pure undo: the file comes back at the workspace root, and gains a `_restored` suffix when another file there already holds its name, so read `folderPath` and `name` off the response. Restoring an already-active file returns it unchanged, so a retry is safe. An archived workspace is a `400`, and a name the restore could not free is a `409`.",
+        "description": "Reverse a soft delete and return the file to the workspace. Not a pure undo: the file comes back in the folder it was deleted from, or at the workspace root when that folder has since been archived, and gains a `_restored` suffix when another file there already holds its name, so read `folderPath` and `name` off the response. Restoring an already-active file returns it unchanged, so a retry is safe. An archived workspace is a `400`, and a name the restore could not free is a `409`.",
         "tags": ["Files"],
         "parameters": [
           {

apps/sim/app/api/v2/files/[fileId]/restore/route.ts

@@ -14,11 +14,12 @@ export const revalidate = 0
  * `DELETE /api/v2/files/[fileId]` is a soft delete; this reverses it. Find the
  * ids to pass here with `GET /api/v2/files?scope=archived`.
  *
- * Restore is not a pure undo: the file returns to the workspace root regardless
- * of the folder it was deleted from, and it is renamed when its original name
- * is no longer free. The response is therefore the post-restore record, not the
- * one the caller deleted. Restoring an already-active file is a no-op that
- * returns that file, so a retried request is safe.
+ * Restore is not a pure undo: the file returns to the folder it was deleted
+ * from while that folder is still active, and to the workspace root once the
+ * folder has been archived; it is renamed when its original name is no longer
+ * free there. The response is therefore the post-restore record, not the one
+ * the caller deleted. Restoring an already-active file is a no-op that returns
+ * that file, so a retried request is safe.
  */
 export const POST = defineV2JsonRoute({
   contract: v2RestoreFileContract,

apps/sim/blocks/blocks/table_v2.ts

@@ -370,6 +370,7 @@ export const TableV2Block: BlockConfig<TableQueryV2Response> = {
       id: 'data',
       title: 'Row Data (JSON)',
       type: 'code',
+      language: 'json',
       placeholder: '{"column_name": "value"}',
       condition: {
         field: 'operation',
@@ -426,6 +427,7 @@ Return ONLY the data JSON:`,
       id: 'rows',
       title: 'Rows Data (Array of JSON)',
       type: 'code',
+      language: 'json',
       placeholder: '[{"col1": "val1"}, {"col1": "val2"}]',
       condition: { field: 'operation', value: 'batch_insert_rows' },
       required: true,
@@ -467,6 +469,7 @@ Return ONLY the rows array:`,
       id: 'filter',
       title: 'Filter',
       type: 'code',
+      language: 'json',
       canonicalParamId: 'filterInput',
       mode: 'advanced',
       placeholder: '{"field":"wins","op":"gte","value":10}',

apps/sim/lib/api/contracts/v2/openapi/files-audit.ts

@@ -560,7 +560,7 @@ const declaredRoutes = [
       operationId: 'restoreFile',
       summary: 'Restore File',
       description:
-        'Reverse a soft delete and return the file to the workspace. Not a pure undo: the file comes back at the workspace root, and gains a `_restored` suffix when another file there already holds its name, so read `folderPath` and `name` off the response. Restoring an already-active file returns it unchanged, so a retry is safe. An archived workspace is a `400`, and a name the restore could not free is a `409`.',
+        'Reverse a soft delete and return the file to the workspace. Not a pure undo: the file comes back in the folder it was deleted from, or at the workspace root when that folder has since been archived, and gains a `_restored` suffix when another file there already holds its name, so read `folderPath` and `name` off the response. Restoring an already-active file returns it unchanged, so a retry is safe. An archived workspace is a `400`, and a name the restore could not free is a `409`.',
       errors: [...RESOURCE_CONFLICT_ERRORS, 'PayloadTooLarge'],
       success: { description: 'The file as it exists after the restore.' },
     }),

apps/sim/lib/catalog/projection/block-detail.ts

@@ -142,9 +142,20 @@ export function hiddenParamKeys(block: BlockConfig): Set<string> {
   return hidden
 }
 
-/** Sub-blocks an authoring surface may configure: action fields, minus the hidden ones. */
+/**
+ * Sub-blocks an authoring surface may configure, minus the hidden ones.
+ *
+ * Action fields for an ordinary block. A `triggers`-category block has no
+ * action side — every field it declares is trigger-mode, and the serializer
+ * keeps those — so its trigger fields are the authorable ones, minus the
+ * system-managed display and lifecycle fields.
+ */
 function authorableSubBlocks(block: BlockConfig): SubBlockConfig[] {
-  return actionSubBlocks(block).filter((subBlock) => !subBlock.hideFromCopilot)
+  const fields =
+    block.category === 'triggers'
+      ? (block.subBlocks ?? []).filter((subBlock) => !SYSTEM_SUBBLOCK_IDS.includes(subBlock.id))
+      : actionSubBlocks(block)
+  return fields.filter((subBlock) => !subBlock.hideFromCopilot)
 }
 
 /** Whether a condition gates its field on a specific operation being selected. */
@@ -227,7 +238,13 @@ export function computeBlockLevelInputs(
   return blockInputs
 }
 
-/** Input definitions scoped to one operation, keyed by operation id. */
+/**
+ * Input definitions scoped to one operation, keyed by operation id.
+ *
+ * Each input is published under the sub-block id — the field name an apply
+ * accepts — even when the block declares its definition under the field's
+ * `canonicalParamId`, which is the executor-side param and not a writable field.
+ */
 export function computeOperationLevelInputs(
   block: BlockConfig
 ): Record<string, Record<string, CatalogInputDefinition>> {
@@ -237,15 +254,13 @@ export function computeOperationLevelInputs(
   for (const subBlock of authorableSubBlocks(block)) {
     const gate = operationGate(subBlock)
     if (!gate) continue
-    const keys = [subBlock.canonicalParamId, subBlock.id].filter(
-      (key): key is string => typeof key === 'string'
-    )
-    for (const key of keys) {
-      if (!(key in inputs)) continue
-      for (const operationId of gate.values) {
-        operationInputs[operationId] ??= {}
-        operationInputs[operationId][key] = inputs[key]
-      }
+    const definition =
+      inputs[subBlock.id] ??
+      (subBlock.canonicalParamId !== undefined ? inputs[subBlock.canonicalParamId] : undefined)
+    if (!definition) continue
+    for (const operationId of gate.values) {
+      operationInputs[operationId] ??= {}
+      operationInputs[operationId][subBlock.id] = definition
     }
   }
 

apps/sim/lib/catalog/projection/catalog-sweep.test.ts

@@ -126,11 +126,40 @@ describe('block catalog projection sweep', () => {
   })
 })
 
+/**
+ * Pinned shapes of two real registry blocks, where a projection rule is only
+ * visible against an authored block rather than a synthetic fixture.
+ */
+describe('block detail regressions', () => {
+  const registry = getBlockRegistry()
+  const registered = (type: string) => {
+    const block = registry[type]
+    if (!block) throw new Error(`block ${type} is not registered`)
+    return block
+  }
+
+  it('keys operation inputs by the sub-block id an apply accepts, not the canonical param id', () => {
+    const detail = projectBlockDetail(registered('table_v2'), { deployment: HOSTED })
+    const inputKeys = Object.keys(detail.operations.query_rows?.inputs ?? {})
+    expect(inputKeys).toContain('filter')
+    expect(inputKeys).not.toContain('filterInput')
+    expect(inputKeys).not.toContain('sortInput')
+  })
+
+  it('publishes a triggers-category block’s trigger-mode fields as its input schema', () => {
+    const detail = projectBlockDetail(registered('schedule'), { deployment: HOSTED })
+    const ids = detail.inputSchema.map((field) => field.id)
+    expect(ids).toEqual(expect.arrayContaining(['scheduleType', 'cronExpression', 'timezone']))
+    expect(ids).not.toContain('scheduleInfo')
+  })
+})
+
 /**
  * Custom (deploy-as-block) blocks, which the registry sweep above cannot reach.
  *
- * `projectCustomBlockDetail` is a separate branch with its own field set — and
- * the only one whose `inputSchema` includes `mode: 'trigger'` sub-blocks — yet
+ * `projectCustomBlockDetail` is a separate branch with its own field set — it
+ * publishes `mode: 'trigger'` sub-blocks in `inputSchema`, as the main branch
+ * does only for `triggers`-category blocks — yet
  * it is caller-reachable through `GET /api/v2/blocks/custom_block_*`. Built from
  * the same `buildCustomBlockConfig` the overlay uses, so a change to the synthesized
  * shape shows up here rather than as a 500 on a well-formed request.

apps/sim/lib/mothership/agent-cli/engines.test.ts

@@ -51,15 +51,15 @@ function runtimeWith(responses: Record<string, unknown>): AgentCliRuntime {
   }
 }
 
-const EXPORT_PATH = '/api/v2/workflows/wf-1/export'
-const exportResponse = { data: { state: WORKFLOW_STATE } }
+const STATE_PATH = '/api/v2/workflows/wf-1/state'
+const stateResponse = { data: WORKFLOW_STATE }
 
 describe('workflows lint', () => {
   it('lints a workflow through the shared engine with the caller scoped as subject', async () => {
     const result = await runEngine(
       'workflows lint',
       ['wf-1'],
-      runtimeWith({ [EXPORT_PATH]: exportResponse }),
+      runtimeWith({ [STATE_PATH]: stateResponse }),
       {}
     )
     expect(result.stderr).toBe('')

apps/sim/lib/mothership/agent-cli/engines/universal-grep.test.ts

@@ -96,4 +96,27 @@ describe('universal grep', () => {
     expect(result.exitCode).toBe(0)
     expect(result.stdout).toContain('No matches for "zzz-nope" in blocks')
   })
+
+  it('names files by their VFS path, with no doubled slash at the root', async () => {
+    const result = await runEngine(
+      'grep',
+      ['runbook'],
+      runtimeWith({
+        '/api/v2/files': {
+          data: [
+            { id: 'file-root', name: 'xp-runbook.md', folderPath: '/' },
+            { id: 'file-ops', name: 'notes.md', folderPath: '/Ops' },
+          ],
+          nextCursor: null,
+        },
+        '/api/v2/files/file-root/text': { data: { text: 'root runbook', degraded: false } },
+        '/api/v2/files/file-ops/text': { data: { text: 'ops runbook', degraded: false } },
+      }),
+      { scope: 'files' }
+    )
+    expect(result.exitCode).toBe(0)
+    expect(result.stdout).toContain('files/xp-runbook.md (file-root):')
+    expect(result.stdout).toContain('files/Ops/notes.md (file-ops):')
+    expect(result.stdout).not.toContain('files//')
+  })
 })

apps/sim/lib/mothership/agent-cli/engines/universal-grep.ts

@@ -103,12 +103,12 @@ const MATERIALIZERS: Record<Scope, (runtime: AgentCliRuntime) => Promise<Materia
     const list = await listAll(runtime, '/api/v2/workflows')
     return mapConcurrent(list, FETCH_CONCURRENCY, async (w) => {
       const id = str(w.id) ?? ''
-      // The export route scopes by workflow id alone (`query: noInputSchema`); a
-      // workspaceId here is an "Unrecognized key" — the other detail routes require it.
-      const exported = await runtime.client.request<{ data: { state: unknown } }>(
-        `/api/v2/workflows/${id}/export`
-      )
-      return render('workflows', id, str(w.name) ?? id, exported.data.state)
+      // The draft state, not the export: export is sanitized for sharing and nulls
+      // workspace-specific fields (a Table block's `tableId`), so a grep for a table id
+      // inside a workflow would miss it. The state route scopes by workflow id alone
+      // (`query: noInputSchema`); a workspaceId here is an "Unrecognized key".
+      const state = await runtime.client.request<{ data: unknown }>(`/api/v2/workflows/${id}/state`)
+      return render('workflows', id, str(w.name) ?? id, state.data)
     })
   },
   blocks: async (runtime) => {
@@ -178,9 +178,11 @@ const MATERIALIZERS: Record<Scope, (runtime: AgentCliRuntime) => Promise<Materia
     })
     return texts.flatMap(({ file, text }) => {
       if (text === null) return []
-      const folder = (str(file.folderPath) ?? '').replace(/\/+$/, '')
+      // `folderPath` is `/` at the root and `/Ops` below it; the match header already
+      // supplies the `files/` prefix, so the label carries no slash of its own.
+      const folder = (str(file.folderPath) ?? '').replace(/^\/+|\/+$/g, '')
       const name = str(file.name) ?? str(file.id) ?? ''
-      const label = folder ? `${folder}/${name}` : `/${name}`
+      const label = folder ? `${folder}/${name}` : name
       return [{ scope: 'files' as const, id: str(file.id) ?? '', label, text }]
     })
   },

apps/sim/lib/mothership/agent-cli/engines/workflow-state.ts

@@ -1,13 +1,23 @@
-import type { ExportWorkflowResponse } from 'sim/embed'
 import type { AgentCliRuntime } from '@/lib/mothership/agent-cli/types'
 
-/** One workflow's exported state — the v2 source of truth the analysis engines read. */
+interface WorkflowStateResponse {
+  data: Record<string, unknown>
+}
+
+/**
+ * One workflow's draft state — the v2 source of truth the analysis engines read.
+ *
+ * The `/state` route, not `/export`: export is sanitized for sharing, which nulls
+ * workspace-specific fields such as a Table block's `tableId` while leaving its
+ * advanced-mode marker, so a lint over the export reported a working block as missing
+ * "Table ID" although the same graph linted clean inside `operations apply`.
+ */
 export async function fetchWorkflowState(
   runtime: AgentCliRuntime,
   workflowId: string
 ): Promise<Record<string, unknown>> {
-  const response = await runtime.client.request<ExportWorkflowResponse>(
-    `/api/v2/workflows/${encodeURIComponent(workflowId)}/export`
+  const response = await runtime.client.request<WorkflowStateResponse>(
+    `/api/v2/workflows/${encodeURIComponent(workflowId)}/state`
   )
-  return response.data.state
+  return response.data
 }