@astrale-os/sdk 0.4.18 → 0.4.19

package/src/linter/oxlint/run.ts

@@ -1,4 +1,3 @@
-import { spawn } from 'node:child_process'
 import { existsSync } from 'node:fs'
 import { createRequire } from 'node:module'
 import { dirname, join, relative, resolve, sep } from 'node:path'
@@ -6,6 +5,8 @@ import { fileURLToPath } from 'node:url'
 
 import { LinterToolError, type DiagnosticSeverity, type LintDiagnostic } from '../diagnostic.js'
 import { ruleInfo } from '../rules/catalog.js'
+import { DOMAIN_OXLINT_IGNORE_PATTERNS } from './ignore-patterns.js'
+import { runOxlintProcess, type OxlintProcessOptions } from './process.js'
 
 type OxlintOutput = {
   diagnostics?: OxlintDiagnostic[]
@@ -29,49 +30,46 @@ export type OxlintResult = {
   files: number
 }
 
-export async function runOxlint(root: string, fix: boolean): Promise<OxlintResult> {
+export async function runOxlint(
+  root: string,
+  fix: boolean,
+  options: OxlintProcessOptions = {},
+): Promise<OxlintResult> {
   const packageJson = join(root, 'package.json')
   const projectRequire = createRequire(packageJson)
   const sdkRequire = createRequire(import.meta.url)
   const oxlintPackage = resolvePackage('oxlint/package.json', projectRequire, sdkRequire)
   const bin = join(dirname(oxlintPackage), 'bin', 'oxlint')
   const config = projectConfig(root) ?? internalConfigPath()
-  const args = [bin, '.', '--format=json', '--no-error-on-unmatched-pattern', '--config', config]
+  const args = ['.', '--format=json', '--no-error-on-unmatched-pattern', '--config', config]
+  // Config-file ignores are rooted at the config's own directory. Enforce the
+  // SDK's traversal boundary at the target process as well so the internal
+  // fallback config and imported presets cannot discover dependency/build trees.
+  for (const pattern of DOMAIN_OXLINT_IGNORE_PATTERNS) args.push('--ignore-pattern', pattern)
   if (fix) args.push('--fix')
 
-  const child = spawn(process.execPath, args, {
-    cwd: root,
-    env: process.env,
-    stdio: ['ignore', 'pipe', 'pipe'],
-  })
-  let stdout = ''
-  let stderr = ''
-  child.stdout.setEncoding('utf8')
-  child.stderr.setEncoding('utf8')
-  child.stdout.on('data', (chunk: string) => (stdout += chunk))
-  child.stderr.on('data', (chunk: string) => (stderr += chunk))
-  const status = await new Promise<number | null>((resolveStatus, reject) => {
-    child.once('error', reject)
-    child.once('close', resolveStatus)
-  }).catch((error: unknown) => {
-    throw new LinterToolError(`Could not start Oxlint at ${bin}.`, { cause: error })
-  })
+  const { status, signal, stdout, stderr } = await runOxlintProcess(bin, args, root, options)
+
+  if (status !== 0 && status !== 1) {
+    const outcome = signal ? `signal ${signal}` : `status ${status ?? 'unknown'}`
+    const detail = failureDetail(stderr, stdout)
+    throw new LinterToolError(`Oxlint failed with ${outcome}.${detail ? `\n${detail}` : ''}`, {
+      code: 'OXLINT_FAILED',
+    })
+  }
 
   let output: OxlintOutput
   try {
-    output = JSON.parse(stdout) as OxlintOutput
+    const parsed: unknown = JSON.parse(stdout)
+    if (!isOxlintOutput(parsed)) throw new TypeError('Unexpected Oxlint report shape.')
+    output = parsed
   } catch (error) {
-    const detail =
-      stderr.trim() || stdout.trim() || `Oxlint exited with status ${status ?? 'unknown'}`
+    const detail = failureDetail(stderr, stdout) || `Oxlint exited with status ${status}`
     throw new LinterToolError(`Oxlint did not produce a diagnostic report.\n${detail}`, {
+      code: 'OXLINT_INVALID_OUTPUT',
       cause: error,
     })
   }
-  if (status !== 0 && status !== 1) {
-    throw new LinterToolError(
-      `Oxlint failed with status ${status ?? 'unknown'}.${stderr.trim() ? `\n${stderr.trim()}` : ''}`,
-    )
-  }
 
   return {
     diagnostics: (output.diagnostics ?? []).map((diagnostic) =>
@@ -94,12 +92,27 @@ function resolvePackage(
     } catch {
       throw new LinterToolError(
         'Oxlint is not installed. Add the scaffolded Oxlint dev dependency and run your package manager install.',
-        { cause: projectError },
+        { code: 'OXLINT_NOT_INSTALLED', cause: projectError },
       )
     }
   }
 }
 
+function isOxlintOutput(value: unknown): value is OxlintOutput {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false
+  const output = value as OxlintOutput
+  return (
+    (output.diagnostics === undefined || Array.isArray(output.diagnostics)) &&
+    (output.number_of_files === undefined || typeof output.number_of_files === 'number')
+  )
+}
+
+function failureDetail(stderr: string, stdout: string): string {
+  const detail = stderr.trim() || stdout.trim()
+  const limit = 4_000
+  return detail.length <= limit ? detail : `…${detail.slice(-limit)}`
+}
+
 function projectConfig(root: string): string | undefined {
   for (const name of [
     'oxlint.config.ts',

package/src/linter/preflight.ts

@@ -45,6 +45,7 @@ export async function assertSingleTypeUniverse(root: string): Promise<void> {
     throw new LinterToolError(
       `Multiple physical installations of ${packageName} would create incompatible Astrale types.\n` +
         `${detail}\nReinstall the workspace so every member resolves one compatible package instance.`,
+      { code: 'LINTER_PREFLIGHT_FAILED' },
     )
   }
 }