@o/run 0.16.19

package/src/helpers/resolveScript.test.ts

@@ -0,0 +1,340 @@
+import { describe, expect, it } from 'vitest'
+
+import { flattenScripts, splitCompound } from './resolveScript'
+
+// scripts modeled after the real chat package.json
+const scripts: Record<string, string> = {
+  dev: 'bun tko run-all --flags=last backend:delayed agent-gateway frontend',
+  'backend:delayed': 'sleep 5 && bun backend',
+  backend: 'bun tko run backend:up backend:migrate-then-zero jobs',
+  'backend:up': 'bun env:dev docker compose up pgdb minio',
+  'backend:migrate-then-zero':
+    'bun backend:migrate && bun env:dev docker compose up zero',
+  'backend:migrate': 'ALLOW_MISSING_ENV=1 bun run:dev scripts/dev/migrate.ts',
+  frontend: 'tko run-all --flags=last dev:kill-orphans watch-lazy dev:tunnel one:dev',
+  'dev:kill-orphans': 'tko dev kill-orphans',
+  'watch-lazy': 'sleep 8 && bun watch',
+  watch: 'tko run types:watch build:watch apps:watch',
+  'types:watch': 'bun check types --watch',
+  'build:watch': 'tko run --no-root watch',
+  'apps:watch': 'tko apps build -- --watch',
+  'dev:tunnel': 'tko dev tunnel --setup',
+  'one:dev': 'bun clear-ports --only web && bun run:dev one dev --port 8081',
+  'agent-gateway': 'tko dev agent-gateway',
+  jobs: 'ALLOW_MISSING_ENV=1 bun run:dev scripts/dev/jobs.ts',
+  lite: 'bun run:dev tko run-all --pty --flags=last watch-lazy lite:backend one:dev agent-gateway',
+  'lite:backend': 'bun run:dev orez --data-dir=.orez',
+}
+
+describe('flattenScripts', () => {
+  it('passes through leaf commands that are not tko run', () => {
+    const result = flattenScripts(['jobs'], scripts)
+    expect(result).toEqual([
+      {
+        name: 'jobs',
+        command: 'ALLOW_MISSING_ENV=1 bun run:dev scripts/dev/jobs.ts',
+        isRaw: false,
+      },
+    ])
+  })
+
+  it('parses compound and inlines bun script references', () => {
+    // backend:delayed = "sleep 5 && bun backend"
+    // backend = "bun tko run backend:up backend:migrate-then-zero jobs" (tko run)
+    // since "bun backend" is last segment and resolves to tko run, it becomes deferredScripts
+    const result = flattenScripts(['backend:delayed'], scripts)
+    expect(result).toEqual([
+      {
+        name: 'backend:delayed',
+        command: 'sleep 5',
+        isRaw: false,
+        deferredScripts: [
+          {
+            name: 'backend:up',
+            command: 'bun env:dev docker compose up pgdb minio',
+            isRaw: false,
+          },
+          {
+            name: 'backend:migrate-then-zero',
+            command:
+              'ALLOW_MISSING_ENV=1 bun run:dev scripts/dev/migrate.ts && bun env:dev docker compose up zero',
+            isRaw: false,
+          },
+          {
+            name: 'jobs',
+            command: 'ALLOW_MISSING_ENV=1 bun run:dev scripts/dev/jobs.ts',
+            isRaw: false,
+          },
+        ],
+      },
+    ])
+  })
+
+  it('resolves bun tko run into child scripts, inlines compounds', () => {
+    const result = flattenScripts(['backend'], scripts)
+    expect(result).toEqual([
+      {
+        name: 'backend:up',
+        command: 'bun env:dev docker compose up pgdb minio',
+        isRaw: false,
+      },
+      {
+        name: 'backend:migrate-then-zero',
+        // "bun backend:migrate" inlined to its command, "bun env:dev docker compose up zero" not a known script
+        command:
+          'ALLOW_MISSING_ENV=1 bun run:dev scripts/dev/migrate.ts && bun env:dev docker compose up zero',
+        isRaw: false,
+      },
+      {
+        name: 'jobs',
+        command: 'ALLOW_MISSING_ENV=1 bun run:dev scripts/dev/jobs.ts',
+        isRaw: false,
+      },
+    ])
+  })
+
+  it('resolves tko run-all and parses compounds within children', () => {
+    const result = flattenScripts(['frontend'], scripts)
+    expect(result).toEqual([
+      { name: 'dev:kill-orphans', command: 'tko dev kill-orphans', isRaw: false },
+      {
+        name: 'watch-lazy',
+        command: 'sleep 8',
+        isRaw: false,
+        deferredScripts: [
+          { name: 'types:watch', command: 'bun check types --watch', isRaw: false },
+          // build:watch → tko run --no-root watch → treated as leaf (no root expansion)
+          { name: 'build:watch', command: 'tko run --no-root watch', isRaw: false },
+          { name: 'apps:watch', command: 'tko apps build -- --watch', isRaw: false },
+        ],
+      },
+      { name: 'dev:tunnel', command: 'tko dev tunnel --setup', isRaw: false },
+      {
+        name: 'one:dev',
+        command: 'bun clear-ports --only web && bun run:dev one dev --port 8081',
+        isRaw: false,
+      },
+    ])
+  })
+
+  it('resolves nested tko run chains', () => {
+    // watch -> tko run types:watch build:watch apps:watch
+    // build:watch -> tko run --no-root watch -> treated as leaf (no root expansion)
+    const result = flattenScripts(['watch'], scripts)
+    expect(result).toEqual([
+      { name: 'types:watch', command: 'bun check types --watch', isRaw: false },
+      { name: 'build:watch', command: 'tko run --no-root watch', isRaw: false },
+      { name: 'apps:watch', command: 'tko apps build -- --watch', isRaw: false },
+    ])
+  })
+
+  it('handles multiple input commands', () => {
+    const result = flattenScripts(['jobs', 'agent-gateway'], scripts)
+    expect(result).toEqual([
+      {
+        name: 'jobs',
+        command: 'ALLOW_MISSING_ENV=1 bun run:dev scripts/dev/jobs.ts',
+        isRaw: false,
+      },
+      { name: 'agent-gateway', command: 'tko dev agent-gateway', isRaw: false },
+    ])
+  })
+
+  it('handles scripts not found in package.json as raw commands', () => {
+    const result = flattenScripts(['nonexistent'], scripts)
+    expect(result).toEqual([{ name: 'nonexistent', command: 'nonexistent', isRaw: true }])
+  })
+
+  it('detects cycles and stops recursion', () => {
+    const cyclicScripts: Record<string, string> = {
+      a: 'tko run b',
+      b: 'tko run a',
+    }
+    const result = flattenScripts(['a'], cyclicScripts)
+    // a -> b -> a (cycle). when 'a' is encountered again, it's emitted as a leaf
+    expect(result).toEqual([{ name: 'a', command: 'tko run b', isRaw: false }])
+  })
+
+  it('strips --flags=last and --pty from tko commands when extracting children', () => {
+    // verify flags like --flags=last don't appear as script names
+    const simpleScripts: Record<string, string> = {
+      parent: 'bun tko run-all --flags=last --pty child1 child2',
+      child1: 'echo one',
+      child2: 'echo two',
+    }
+    const result = flattenScripts(['parent'], simpleScripts)
+    expect(result).toEqual([
+      { name: 'child1', command: 'echo one', isRaw: false },
+      { name: 'child2', command: 'echo two', isRaw: false },
+    ])
+  })
+
+  it('treats --no-root tko run as a leaf command (no root expansion)', () => {
+    const simpleScripts: Record<string, string> = {
+      parent: 'bun tko run-all --no-root --flags=last child1 child2',
+      child1: 'echo one',
+      child2: 'echo two',
+    }
+    const result = flattenScripts(['parent'], simpleScripts)
+    // --no-root means this runs in workspace packages only, don't expand against root
+    expect(result).toEqual([
+      {
+        name: 'parent',
+        command: 'bun tko run-all --no-root --flags=last child1 child2',
+        isRaw: false,
+      },
+    ])
+  })
+
+  it('filters out scripts listed in BUN_RUN_SCRIPTS', () => {
+    const result = flattenScripts(['backend'], scripts, {
+      runningScripts: ['backend:up'],
+    })
+    expect(result).toEqual([
+      {
+        name: 'backend:migrate-then-zero',
+        command:
+          'ALLOW_MISSING_ENV=1 bun run:dev scripts/dev/migrate.ts && bun env:dev docker compose up zero',
+        isRaw: false,
+      },
+      {
+        name: 'jobs',
+        command: 'ALLOW_MISSING_ENV=1 bun run:dev scripts/dev/jobs.ts',
+        isRaw: false,
+      },
+    ])
+  })
+
+  it('handles tko run-all with --pty flag (lite script)', () => {
+    // lite = bun run:dev tko run-all --pty --flags=last watch-lazy lite:backend one:dev agent-gateway
+    // the "bun run:dev" prefix before tko means this is NOT a tko command at the top level
+    // it contains && or is a raw command - actually "bun run:dev tko run-all ..." IS a tko pattern
+    // but wrapped in "bun run:dev" so it should be treated as a leaf
+    const result = flattenScripts(['lite'], scripts)
+    expect(result).toEqual([
+      {
+        name: 'lite',
+        command:
+          'bun run:dev tko run-all --pty --flags=last watch-lazy lite:backend one:dev agent-gateway',
+        isRaw: false,
+      },
+    ])
+  })
+
+  it('deduplicates scripts that appear multiple times', () => {
+    const dupeScripts: Record<string, string> = {
+      a: 'tko run shared c',
+      b: 'tko run shared d',
+      shared: 'echo shared',
+      c: 'echo c',
+      d: 'echo d',
+    }
+    const result = flattenScripts(['a', 'b'], dupeScripts)
+    const names = result.map((r) => r.name)
+    expect(names).toEqual(['shared', 'c', 'shared', 'd'])
+  })
+
+  it('inlines simple bun script in compound middle segment', () => {
+    const s: Record<string, string> = {
+      setup: 'bun migrate && bun serve',
+      migrate: 'drizzle-kit push',
+      serve: 'bun run:dev server.ts',
+    }
+    const result = flattenScripts(['setup'], s)
+    expect(result).toEqual([
+      {
+        name: 'setup',
+        command: 'drizzle-kit push && bun run:dev server.ts',
+        isRaw: false,
+      },
+    ])
+  })
+
+  it('leaves non-bun compound segments untouched', () => {
+    const s: Record<string, string> = {
+      task: 'sleep 5 && echo done',
+    }
+    const result = flattenScripts(['task'], s)
+    expect(result).toEqual([
+      { name: 'task', command: 'sleep 5 && echo done', isRaw: false },
+    ])
+  })
+
+  it('handles semicolons as compound operators', () => {
+    const s: Record<string, string> = {
+      task: 'echo start; bun build; echo end',
+      build: 'tsc --noEmit',
+    }
+    const result = flattenScripts(['task'], s)
+    expect(result).toEqual([
+      { name: 'task', command: 'echo start ; tsc --noEmit ; echo end', isRaw: false },
+    ])
+  })
+
+  it('passes extra args through when inlining bun references', () => {
+    const s: Record<string, string> = {
+      task: 'bun build --watch && echo done',
+      build: 'tsc',
+    }
+    const result = flattenScripts(['task'], s)
+    expect(result).toEqual([
+      { name: 'task', command: 'tsc --watch && echo done', isRaw: false },
+    ])
+  })
+})
+
+describe('splitCompound', () => {
+  it('returns null for simple commands', () => {
+    expect(splitCompound('echo hello')).toBeNull()
+    expect(splitCompound('bun run dev')).toBeNull()
+  })
+
+  it('splits on &&', () => {
+    expect(splitCompound('sleep 5 && echo done')).toEqual({
+      segments: ['sleep 5', 'echo done'],
+      operators: ['&&'],
+    })
+  })
+
+  it('splits on ||', () => {
+    expect(splitCompound('test -f file || echo missing')).toEqual({
+      segments: ['test -f file', 'echo missing'],
+      operators: ['||'],
+    })
+  })
+
+  it('splits on ;', () => {
+    expect(splitCompound('echo a; echo b')).toEqual({
+      segments: ['echo a', 'echo b'],
+      operators: [';'],
+    })
+  })
+
+  it('handles mixed operators', () => {
+    expect(splitCompound('a && b || c; d')).toEqual({
+      segments: ['a', 'b', 'c', 'd'],
+      operators: ['&&', '||', ';'],
+    })
+  })
+
+  it('respects double quotes', () => {
+    expect(splitCompound('echo "a && b" && echo c')).toEqual({
+      segments: ['echo "a && b"', 'echo c'],
+      operators: ['&&'],
+    })
+  })
+
+  it('respects single quotes', () => {
+    expect(splitCompound("echo 'a && b' && echo c")).toEqual({
+      segments: ["echo 'a && b'", 'echo c'],
+      operators: ['&&'],
+    })
+  })
+
+  it('handles escaped characters', () => {
+    expect(splitCompound('echo a\\&\\& && echo b')).toEqual({
+      segments: ['echo a\\&\\&', 'echo b'],
+      operators: ['&&'],
+    })
+  })
+})

package/src/helpers/resolveScript.ts

@@ -0,0 +1,225 @@
+export interface FlattenedScript {
+  name: string
+  command: string
+  /** true when the script name doesn't exist in package.json */
+  isRaw: boolean
+  /** scripts to spawn in parallel after command completes successfully */
+  deferredScripts?: FlattenedScript[]
+}
+
+export interface FlattenOptions {
+  /** scripts already running (from BUN_RUN_SCRIPTS), will be filtered out */
+  runningScripts?: string[]
+}
+
+// matches: "bun tko run ...", "bun tko run-all ...", "tko run ...", "tko run-all ..."
+// but NOT "bun run:dev tko run-all ..." (has extra words between bun and tko)
+const TKO_RUN_RE = /^(?:bun\s+)?tko\s+(run(?:-all)?)\s+(.+)$/
+
+/**
+ * parse a tko run/run-all command string, extracting script names and flags
+ * returns null if the command is not a tko run/run-all pattern
+ */
+function parseTkoRun(command: string): { scriptNames: string[]; noRoot: boolean } | null {
+  const match = command.match(TKO_RUN_RE)
+  if (!match) return null
+
+  const argsPart = match[2]!
+  const args = argsPart.split(/\s+/)
+  const scriptNames: string[] = []
+  let noRoot = false
+
+  for (const arg of args) {
+    if (arg === '--no-root') {
+      noRoot = true
+      continue
+    }
+    if (arg.startsWith('--')) continue
+    scriptNames.push(arg)
+  }
+
+  return { scriptNames, noRoot }
+}
+
+/**
+ * split a shell command on &&, ||, ; while respecting quotes.
+ * returns null if no operators found (command is not a compound).
+ */
+export function splitCompound(
+  command: string
+): { segments: string[]; operators: string[] } | null {
+  const segments: string[] = []
+  const operators: string[] = []
+  let current = ''
+  let inSingle = false
+  let inDouble = false
+  let i = 0
+
+  while (i < command.length) {
+    const ch = command[i]!
+
+    if (ch === "'" && !inDouble) {
+      inSingle = !inSingle
+      current += ch
+      i++
+    } else if (ch === '"' && !inSingle) {
+      inDouble = !inDouble
+      current += ch
+      i++
+    } else if (ch === '\\' && !inSingle) {
+      current += ch + (command[i + 1] || '')
+      i += 2
+    } else if (!inSingle && !inDouble) {
+      if (command[i] === '&' && command[i + 1] === '&') {
+        segments.push(current.trim())
+        operators.push('&&')
+        current = ''
+        i += 2
+      } else if (command[i] === '|' && command[i + 1] === '|') {
+        segments.push(current.trim())
+        operators.push('||')
+        current = ''
+        i += 2
+      } else if (command[i] === ';') {
+        segments.push(current.trim())
+        operators.push(';')
+        current = ''
+        i++
+      } else {
+        current += ch
+        i++
+      }
+    } else {
+      current += ch
+      i++
+    }
+  }
+
+  if (current.trim()) segments.push(current.trim())
+  if (operators.length === 0) return null
+  return { segments, operators }
+}
+
+/**
+ * match "bun <name> [args...]" where <name> is a package.json script.
+ * returns the script name and any trailing args, or null if no match.
+ */
+function matchBunRun(
+  segment: string,
+  scripts: Record<string, string>
+): { name: string; args: string[] } | null {
+  const parts = segment.trim().split(/\s+/)
+  if (parts[0] !== 'bun' || parts.length < 2) return null
+  const name = parts[1]!
+  if (name.startsWith('-')) return null
+  if (scripts[name] === undefined) return null
+  return { name, args: parts.slice(2) }
+}
+
+/**
+ * recursively flatten script references into leaf commands.
+ * resolves tko run/run-all chains AND shell compounds (&&, ;, ||).
+ */
+export function flattenScripts(
+  commands: string[],
+  packageJsonScripts: Record<string, string>,
+  options?: FlattenOptions
+): FlattenedScript[] {
+  const runningScripts = new Set(options?.runningScripts ?? [])
+  const results: FlattenedScript[] = []
+
+  function resolve(name: string, visited: Set<string>) {
+    if (runningScripts.has(name)) return
+
+    const scriptCommand = packageJsonScripts[name]
+
+    // script doesn't exist in package.json - treat as raw command
+    if (scriptCommand === undefined) {
+      results.push({ name, command: name, isRaw: true })
+      return
+    }
+
+    // cycle detected - emit as leaf to avoid infinite recursion
+    if (visited.has(name)) {
+      results.push({ name, command: scriptCommand, isRaw: false })
+      return
+    }
+
+    // try to parse as tko run/run-all
+    const parsed = parseTkoRun(scriptCommand)
+    if (parsed) {
+      // --no-root means this will be handled by a separate tko process
+      // scoped to workspace packages — don't resolve against root scripts
+      if (parsed.noRoot) {
+        results.push({ name, command: scriptCommand, isRaw: false })
+        return
+      }
+      visited.add(name)
+      for (const childName of parsed.scriptNames) {
+        resolve(childName, visited)
+      }
+      return
+    }
+
+    // try to parse as shell compound (&&, ;, ||)
+    const compound = splitCompound(scriptCommand)
+    if (compound) {
+      const resolvedSegments: string[] = []
+      let deferredScripts: FlattenedScript[] | undefined
+
+      for (let idx = 0; idx < compound.segments.length; idx++) {
+        const segment = compound.segments[idx]!
+        const isLast = idx === compound.segments.length - 1
+        const bunMatch = matchBunRun(segment, packageJsonScripts)
+
+        if (bunMatch) {
+          const innerCommand = packageJsonScripts[bunMatch.name]!
+          const innerParsed = parseTkoRun(innerCommand)
+
+          if (innerParsed && innerParsed.noRoot) {
+            // --no-root: keep as-is, will be handled by separate tko process
+            resolvedSegments.push(segment)
+          } else if (innerParsed && isLast) {
+            // last segment is a tko run → defer its children for parallel spawn
+            deferredScripts = flattenScripts(
+              innerParsed.scriptNames,
+              packageJsonScripts,
+              options
+            )
+          } else if (innerParsed && !isLast) {
+            // non-last segment is a tko run — can't inline parallel, keep as bun run
+            resolvedSegments.push(segment)
+          } else {
+            // simple script → inline its command with any extra args
+            const inlined = bunMatch.args.length
+              ? `${innerCommand} ${bunMatch.args.join(' ')}`
+              : innerCommand
+            resolvedSegments.push(inlined)
+          }
+        } else {
+          resolvedSegments.push(segment)
+        }
+      }
+
+      // reconstruct the compound from resolved segments
+      let reconstructed = resolvedSegments[0] || ''
+      for (let idx = 0; idx < compound.operators.length; idx++) {
+        if (idx < resolvedSegments.length - 1) {
+          reconstructed += ` ${compound.operators[idx]} ${resolvedSegments[idx + 1]}`
+        }
+      }
+
+      results.push({ name, command: reconstructed, isRaw: false, deferredScripts })
+      return
+    }
+
+    // leaf command - not a tko run/run-all or compound
+    results.push({ name, command: scriptCommand, isRaw: false })
+  }
+
+  for (const cmd of commands) {
+    resolve(cmd, new Set())
+  }
+
+  return results
+}

package/src/node-version-check.ts

@@ -0,0 +1,55 @@
+import { execFileSync } from 'node:child_process'
+import fs from 'node:fs'
+
+import semver from 'semver'
+
+function getCurrentNodeVersion() {
+  // under bun, process.version is bun's bundled node-COMPAT string (a fixed
+  // value like v24.3.0), not the project's actual node toolchain — comparing
+  // it against engines.node rejects any pin newer than bun's compat level.
+  // the check exists to guard native-addon ABI for the real `node` binary
+  // child processes will run, so resolve that binary's version from PATH.
+  if (process.versions.bun) {
+    try {
+      return execFileSync('node', ['--version'], { encoding: 'utf-8' }).trim()
+    } catch {
+      // no node on PATH — nothing for the version pin to guard
+      return null
+    }
+  }
+  return process.version
+}
+
+async function getRequiredNodeVersion() {
+  const path = await import('node:path')
+
+  try {
+    const nodeVersionContent = await fs.promises.readFile(
+      path.join(process.cwd(), '.node-version'),
+      'utf-8'
+    )
+    return nodeVersionContent.trim()
+  } catch {}
+
+  try {
+    const packageJson = JSON.parse(
+      await fs.promises.readFile(path.join(process.cwd(), 'package.json'), 'utf-8')
+    )
+    return packageJson?.engines?.node ?? null
+  } catch {
+    return null
+  }
+}
+
+export async function checkNodeVersion() {
+  const current = getCurrentNodeVersion()
+  const required = await getRequiredNodeVersion()
+
+  if (!required || !current) return
+
+  if (semver.validRange(required) && semver.satisfies(current, required)) return
+
+  throw new Error(
+    `Warning: Incorrect Node.js version. Expected ${required} but got ${current}`
+  )
+}