refactor(input-format): extract file adapters, share run-input builder, harden types

Follow-up cleanup from /simplify + /cleanup review:
- Extract pure file adapters into input-format-files.ts (filesToControlValue,
  controlValueToFiles, serializeInputFormatFiles, defaultFileFieldMode) so they
  are unit-tested without a DOM; add tests.
- Derive InputFormatFile from the canonical executor UserFile so the editor and
  runtime file shapes can't drift.
- Consolidate the two manual run-input builders into one buildInputFormatInput
  helper so manual run and run-from-block handle files identically.
- Narrow file-field detection to the canonical file[] (matches the field-type
  dropdown and the existing execution/webhook file paths) so no pre-existing
  non-file[] field changes behavior.
- defaultFileFieldMode parses once; the file value is only parsed in upload mode.
- Add lib/component unit tests (45 passing).

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/starter/input-format-files.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, it } from 'vitest'
+import type { InputFormatFile } from '@/lib/workflows/input-format'
+import {
+  controlValueToFiles,
+  defaultFileFieldMode,
+  filesToControlValue,
+  serializeInputFormatFiles,
+} from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/starter/input-format-files'
+
+const file: InputFormatFile = {
+  id: 'f1',
+  name: 'doc.pdf',
+  url: '/api/files/serve/key',
+  key: 'key',
+  size: 10,
+  type: 'application/pdf',
+}
+
+describe('filesToControlValue', () => {
+  it.concurrent('maps url -> path for the FileUpload value shape', () => {
+    expect(filesToControlValue([file])).toEqual([
+      {
+        name: 'doc.pdf',
+        path: '/api/files/serve/key',
+        key: 'key',
+        size: 10,
+        type: 'application/pdf',
+      },
+    ])
+  })
+
+  it.concurrent('round-trips through controlValueToFiles without data loss', () => {
+    expect(controlValueToFiles(filesToControlValue([file]), [file])).toEqual([file])
+  })
+})
+
+describe('controlValueToFiles', () => {
+  it.concurrent('preserves the stable id of an existing file (matched by key)', () => {
+    const control = [
+      { name: 'doc.pdf', path: '/moved', key: 'key', size: 10, type: 'application/pdf' },
+    ]
+    expect(controlValueToFiles(control, [file])[0].id).toBe('f1')
+  })
+
+  it.concurrent('matches an existing file by url when key is absent', () => {
+    const control = [
+      { name: 'doc.pdf', path: '/api/files/serve/key', size: 10, type: 'application/pdf' },
+    ]
+    expect(controlValueToFiles(control, [file])[0].id).toBe('f1')
+  })
+
+  it.concurrent('generates an id for a newly added file', () => {
+    const control = [
+      {
+        name: 'new.pdf',
+        path: '/api/files/serve/new',
+        key: 'new',
+        size: 5,
+        type: 'application/pdf',
+      },
+    ]
+    const result = controlValueToFiles(control, [file])
+    expect(result[0].id).toEqual(expect.any(String))
+    expect(result[0].id).not.toBe('f1')
+    expect(result[0].url).toBe('/api/files/serve/new')
+  })
+
+  it.concurrent('normalizes a single object or null to an array', () => {
+    const single = {
+      name: 'doc.pdf',
+      path: '/api/files/serve/key',
+      key: 'key',
+      size: 10,
+      type: 'application/pdf',
+    }
+    expect(controlValueToFiles(single, [file])).toEqual([file])
+    expect(controlValueToFiles(null, [file])).toEqual([])
+  })
+})
+
+describe('serializeInputFormatFiles', () => {
+  it.concurrent('serializes to JSON that parses back to the same files', () => {
+    expect(JSON.parse(serializeInputFormatFiles([file]))).toEqual([file])
+  })
+
+  it.concurrent('returns an empty string for no files', () => {
+    expect(serializeInputFormatFiles([])).toBe('')
+  })
+})
+
+describe('defaultFileFieldMode', () => {
+  it.concurrent('defaults to upload for empty or whitespace values', () => {
+    expect(defaultFileFieldMode(undefined)).toBe('upload')
+    expect(defaultFileFieldMode('')).toBe('upload')
+    expect(defaultFileFieldMode('   ')).toBe('upload')
+  })
+
+  it.concurrent('uses upload for an empty array or run-ready files', () => {
+    expect(defaultFileFieldMode('[]')).toBe('upload')
+    expect(defaultFileFieldMode(JSON.stringify([file]))).toBe('upload')
+  })
+
+  it.concurrent('falls back to json for legacy free-form values (no data loss)', () => {
+    expect(defaultFileFieldMode('C:/Users/x/budget.xlsx')).toBe('json')
+    expect(defaultFileFieldMode('[{"data":"<base64>","name":"x.pdf"}]')).toBe('json')
+    expect(defaultFileFieldMode('{"csv":"a,b,c"}')).toBe('json')
+  })
+})

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/starter/input-format-files.ts

@@ -0,0 +1,71 @@
+import { generateId } from '@sim/utils/id'
+import { type InputFormatFile, parseInputFormatFiles } from '@/lib/workflows/input-format'
+import type { UploadedFile } from '@/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/file-upload/file-upload'
+
+/**
+ * Pure adapters bridging a file-typed input-format field's stored value (a JSON
+ * string of run-ready {@link InputFormatFile} objects) and the {@link FileUpload}
+ * component's value shape (which keys off `path`). Kept separate from the React
+ * component so they can be unit-tested without a DOM.
+ */
+
+/**
+ * Maps stored run-ready file objects to the {@link FileUpload} value shape.
+ */
+export function filesToControlValue(files: InputFormatFile[]): UploadedFile[] {
+  return files.map((file) => ({
+    name: file.name,
+    path: file.url,
+    key: file.key,
+    size: file.size,
+    type: file.type,
+  }))
+}
+
+/**
+ * Maps a {@link FileUpload} value back to stored run-ready file objects,
+ * preserving the stable `id` of files that were already present.
+ */
+export function controlValueToFiles(
+  value: UploadedFile | UploadedFile[] | null,
+  previous: InputFormatFile[]
+): InputFormatFile[] {
+  const uploaded = Array.isArray(value) ? value : value ? [value] : []
+  return uploaded.map((file) => {
+    const existing = previous.find(
+      (prev) => (file.key && prev.key === file.key) || prev.url === file.path
+    )
+    return {
+      id: existing?.id ?? generateId(),
+      name: file.name,
+      url: file.path,
+      key: file.key,
+      size: file.size,
+      type: file.type,
+    }
+  })
+}
+
+/**
+ * Serializes run-ready file objects into a field value string (empty when none).
+ */
+export function serializeInputFormatFiles(files: InputFormatFile[]): string {
+  return files.length > 0 ? JSON.stringify(files, null, 2) : ''
+}
+
+/**
+ * Default editor mode for a file field: the uploader, unless the stored value is
+ * legacy free-form content (raw text or a non-file array) that only the JSON
+ * editor can represent without data loss.
+ */
+export function defaultFileFieldMode(value: string | undefined): 'upload' | 'json' {
+  if (!value || !value.trim()) return 'upload'
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(value)
+  } catch {
+    return 'json'
+  }
+  if (!Array.isArray(parsed)) return 'json'
+  return parsed.length === 0 || parseInputFormatFiles(parsed).length > 0 ? 'upload' : 'json'
+}