fix(parsers): accept YAML document streams and JSON with comments

Kubernetes manifests, Helm output and CI fixtures hold several YAML
documents separated by ---; js-yaml's single-document load rejected them
outright. A stream now becomes one item per document. JSON files with
comments or trailing commas (tsconfig, editor settings) parse leniently
after strict parsing fails, with a warning in metadata.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

Author: waleedlatif1

apps/sim/lib/file-parsers/json-parser.test.ts

@@ -61,6 +61,26 @@ describe('JSON parser complexity limits', () => {
     expect(result.metadata?.warning).toMatch(/Windows-1252/)
   })
 
+  it('parses JSON with comments and trailing commas leniently with a warning', async () => {
+    const jsonc =
+      '{\n  // strict later\n  "compilerOptions": { "strict": true, /* todo */ "target": "esnext", },\n  "url": "http://example.com/a//b",\n}\n'
+    const result = await parseJSONBuffer(Buffer.from(jsonc))
+    const parsed = JSON.parse(result.content) as {
+      compilerOptions: { target: string }
+      url: string
+    }
+
+    expect(parsed.compilerOptions.target).toBe('esnext')
+    expect(parsed.url).toBe('http://example.com/a//b')
+    expect(result.metadata?.warning).toContain('comments')
+  })
+
+  it('still rejects JSON that is invalid even after comment stripping', async () => {
+    await expect(parseJSONBuffer(Buffer.from('{ "a": [1, 2 }'))).rejects.toMatchObject({
+      code: 'invalid_format',
+    })
+  })
+
   it('parses BOM-prefixed JSON Lines', async () => {
     const result = await parseJSONLBuffer(
       Buffer.concat([Buffer.from([0xef, 0xbb, 0xbf]), Buffer.from('{"a":1}\n{"a":2}')])

apps/sim/lib/file-parsers/json-parser.ts

@@ -174,6 +174,45 @@ function buildJsonResult(jsonData: unknown, decoded: DecodedText): FileParseResu
  * `toString('utf-8')` read used to reject every BOM-prefixed file from Windows
  * editors, and a Windows-1252 file silently lost its accented characters.
  */
+const JSONC_WARNING = 'File is JSON with comments or trailing commas; parsed leniently'
+
+/**
+ * Removes `//` and `/* *\/` comments and trailing commas outside string
+ * literals, so a `tsconfig.json`, `.vscode` settings file or `devcontainer.json`
+ * — JSON with comments, which editors accept — parses like plain JSON. Runs
+ * only after strict parsing has failed, so valid JSON never goes through it.
+ */
+export function stripJsonComments(text: string): string {
+  let out = ''
+  let index = 0
+  while (index < text.length) {
+    const char = text[index]
+    if (char === '"') {
+      let end = index + 1
+      while (end < text.length && text[end] !== '"') {
+        if (text[end] === '\\') end++
+        end++
+      }
+      out += text.slice(index, end + 1)
+      index = end + 1
+      continue
+    }
+    if (char === '/' && text[index + 1] === '/') {
+      const end = text.indexOf('\n', index)
+      index = end === -1 ? text.length : end
+      continue
+    }
+    if (char === '/' && text[index + 1] === '*') {
+      const end = text.indexOf('*/', index + 2)
+      index = end === -1 ? text.length : end + 2
+      continue
+    }
+    out += char
+    index++
+  }
+  return out.replace(/,(\s*[}\]])/g, '$1')
+}
+
 function parseJsonContent(buffer: Uint8Array): FileParseResult {
   const decoded = decodeTextBuffer(buffer)
   try {
@@ -183,6 +222,8 @@ function parseJsonContent(buffer: Uint8Array): FileParseResult {
     if (!(error instanceof SyntaxError)) {
       throw new FileParserError('runtime_failure', 'JSON processing failed unexpectedly', error)
     }
+    const lenient = parseJsonWithComments(decoded)
+    if (lenient) return lenient
     throw new FileParserError(
       'invalid_format',
       `Invalid JSON: ${getErrorMessage(error, 'Unknown error')}`,
@@ -191,6 +232,18 @@ function parseJsonContent(buffer: Uint8Array): FileParseResult {
   }
 }
 
+function parseJsonWithComments(decoded: DecodedText): FileParseResult | undefined {
+  let value: unknown
+  try {
+    value = JSON.parse(stripJsonComments(decoded.text))
+  } catch {
+    return undefined
+  }
+  const result = buildJsonResult(value, decoded)
+  const warning = [decoded.warning, JSONC_WARNING].filter(Boolean).join('; ')
+  return { ...result, metadata: { ...result.metadata, warning } }
+}
+
 /** Parse a JSON file. */
 export async function parseJSON(filePath: string): Promise<FileParseResult> {
   const fs = await import('fs/promises')

apps/sim/lib/file-parsers/yaml-parser.test.ts

@@ -70,6 +70,28 @@ describe('parseYAMLBuffer', () => {
     await expect(parseYAMLBuffer(Buffer.from(bomb))).rejects.toBeInstanceOf(YamlComplexityError)
   })
 
+  it('parses a multi-document stream as one document per item', async () => {
+    const stream =
+      'apiVersion: v1\nkind: Service\nmetadata:\n  name: web\n---\napiVersion: apps/v1\nkind: Deployment\nmetadata:\n  name: web\n'
+    const result = await parseYAMLBuffer(Buffer.from(stream))
+    const parsed = JSON.parse(result.content) as Array<{ kind: string }>
+
+    expect(parsed.map((document) => document.kind)).toEqual(['Service', 'Deployment'])
+    expect(result.metadata).toMatchObject({
+      type: 'yaml',
+      isArray: true,
+      itemCount: 2,
+      documentCount: 2,
+    })
+  })
+
+  it('keeps a single document unwrapped and skips empty documents in a stream', async () => {
+    const result = await parseYAMLBuffer(Buffer.from('---\nname: solo\n---\n'))
+
+    expect(JSON.parse(result.content)).toEqual({ name: 'solo' })
+    expect(result.metadata).toMatchObject({ isArray: false, documentCount: 1 })
+  })
+
   it('surfaces malformed YAML as an Invalid YAML error', async () => {
     await expect(parseYAMLBuffer(Buffer.from('key: "unterminated\n'))).rejects.toThrow(
       /Invalid YAML/

apps/sim/lib/file-parsers/yaml-parser.ts

@@ -53,7 +53,11 @@ export function assertYamlWithinLimits(root: unknown): number {
  * Parse a YAML value into the shared `FileParseResult` shape after validating
  * that its expanded form stays within safe complexity limits.
  */
-function buildYamlResult(yamlData: unknown, decoded: DecodedText): FileParseResult {
+function buildYamlResult(
+  yamlData: unknown,
+  decoded: DecodedText,
+  documentCount: number
+): FileParseResult {
   if (yamlData === undefined) {
     throw new FileParserError('empty_input', 'Empty YAML input provided')
   }
@@ -67,6 +71,7 @@ function buildYamlResult(yamlData: unknown, decoded: DecodedText): FileParseResu
     keys: Array.isArray(yamlData) ? [] : Object.keys((yamlData as Record<string, unknown>) || {}),
     itemCount: Array.isArray(yamlData) ? yamlData.length : undefined,
     depth,
+    documentCount,
     encoding: decoded.encoding,
     ...(decoded.warning ? { warning: decoded.warning } : {}),
   }
@@ -96,8 +101,18 @@ export async function parseYAMLBuffer(buffer: Buffer): Promise<FileParseResult>
   const decoded = decodeTextBuffer(buffer)
 
   try {
-    const yamlData = yaml.load(decoded.text)
-    return buildYamlResult(yamlData, decoded)
+    /**
+     * A YAML file is a stream: Kubernetes manifests, Helm output and CI
+     * fixtures routinely hold several documents separated by `---`. A single
+     * document keeps its own shape; a multi-document stream becomes an array of
+     * documents, which the JSON/YAML chunker then splits one document per item.
+     */
+    const documents = yaml
+      .loadAll(decoded.text)
+      .filter((document) => document !== undefined && document !== null)
+    const yamlData =
+      documents.length === 1 ? documents[0] : documents.length === 0 ? undefined : documents
+    return buildYamlResult(yamlData, decoded, documents.length)
   } catch (error) {
     if (error instanceof FileParserError) throw error
     throw new FileParserError(