VFS updates and linter

Author: Sg312

apps/sim/app/workspace/[workspaceId]/home/hooks/use-chat.ts

@@ -722,8 +722,11 @@ function resolveToolDisplayTitle(name: string, args?: Record<string, unknown>):
   }
 
   if (name === QueryLogs.id) {
-    const workflowName = resolveWorkflowNameForDisplay(args.workflowId)
-    return workflowName ? `Querying logs for ${workflowName}` : 'Querying logs'
+    const workflowName =
+      resolveWorkflowNameForDisplay(args.workflowId) ?? stringParam(args.workflowName)
+    // Fall back to the server-provided title (which is workflow-scoped when the
+    // request is attached to a workflow) instead of a generic label.
+    return workflowName ? `Querying logs for ${workflowName}` : undefined
   }
 
   return undefined

apps/sim/lib/copilot/tools/handlers/materialize-file.ts

@@ -213,6 +213,14 @@ export async function executeMaterializeFile(
   }
 
   const operation = (params.operation as string | undefined) || 'save'
+  // Only save/import are implemented. Reject anything else with guidance instead of
+  // silently falling back to save (table/knowledge_base are handled by their subagents).
+  if (operation !== 'save' && operation !== 'import') {
+    return {
+      success: false,
+      error: `Unsupported materialize_file operation "${operation}". Use "save" or "import". For CSV/TSV/JSON → use the table subagent; for documents → use the knowledge subagent.`,
+    }
+  }
   const succeeded: string[] = []
   const failed: Array<{ fileName: string; error: string }> = []
 

apps/sim/lib/copilot/tools/handlers/vfs.test.ts

@@ -382,4 +382,32 @@ describe('vfs uploads are opt-in (like recently-deleted/)', () => {
     expect(listChatUploads).not.toHaveBeenCalled()
     expect((broad.output as { files: string[] }).files).not.toContain('uploads/My%20Report.json')
   })
+
+  it('reads an upload directly, tolerating a spurious /content suffix', async () => {
+    const vfs = makeVfs()
+    getOrMaterializeVFS.mockResolvedValue(vfs)
+    readChatUpload.mockResolvedValue({ content: 'hello upload', totalLines: 1 })
+
+    const bare = await executeVfsRead({ path: 'uploads/report.csv' }, GREP_CTX_CHAT)
+    expect(bare.success).toBe(true)
+    expect(readChatUpload).toHaveBeenLastCalledWith('report.csv', 'chat-1')
+
+    // The model adds /content out of habit (from files/) — it must still resolve.
+    const withContent = await executeVfsRead({ path: 'uploads/report.csv/content' }, GREP_CTX_CHAT)
+    expect(withContent.success).toBe(true)
+    expect(readChatUpload).toHaveBeenLastCalledWith('report.csv', 'chat-1')
+  })
+
+  it('tolerates a trailing /content on an uploads grep path', async () => {
+    grepChatUpload.mockResolvedValue([])
+
+    await executeVfsGrep({ pattern: 'x', path: 'uploads/report.json/content' }, GREP_CTX_CHAT)
+
+    expect(grepChatUpload).toHaveBeenCalledWith(
+      'report.json',
+      'chat-1',
+      'x',
+      expect.any(Object)
+    )
+  })
 })

apps/sim/lib/copilot/tools/handlers/vfs.ts

@@ -104,7 +104,9 @@ export async function executeVfsGrep(
       if (!context.chatId) {
         return { success: false, error: 'No chat context available for uploads/' }
       }
-      const filename = rawPath.replace(/^\/+/, '').replace(/^uploads\/?/, '')
+      // The upload is the first segment after uploads/; any trailing segment
+      // (e.g. a /content suffix) is ignored, mirroring the uploads read path.
+      const filename = rawPath.replace(/^\/+/, '').replace(/^uploads\/?/, '').split('/')[0]
       if (!filename) {
         return {
           success: false,
@@ -230,12 +232,15 @@ export async function executeVfsRead(
       }
     }
 
-    // Handle chat-scoped uploads via the uploads/ virtual prefix
+    // Handle chat-scoped uploads via the uploads/ virtual prefix.
+    // Uploads are flat and have no metadata/content split like files/ — the upload
+    // IS the first path segment after uploads/. Any trailing segment (e.g. a
+    // /content suffix added out of habit) is ignored so the read resolves either way.
     if (path.startsWith('uploads/')) {
       if (!context.chatId) {
         return { success: false, error: 'No chat context available for uploads/' }
       }
-      const filename = path.slice('uploads/'.length)
+      const filename = path.slice('uploads/'.length).split('/')[0]
       const uploadResult = await readChatUpload(filename, context.chatId)
       if (uploadResult) {
         const isAttachment = hasModelAttachment(uploadResult)
@@ -350,31 +355,3 @@ export async function executeVfsRead(
     return { success: false, error: getErrorMessage(err, 'vfs_read failed') }
   }
 }
-
-async function executeVfsList(
-  params: Record<string, unknown>,
-  context: ExecutionContext
-): Promise<ToolCallResult> {
-  const path = params.path as string | undefined
-  if (!path) {
-    return { success: false, error: "Missing required parameter 'path'" }
-  }
-
-  const workspaceId = context.workspaceId
-  if (!workspaceId) {
-    return { success: false, error: 'No workspace context available' }
-  }
-
-  try {
-    const vfs = await getOrMaterializeVFS(workspaceId, context.userId)
-    const entries = vfs.list(path)
-    logger.debug('vfs_list result', { path, entryCount: entries.length })
-    return { success: true, output: { entries } }
-  } catch (err) {
-    logger.error('vfs_list failed', {
-      path,
-      error: toError(err).message,
-    })
-    return { success: false, error: getErrorMessage(err, 'vfs_list failed') }
-  }
-}

apps/sim/lib/copilot/tools/server/workflow/edit-workflow/dag.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it } from 'vitest'
+import { computeWorkflowDag } from './dag'
+
+function block(id: string, name: string, type = 'function') {
+  return { id, type, name }
+}
+
+describe('computeWorkflowDag', () => {
+  it('builds a linear adjacency with sinks as empty arrays', () => {
+    const dag = computeWorkflowDag({
+      blocks: { a: block('a', 'A', 'starter'), b: block('b', 'B'), c: block('c', 'C') },
+      edges: [
+        { source: 'a', target: 'b' },
+        { source: 'b', target: 'c' },
+      ],
+    } as any)
+
+    expect(dag).toEqual({ A: ['B'], B: ['C'], C: [] })
+  })
+
+  it('captures condition branches (if/else) as downstream names', () => {
+    const dag = computeWorkflowDag({
+      blocks: {
+        cond: block('cond', 'Cond', 'condition'),
+        x: block('x', 'X'),
+        y: block('y', 'Y'),
+      },
+      edges: [
+        { source: 'cond', sourceHandle: 'if', target: 'x' },
+        { source: 'cond', sourceHandle: 'else', target: 'y' },
+      ],
+    } as any)
+
+    expect(dag.Cond).toEqual(['X', 'Y'])
+    expect(dag.X).toEqual([])
+    expect(dag.Y).toEqual([])
+  })
+
+  it('captures router routes (sorted)', () => {
+    const dag = computeWorkflowDag({
+      blocks: {
+        r: block('r', 'Router', 'router_v2'),
+        s: block('s', 'Support'),
+        sa: block('sa', 'Sales'),
+      },
+      edges: [
+        { source: 'r', sourceHandle: 'route-0', target: 's' },
+        { source: 'r', sourceHandle: 'route-1', target: 'sa' },
+      ],
+    } as any)
+
+    expect(dag.Router).toEqual(['Sales', 'Support'])
+  })
+
+  it('captures subflow container edges (loop-start-source / loop-end-source)', () => {
+    const dag = computeWorkflowDag({
+      blocks: {
+        loop: block('loop', 'Loop', 'loop'),
+        child: block('child', 'Child'),
+        after: block('after', 'After'),
+      },
+      edges: [
+        { source: 'loop', sourceHandle: 'loop-start-source', target: 'child' },
+        { source: 'loop', sourceHandle: 'loop-end-source', target: 'after' },
+      ],
+    } as any)
+
+    expect(dag.Loop).toEqual(['After', 'Child'])
+    expect(dag.Child).toEqual([])
+    expect(dag.After).toEqual([])
+  })
+
+  it('excludes note blocks, dedups parallel edges, and ignores edges to missing blocks', () => {
+    const dag = computeWorkflowDag({
+      blocks: {
+        a: block('a', 'A', 'starter'),
+        x: block('x', 'X'),
+        note: block('note', 'Note', 'note'),
+      },
+      edges: [
+        { source: 'a', target: 'x' },
+        { source: 'a', sourceHandle: 'error', target: 'x' }, // duplicate target
+        { source: 'a', target: 'note' }, // note is excluded
+        { source: 'a', target: 'ghost' }, // missing block
+      ],
+    } as any)
+
+    expect(dag.A).toEqual(['X'])
+    expect(dag.X).toEqual([])
+    expect(dag.Note).toBeUndefined()
+  })
+})

apps/sim/lib/copilot/tools/server/workflow/edit-workflow/dag.ts

@@ -0,0 +1,56 @@
+import type { WorkflowState } from '@/stores/workflows/workflow/types'
+
+type DagBlockState = {
+  id?: string
+  type?: string
+  name?: string
+}
+
+type DagEdgeState = {
+  source?: string | null
+  target?: string | null
+}
+
+/**
+ * Compute the workflow's downstream adjacency: each non-note block name mapped
+ * to the sorted, de-duplicated names of the blocks it connects to.
+ *
+ * Because conditions, routers, and subflow containers all encode their fan-out
+ * as real edges (`if`/`else`, `route-N`, `loop-start-source`/`loop-end-source`,
+ * `error`), a plain edge-based adjacency captures them correctly. Every non-note
+ * block appears as a key; sink blocks map to `[]`. Edges to/from note blocks or
+ * missing blocks are ignored, as are self-edges (in the name view).
+ */
+export function computeWorkflowDag(
+  workflowState: Pick<WorkflowState, 'blocks' | 'edges'>
+): Record<string, string[]> {
+  const blocks = (workflowState.blocks || {}) as Record<string, DagBlockState>
+  const edges = Array.isArray(workflowState.edges)
+    ? (workflowState.edges as DagEdgeState[])
+    : ([] as DagEdgeState[])
+
+  const nameById = new Map<string, string>()
+  for (const [blockId, block] of Object.entries(blocks)) {
+    if (block?.type === 'note') continue
+    nameById.set(blockId, block?.name || blockId)
+  }
+
+  const downstream = new Map<string, Set<string>>()
+  for (const name of nameById.values()) {
+    if (!downstream.has(name)) downstream.set(name, new Set<string>())
+  }
+
+  for (const edge of edges) {
+    const sourceName = nameById.get(edge?.source || '')
+    const targetName = nameById.get(edge?.target || '')
+    if (!sourceName || !targetName) continue
+    if (sourceName === targetName) continue
+    downstream.get(sourceName)?.add(targetName)
+  }
+
+  const result: Record<string, string[]> = {}
+  for (const [name, targets] of downstream) {
+    result[name] = Array.from(targets).sort()
+  }
+  return result
+}

apps/sim/lib/copilot/tools/server/workflow/edit-workflow/index.ts

@@ -31,9 +31,20 @@ import { getUserPermissionConfig } from '@/ee/access-control/utils/permission-ch
 import { generateLoopBlocks, generateParallelBlocks } from '@/stores/workflows/workflow/utils'
 import { normalizeWorkflowState } from '@/stores/workflows/workflow/validation'
 import { applyOperationsToWorkflowState } from './engine'
-import { formatWorkflowLintMessage, hasWorkflowLintIssues, lintEditedWorkflowState } from './lint'
+import {
+  collectWorkflowFieldIssues,
+  formatWorkflowLintMessage,
+  hasWorkflowLintIssues,
+  lintEditedWorkflowState,
+  type WorkflowLintReport,
+  type WorkflowLintUnresolvedReference,
+} from './lint'
 import { type EditWorkflowParams, isDeferredSkippedItem, type ValidationError } from './types'
-import { preValidateCredentialInputs, validateWorkflowSelectorIds } from './validation'
+import {
+  collectUnresolvedReferences,
+  preValidateCredentialInputs,
+  UNRESOLVABLE_AT_LINT_NOTE,
+} from './validation'
 
 async function getCurrentWorkflowStateFromDb(
   workflowId: string
@@ -149,14 +160,26 @@ export const editWorkflowServerTool: BaseServerTool<EditWorkflowParams, unknown>
     // Add credential validation errors
     validationErrors.push(...credentialErrors)
 
-    // Validate selector IDs exist in the database
+    // Resolve credential/resource references against the workspace (Tier 2).
+    // Includes oauth-input credentials and only the active canonical member, so a
+    // credential "set in basic mode but unresolved in the dropdown" is caught.
+    let unresolvedReferences: WorkflowLintUnresolvedReference[] = []
     if (context?.userId) {
       try {
-        const selectorErrors = await validateWorkflowSelectorIds(modifiedWorkflowState, {
+        unresolvedReferences = await collectUnresolvedReferences(modifiedWorkflowState, {
           userId: context.userId,
           workspaceId,
         })
-        validationErrors.push(...selectorErrors)
+        // Back-compat: also surface unresolved references through the input-validation channel.
+        validationErrors.push(
+          ...unresolvedReferences.map((ref) => ({
+            blockId: ref.blockId,
+            blockType: ref.blockType ?? 'unknown',
+            field: ref.field,
+            value: ref.value,
+            error: ref.reason,
+          }))
+        )
       } catch (error) {
         logger.warn('Selector ID validation failed', {
           error: toError(error).message,
@@ -286,7 +309,16 @@ export const editWorkflowServerTool: BaseServerTool<EditWorkflowParams, unknown>
       isDeployed: false,
     }
 
-    const workflowLint = lintEditedWorkflowState(workflowStateForDb as any)
+    // Aggregate lint report: graph (sources/sinks/orphans/ports) + Tier-1 config
+    // (required + canonical-mode) + Tier-2 resolution (credential/resource IDs).
+    const graphLint = lintEditedWorkflowState(workflowStateForDb as any)
+    const fieldIssues = collectWorkflowFieldIssues(workflowStateForDb.blocks as any)
+    const workflowLint: WorkflowLintReport = {
+      ...graphLint,
+      fieldIssues,
+      unresolvedReferences,
+      notes: unresolvedReferences.length > 0 ? [UNRESOLVABLE_AT_LINT_NOTE] : [],
+    }
     const workflowLintMessage = hasWorkflowLintIssues(workflowLint)
       ? formatWorkflowLintMessage(workflowLint)
       : undefined
@@ -331,10 +363,8 @@ export const editWorkflowServerTool: BaseServerTool<EditWorkflowParams, unknown>
       workflowId,
       workflowName: workflowName ?? 'Workflow',
       workflowState: { ...finalWorkflowState, blocks: layoutedBlocks },
-      ...(workflowLintMessage && {
-        workflowLint,
-        workflowLintMessage,
-      }),
+      workflowLint,
+      ...(workflowLintMessage && { workflowLintMessage }),
       ...(inputErrors && {
         inputValidationErrors: inputErrors,
         inputValidationMessage: `${inputErrors.length} input(s) were rejected due to validation errors. The workflow was still updated with valid inputs only. Errors: ${inputErrors.join('; ')}`,

apps/sim/lib/copilot/tools/server/workflow/edit-workflow/lint.test.ts

@@ -163,11 +163,42 @@ describe('lintEditedWorkflowState', () => {
     const lint = lintEditedWorkflowState(workflowState as any)
 
     expect(lint).toEqual({
+      sources: [{ blockId: 'start', blockName: 'Start', blockType: 'starter' }],
+      sinks: [{ blockId: 'agent', blockName: 'Agent', blockType: 'agent' }],
       orphanBlocks: [],
       emptyOutgoingPorts: [],
       invalidBranchPorts: [],
       invalidConnectionTargets: [],
     })
     expect(hasWorkflowLintIssues(lint)).toBe(false)
   })
+
+  it('reports sources and sinks (triggers are sources, terminals are sinks, notes excluded)', () => {
+    const workflowState = {
+      blocks: {
+        start: baseBlock('start', 'starter', 'Start'),
+        agent: baseBlock('agent', 'agent', 'Agent'),
+        end: baseBlock('end', 'function', 'End'),
+        note: baseBlock('note', 'note', 'Note'),
+      },
+      edges: [
+        { id: 'e1', source: 'start', sourceHandle: 'source', target: 'agent', targetHandle: 'target' },
+        { id: 'e2', source: 'agent', sourceHandle: 'source', target: 'end', targetHandle: 'target' },
+      ],
+    }
+
+    const lint = lintEditedWorkflowState(workflowState as any)
+
+    // 'start' has no incoming edge -> a source, even though it is NOT an orphan (trigger).
+    expect(lint.sources).toEqual([{ blockId: 'start', blockName: 'Start', blockType: 'starter' }])
+    expect(lint.orphanBlocks).toEqual([])
+    // 'end' has no outgoing edge -> a sink.
+    expect(lint.sinks).toEqual([{ blockId: 'end', blockName: 'End', blockType: 'function' }])
+    // 'agent' has both in and out edges -> neither source nor sink.
+    expect(lint.sources.map((b) => b.blockId)).not.toContain('agent')
+    expect(lint.sinks.map((b) => b.blockId)).not.toContain('agent')
+    // 'note' is excluded from both even though it has no edges.
+    expect(lint.sources.map((b) => b.blockId)).not.toContain('note')
+    expect(lint.sinks.map((b) => b.blockId)).not.toContain('note')
+  })
 })