@ticatec/omniflow-core 0.1.1 → 0.2.0

package/src/primitives/subprocess.ts

@@ -0,0 +1,389 @@
+import path from 'node:path'
+import fs from 'node:fs'
+import { Transform } from 'node:stream'
+import type { execa } from 'execa'
+import { tryGetContext } from '../context/index.js'
+import { isSecretKey, maskString } from '../utils/mask.js'
+
+export interface SubprocessResult {
+  stdout: string
+  stderr: string
+  exitCode: number
+  failed: boolean
+  signal?: string
+}
+
+export interface SubprocessRunOptions {
+  subprocess: ReturnType<typeof execa>
+  displayCmd: string
+  cmdText?: string
+  errorPrefix?: string
+  reject?: boolean
+  secrets?: string[]
+}
+
+/**
+ * Resolve process.env merged with context.env and any explicit overrides.
+ */
+export function resolveEnv(explicitEnv?: Record<string, string>): Record<string, string> {
+  const ctx = tryGetContext()
+  const base = { ...process.env }
+  if (ctx?.env) {
+    Object.assign(base, ctx.env)
+  }
+  if (explicitEnv) {
+    Object.assign(base, explicitEnv)
+  }
+  return base as Record<string, string>
+}
+
+/**
+ * Extract active secret values from execution context.
+ */
+export function getSecretValues(): string[] {
+  const ctx = tryGetContext()
+  if (!ctx?.env) return []
+  const secrets: string[] = []
+  for (const [k, v] of Object.entries(ctx.env)) {
+    if (isSecretKey(k) && typeof v === 'string' && v.length >= 3) {
+      secrets.push(v)
+    }
+  }
+  return secrets
+}
+
+/**
+ * Create a stateful Transform stream that masks secrets across chunk boundaries.
+ * Retains up to maxSecretLen - 1 bytes in tail buffer to prevent boundary leaks.
+ */
+export function createMaskTransform(secrets: string[]): Transform {
+  const activeSecrets = secrets
+    .filter(s => typeof s === 'string' && s.length >= 3)
+    .flatMap(s => s.includes('\n') ? s.split(/\r?\n/).map(l => l.trim()).filter(l => l.length >= 3) : [s])
+
+  if (activeSecrets.length === 0) {
+    return new Transform({
+      transform(chunk, _encoding, callback) {
+        callback(null, chunk)
+      }
+    })
+  }
+
+  // Sort descending by length so longer matches are prioritized
+  activeSecrets.sort((a, b) => b.length - a.length)
+
+  const maxSecretLen = Math.max(...activeSecrets.map(s => s.length))
+  const keepLen = Math.max(0, maxSecretLen - 1)
+  let tail = ''
+
+  return new Transform({
+    transform(chunk, _encoding, callback) {
+      const text = tail + chunk.toString('utf8')
+      const masked = maskString(text, activeSecrets)
+
+      if (masked.length > keepLen) {
+        const emitLen = masked.length - keepLen
+        const toEmit = masked.slice(0, emitLen)
+        tail = masked.slice(emitLen)
+        callback(null, Buffer.from(toEmit, 'utf8'))
+      } else {
+        tail = masked
+        callback()
+      }
+    },
+    flush(callback) {
+      if (tail.length > 0) {
+        const finalMasked = maskString(tail, activeSecrets)
+        tail = ''
+        callback(null, Buffer.from(finalMasked, 'utf8'))
+      } else {
+        callback()
+      }
+    }
+  })
+}
+
+/**
+ * Prefix every line in the stream with a tag (e.g. PID).
+ */
+export function createLinePrefixTransform(prefix: string): Transform {
+  if (!prefix) {
+    return new Transform({
+      transform(chunk, _encoding, callback) {
+        callback(null, chunk)
+      }
+    })
+  }
+
+  let remainder = ''
+  return new Transform({
+    transform(chunk, _encoding, callback) {
+      const text = remainder + chunk.toString('utf8')
+      const lines = text.split('\n')
+      remainder = lines.pop() ?? ''
+      const out = lines.map(l => `${prefix}${l}\n`).join('')
+      callback(null, Buffer.from(out, 'utf8'))
+    },
+    flush(callback) {
+      if (remainder.length > 0) {
+        callback(null, Buffer.from(`${prefix}${remainder}\n`, 'utf8'))
+      } else {
+        callback()
+      }
+    }
+  })
+}
+
+/**
+ * Open appendable write stream to the log file, auto-creating directories.
+ */
+export function openLogStream(logFile: string, logger?: { warn?: (msg: string) => void }): fs.WriteStream | undefined {
+  try {
+    const logDir = path.dirname(logFile)
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true })
+    }
+    if (fs.existsSync(logFile) && fs.statSync(logFile).isDirectory()) {
+      logger?.warn?.(`Failed to open logFile ${logFile}: path is a directory`)
+      return undefined
+    }
+    const logStream = fs.createWriteStream(logFile, { flags: 'a' })
+    logStream.on('error', (err) => {
+      logger?.warn?.(`Failed to write to logFile ${logFile}: ${err.message}`)
+    })
+    return logStream
+  } catch (err: any) {
+    logger?.warn?.(`Failed to open logFile ${logFile}: ${err?.message}`)
+    return undefined
+  }
+}
+
+/**
+ * Mask all known string and stdio properties on an ExecaError.
+ */
+export function maskExecaError(thrownError: any, secrets: string[]): any {
+  if (!thrownError) return thrownError
+  if (secrets.length > 0) {
+    const props = ['message', 'shortMessage', 'originalMessage', 'command', 'escapedCommand', 'stack', 'all']
+    for (const prop of props) {
+      if (typeof thrownError[prop] === 'string') {
+        thrownError[prop] = maskString(thrownError[prop], secrets)
+      }
+    }
+    if (Array.isArray(thrownError.stdio)) {
+      thrownError.stdio = thrownError.stdio.map((item: unknown) => {
+        if (typeof item === 'string') {
+          return maskString(item, secrets)
+        }
+        if (item && typeof (item as any).toString === 'function' && Buffer.isBuffer(item)) {
+          return Buffer.from(maskString(item.toString('utf-8'), secrets))
+        }
+        return item
+      })
+    }
+  }
+  return thrownError
+}
+
+let cmdCounter = 0
+
+export function resetCmdCounter(): void {
+  cmdCounter = 0
+}
+
+/**
+ * Unified subprocess runner: pipes stdout/stderr to logFile with PID prefix and masking,
+ * manages stream flushing, exit code logging, failure log level downgrade, and ExecaError masking.
+ */
+export async function runSubprocess(options: SubprocessRunOptions): Promise<SubprocessResult> {
+  const { subprocess, displayCmd, reject = true } = options
+  const ctx = tryGetContext()
+  const secrets = options.secrets ?? getSecretValues()
+  const pid = subprocess.pid
+  const pidTag = pid ? `[PID ${pid}] ` : `[CMD ${++cmdCounter}] `
+  const cmdText = options.cmdText ?? displayCmd
+  const errorPrefix = options.errorPrefix ?? 'Command'
+
+  let logStream: fs.WriteStream | undefined
+  if (ctx?.logFile) {
+    logStream = openLogStream(ctx.logFile, ctx.logger)
+  }
+
+  if (logStream && !logStream.destroyed && logStream.writable) {
+    try {
+      logStream.write(`${pidTag}${displayCmd}\n`)
+    } catch {}
+  }
+
+  let lineStdout: Transform | undefined
+  let lineStderr: Transform | undefined
+  const streamDone: Promise<void>[] = []
+
+  const unpipeAndDrain = () => {
+    if (lineStdout && logStream) {
+      try {
+        lineStdout.unpipe(logStream)
+        lineStdout.resume()
+      } catch {}
+    }
+    if (lineStderr && logStream) {
+      try {
+        lineStderr.unpipe(logStream)
+        lineStderr.resume()
+      } catch {}
+    }
+  }
+
+  if (logStream) {
+    logStream.on('error', unpipeAndDrain)
+    logStream.on('close', unpipeAndDrain)
+  }
+
+  if (subprocess.stdout && logStream) {
+    const maskStdout = createMaskTransform(secrets)
+    lineStdout = createLinePrefixTransform(pidTag)
+    maskStdout.pipe(lineStdout).pipe(logStream, { end: false })
+    subprocess.stdout.pipe(maskStdout)
+    streamDone.push(new Promise(resolve => {
+      let resolved = false
+      const done = () => {
+        if (!resolved) {
+          resolved = true
+          resolve()
+        }
+      }
+      lineStdout!.once('end', done)
+      lineStdout!.once('close', done)
+      lineStdout!.once('error', done)
+      if (logStream) {
+        logStream.once('error', done)
+        logStream.once('close', done)
+      }
+    }))
+  }
+  if (subprocess.stderr && logStream) {
+    const maskStderr = createMaskTransform(secrets)
+    lineStderr = createLinePrefixTransform(pidTag)
+    maskStderr.pipe(lineStderr).pipe(logStream, { end: false })
+    subprocess.stderr.pipe(maskStderr)
+    streamDone.push(new Promise(resolve => {
+      let resolved = false
+      const done = () => {
+        if (!resolved) {
+          resolved = true
+          resolve()
+        }
+      }
+      lineStderr!.once('end', done)
+      lineStderr!.once('close', done)
+      lineStderr!.once('error', done)
+      if (logStream) {
+        logStream.once('error', done)
+        logStream.once('close', done)
+      }
+    }))
+  }
+
+  let execResult: any
+  let thrownError: any
+
+  try {
+    execResult = await subprocess
+  } catch (err: any) {
+    thrownError = err
+    execResult = err
+  }
+
+  // Always wait for stream completion regardless of subprocess exit status, with timeout safety
+  if (streamDone.length > 0) {
+    let timeoutId: NodeJS.Timeout | undefined
+    const drainTimeout = new Promise<void>(resolve => {
+      timeoutId = setTimeout(resolve, 3000)
+      timeoutId.unref?.()
+    })
+    await Promise.race([Promise.all(streamDone), drainTimeout])
+    if (timeoutId) {
+      clearTimeout(timeoutId)
+    }
+  }
+
+  try {
+    const isFailed = Boolean(execResult.failed || (execResult.exitCode !== undefined && execResult.exitCode !== 0))
+    let exitCode = execResult.exitCode
+    if (exitCode === undefined) {
+      exitCode = isFailed ? -1 : 0
+    }
+
+    if (logStream && !logStream.destroyed && logStream.writable) {
+      try {
+        logStream.write(`${pidTag}[Process exited with code ${exitCode}]\n`)
+      } catch {}
+    }
+
+    if (isFailed) {
+      if (reject === false) {
+        ctx?.logger?.debug?.(`${errorPrefix} exited with code ${exitCode} (reject: false): ${cmdText}`)
+      } else {
+        ctx?.logger?.error?.(`${errorPrefix} failed with exit code ${exitCode}: ${cmdText}`)
+      }
+    }
+
+    const rawStdout = typeof execResult.stdout === 'string' ? execResult.stdout : (execResult.stdout ? String(execResult.stdout) : '')
+    const rawStderr = typeof execResult.stderr === 'string' ? execResult.stderr : (execResult.stderr ? String(execResult.stderr) : '')
+
+    const stdout = secrets.length > 0 ? maskString(rawStdout, secrets) : rawStdout
+    const stderr = secrets.length > 0 ? maskString(rawStderr, secrets) : rawStderr
+
+    if (thrownError) {
+      maskExecaError(thrownError, secrets)
+      thrownError.stdout = stdout
+      thrownError.stderr = stderr
+      thrownError.exitCode = exitCode
+      thrownError.failed = true
+
+      if (reject === false) {
+        return {
+          stdout,
+          stderr,
+          exitCode,
+          failed: true,
+          signal: execResult.signal
+        }
+      }
+      throw thrownError
+    }
+
+    return {
+      stdout,
+      stderr,
+      exitCode,
+      failed: isFailed,
+      signal: execResult.signal
+    }
+  } finally {
+    if (logStream) {
+      await new Promise<void>(resolve => {
+        if (logStream!.destroyed || logStream!.closed || !logStream!.writable) {
+          resolve()
+          return
+        }
+        let settled = false
+        let timer: NodeJS.Timeout | undefined
+        const done = () => {
+          if (!settled) {
+            settled = true
+            if (timer) {
+              clearTimeout(timer)
+            }
+            resolve()
+          }
+        }
+        timer = setTimeout(done, 1000)
+        timer.unref?.()
+        logStream!.once('error', done)
+        logStream!.once('close', done)
+        logStream!.end(done)
+      })
+    }
+  }
+}

package/src/toolchain/index.ts

@@ -0,0 +1,6 @@
+export * from './types.js'
+export * from './registry.js'
+export { MavenToolchain } from './providers/MavenToolchain.js'
+export { GradleToolchain } from './providers/GradleToolchain.js'
+export { NodeToolchain } from './providers/NodeToolchain.js'
+export { readPom, parseXml } from './providers/pom.js'

package/src/toolchain/providers/GradleToolchain.ts

@@ -0,0 +1,137 @@
+import path from 'node:path'
+import fs from 'node:fs/promises'
+import { shell } from '../../primitives/shell.js'
+import type { ToolchainProvider, DetectionResult, ProjectInfo } from '../types.js'
+
+const BUILD_FILES = ['build.gradle', 'build.gradle.kts']
+const SETTINGS_FILES = ['settings.gradle', 'settings.gradle.kts']
+
+async function readIfPresent(file: string): Promise<string | undefined> {
+  try {
+    return await fs.readFile(file, 'utf-8')
+  } catch {
+    return undefined
+  }
+}
+
+function fromProperties(text: string, key: string): string | undefined {
+  for (const line of text.split('\n')) {
+    const trimmed = line.trim()
+    if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('!')) continue
+    const eq = trimmed.indexOf('=')
+    if (eq === -1) continue
+    if (trimmed.slice(0, eq).trim() !== key) continue
+    return trimmed.slice(eq + 1).trim() || undefined
+  }
+  return undefined
+}
+
+function fromBuildScript(text: string, key: string): string | undefined {
+  const assignment = new RegExp(`^\\s*${key}(?:\\s*=|\\s+)\\s*['"]([^'"]+)['"]`, 'm')
+  return assignment.exec(text)?.[1]
+}
+
+export class GradleToolchain implements ToolchainProvider {
+  readonly name = 'gradle'
+  readonly priority: number = 20
+
+  async detect(projectDir: string): Promise<DetectionResult | null> {
+    for (const file of BUILD_FILES) {
+      try {
+        await fs.access(path.join(projectDir, file))
+        return { name: 'gradle', reason: `found ${file}` }
+      } catch {
+        // continue
+      }
+    }
+    return null
+  }
+
+  async projectInfo(projectDir: string): Promise<ProjectInfo> {
+    let name = await this.staticName(projectDir)
+    let version = await this.staticVersion(projectDir)
+
+    if (!name) name = path.basename(projectDir)
+    if (!version || version === 'unspecified') {
+      throw new Error(
+        `Could not determine project version for Gradle project in '${projectDir}'. ` +
+        `Please specify 'version' in build.gradle(.kts) or gradle.properties.`
+      )
+    }
+
+    const group = await this.staticGroup(projectDir)
+    return {
+      name,
+      version,
+      fullName: group ? `${group}:${name}` : name,
+      namespace: group
+    }
+  }
+
+  async install(projectDir: string, _flags: string[] = []): Promise<void> {
+    // Gradle resolves dependencies as part of tasks, no dedicated install needed
+  }
+
+  async build(projectDir: string, flags: string[] = []): Promise<void> {
+    const cmd = await this.getCommand(projectDir)
+    await shell.run({ cwd: projectDir })`${cmd} build ${flags}`
+  }
+
+  async run(projectDir: string, task: string, flags: string[] = []): Promise<void> {
+    const cmd = await this.getCommand(projectDir)
+    await shell.run({ cwd: projectDir })`${cmd} ${task} ${flags}`
+  }
+
+  private async getCommand(projectDir: string): Promise<string> {
+    const wrapper = path.join(projectDir, process.platform === 'win32' ? 'gradlew.bat' : 'gradlew')
+    try {
+      await fs.access(wrapper, fs.constants.X_OK)
+      return wrapper
+    } catch {
+      return 'gradle'
+    }
+  }
+
+  private async staticVersion(projectDir: string): Promise<string | undefined> {
+    const props = await readIfPresent(path.join(projectDir, 'gradle.properties'))
+    if (props) {
+      const found = fromProperties(props, 'version')
+      if (found) return found
+    }
+    for (const file of BUILD_FILES) {
+      const text = await readIfPresent(path.join(projectDir, file))
+      if (text) {
+        const found = fromBuildScript(text, 'version')
+        if (found) return found
+      }
+    }
+    return undefined
+  }
+
+  private async staticGroup(projectDir: string): Promise<string | undefined> {
+    const props = await readIfPresent(path.join(projectDir, 'gradle.properties'))
+    if (props) {
+      const found = fromProperties(props, 'group')
+      if (found) return found
+    }
+    for (const file of BUILD_FILES) {
+      const text = await readIfPresent(path.join(projectDir, file))
+      if (text) {
+        const found = fromBuildScript(text, 'group')
+        if (found) return found
+      }
+    }
+    return undefined
+  }
+
+  private async staticName(projectDir: string): Promise<string | undefined> {
+    for (const file of SETTINGS_FILES) {
+      const text = await readIfPresent(path.join(projectDir, file))
+      if (text) {
+        const found = /rootProject\.name\s*=\s*['"]([^'"]+)['"]/.exec(text)?.[1]
+        if (found) return found
+      }
+    }
+    return undefined
+  }
+}

package/src/toolchain/providers/MavenToolchain.ts

@@ -0,0 +1,64 @@
+import path from 'node:path'
+import fs from 'node:fs/promises'
+import { shell } from '../../primitives/shell.js'
+import { readPom } from './pom.js'
+import type { ToolchainProvider, DetectionResult, ProjectInfo } from '../types.js'
+
+export class MavenToolchain implements ToolchainProvider {
+  readonly name = 'maven'
+  readonly priority: number = 30
+
+  async detect(projectDir: string): Promise<DetectionResult | null> {
+    try {
+      await fs.access(path.join(projectDir, 'pom.xml'))
+      return { name: 'maven', reason: 'found pom.xml' }
+    } catch {
+      return null
+    }
+  }
+
+  async projectInfo(projectDir: string): Promise<ProjectInfo> {
+    const pomPath = path.join(projectDir, 'pom.xml')
+    const content = await fs.readFile(pomPath, 'utf-8')
+    const { groupId, artifactId, version } = readPom(content)
+
+    if (!artifactId) {
+      throw new Error(`Invalid pom.xml (missing <artifactId>): ${pomPath}`)
+    }
+    if (!version || version.includes('${')) {
+      throw new Error(`Invalid pom.xml (missing or unexpanded <version> '${version ?? ''}'): ${pomPath}`)
+    }
+
+    return {
+      name: artifactId,
+      version,
+      fullName: groupId ? `${groupId}:${artifactId}` : artifactId,
+      namespace: groupId
+    }
+  }
+
+  async install(projectDir: string, flags: string[] = []): Promise<void> {
+    const cmd = await this.getCommand(projectDir)
+    await shell.run({ cwd: projectDir })`${cmd} -B dependency:go-offline ${flags}`
+  }
+
+  async build(projectDir: string, flags: string[] = []): Promise<void> {
+    const cmd = await this.getCommand(projectDir)
+    await shell.run({ cwd: projectDir })`${cmd} -B package ${flags}`
+  }
+
+  async run(projectDir: string, task: string, flags: string[] = []): Promise<void> {
+    const cmd = await this.getCommand(projectDir)
+    await shell.run({ cwd: projectDir })`${cmd} -B ${task} ${flags}`
+  }
+
+  private async getCommand(projectDir: string): Promise<string> {
+    const wrapper = path.join(projectDir, process.platform === 'win32' ? 'mvnw.cmd' : 'mvnw')
+    try {
+      await fs.access(wrapper, fs.constants.X_OK)
+      return wrapper
+    } catch {
+      return 'mvn'
+    }
+  }
+}