@meistrari/tela-cli 0.1.0

package/src/process.ts

@@ -0,0 +1,251 @@
+export interface CommandResult {
+    command: string[]
+    exitCode: number
+    stdout: string
+    stderr: string
+}
+
+export interface RunCommandOptions {
+    cwd?: string
+    env?: Record<string, string | undefined>
+    stdin?: 'pipe' | 'inherit' | 'ignore'
+    input?: string
+    allowFailure?: boolean
+}
+
+export interface RunStreamingCommandOptions extends RunCommandOptions {
+    onStdoutLine?: (line: string) => void | Promise<void>
+    onStderrLine?: (line: string) => void | Promise<void>
+}
+
+export interface StreamingCommandHandle {
+    result: Promise<CommandResult>
+    interrupt(): void
+    kill(): void
+}
+
+export class CommandError extends Error {
+    constructor(
+        message: string,
+        public readonly result: CommandResult,
+    ) {
+        super(message)
+    }
+}
+
+async function readStream(stream: ReadableStream<Uint8Array> | null | undefined): Promise<string> {
+    if (!stream) {
+        return ''
+    }
+
+    return await new Response(stream).text()
+}
+
+async function readLineStream(
+    stream: ReadableStream<Uint8Array> | null | undefined,
+    onLine?: (line: string) => void | Promise<void>,
+): Promise<string> {
+    if (!stream) {
+        return ''
+    }
+
+    const reader = stream.getReader()
+    const decoder = new TextDecoder()
+    let buffer = ''
+    let output = ''
+
+    while (true) {
+        const { done, value } = await reader.read()
+        if (done) {
+            break
+        }
+
+        const chunk = decoder.decode(value, { stream: true })
+        output += chunk
+        buffer += chunk
+
+        let newlineIndex = buffer.indexOf('\n')
+        while (newlineIndex >= 0) {
+            const line = buffer.slice(0, newlineIndex).replace(/\r$/, '')
+            if (onLine) {
+                await onLine(line)
+            }
+            buffer = buffer.slice(newlineIndex + 1)
+            newlineIndex = buffer.indexOf('\n')
+        }
+    }
+
+    const remainder = decoder.decode()
+    if (remainder) {
+        output += remainder
+        buffer += remainder
+    }
+
+    if (buffer.length > 0 && onLine) {
+        await onLine(buffer.replace(/\r$/, ''))
+    }
+
+    return output
+}
+
+export async function runCommand(
+    command: string[],
+    options: RunCommandOptions = {},
+): Promise<CommandResult> {
+    const stdin = options.input !== undefined
+        ? new Blob([options.input])
+        : (options.stdin ?? 'pipe')
+
+    const proc = Bun.spawn(command, {
+        cwd: options.cwd,
+        env: options.env ? { ...process.env, ...options.env } : process.env,
+        stdin,
+        stdout: 'pipe',
+        stderr: 'pipe',
+    })
+
+    const [stdout, stderr, exitCode] = await Promise.all([
+        readStream(proc.stdout),
+        readStream(proc.stderr),
+        proc.exited,
+    ])
+
+    const result: CommandResult = {
+        command,
+        exitCode: exitCode ?? 1,
+        stdout,
+        stderr,
+    }
+
+    if (result.exitCode !== 0 && !options.allowFailure) {
+        throw new CommandError(
+            `Command failed (${result.exitCode}): ${command.join(' ')}`,
+            result,
+        )
+    }
+
+    return result
+}
+
+export async function runShell(
+    script: string,
+    options: Omit<RunCommandOptions, 'input'> = {},
+): Promise<CommandResult> {
+    return await runCommand(
+        ['/bin/bash', '-lc', script],
+        options,
+    )
+}
+
+export async function commandExists(command: string): Promise<boolean> {
+    const result = await runCommand(['which', command], { allowFailure: true })
+    return result.exitCode === 0
+}
+
+export async function runInteractiveCommand(
+    command: string[],
+    options: Omit<RunCommandOptions, 'stdin' | 'input'> = {},
+): Promise<CommandResult> {
+    const proc = Bun.spawn(command, {
+        cwd: options.cwd,
+        env: options.env ? { ...process.env, ...options.env } : process.env,
+        stdin: 'inherit',
+        stdout: 'inherit',
+        stderr: 'inherit',
+    })
+
+    const exitCode = await proc.exited
+    const result: CommandResult = {
+        command,
+        exitCode: exitCode ?? 1,
+        stdout: '',
+        stderr: '',
+    }
+
+    if (result.exitCode !== 0 && !options.allowFailure) {
+        throw new CommandError(
+            `Command failed (${result.exitCode}): ${command.join(' ')}`,
+            result,
+        )
+    }
+
+    return result
+}
+
+export async function runStreamingCommand(
+    command: string[],
+    options: RunStreamingCommandOptions = {},
+): Promise<CommandResult> {
+    return await spawnStreamingCommand(command, options).result
+}
+
+export function spawnStreamingCommand(
+    command: string[],
+    options: RunStreamingCommandOptions = {},
+): StreamingCommandHandle {
+    const stdin = options.input !== undefined
+        ? new Blob([options.input])
+        : (options.stdin ?? 'pipe')
+
+    const proc = Bun.spawn(command, {
+        cwd: options.cwd,
+        env: options.env ? { ...process.env, ...options.env } : process.env,
+        stdin,
+        stdout: 'pipe',
+        stderr: 'pipe',
+    })
+
+    const sendSignal = (signal?: string) => {
+        try {
+            ;(proc as { kill: (signal?: string) => void }).kill(signal)
+        }
+        catch {
+            try {
+                proc.kill()
+            }
+            catch {
+                // Best-effort shutdown only.
+            }
+        }
+    }
+
+    const result = (async () => {
+        try {
+            const [stdout, stderr, exitCode] = await Promise.all([
+                readLineStream(proc.stdout, options.onStdoutLine),
+                readLineStream(proc.stderr, options.onStderrLine),
+                proc.exited,
+            ])
+
+            const commandResult: CommandResult = {
+                command,
+                exitCode: exitCode ?? 1,
+                stdout,
+                stderr,
+            }
+
+            if (commandResult.exitCode !== 0 && !options.allowFailure) {
+                throw new CommandError(
+                    `Command failed (${commandResult.exitCode}): ${command.join(' ')}`,
+                    commandResult,
+                )
+            }
+
+            return commandResult
+        }
+        catch (error) {
+            sendSignal()
+            throw error
+        }
+    })()
+
+    return {
+        result,
+        interrupt() {
+            sendSignal('SIGINT')
+        },
+        kill() {
+            sendSignal('SIGKILL')
+        },
+    }
+}