@fitlab-ai/agent-infra 0.7.6 → 0.8.0

package/dist/lib/server/daemon.js

@@ -0,0 +1,96 @@
+import { VERSION } from "../version.js";
+import { loadServerConfig } from "./config.js";
+import { createLogger } from "./logger.js";
+import { loadAdapters, unloadAdapters } from "./plugin-loader.js";
+import { authorize } from "./auth.js";
+import { commandHelp, parseCommand } from "./protocol.js";
+import { runAi } from "./runner.js";
+import { streamCommand } from "./streamer.js";
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+// The daemon main loop. Runs in the detached child spawned by
+// process-control.start(), or in the foreground for debugging.
+//
+// Lifecycle (keep-alive / shutdown model):
+//   - The heartbeat interval is kept *ref'd*. It is both the keep-alive that
+//     holds the event loop open while subtask A has no adapters, and the
+//     observable signal that `ai server logs -f` shows.
+//   - runDaemon() awaits a shutdown promise that only resolves once a
+//     SIGINT/SIGTERM handler has finished graceful cleanup. We never unref()
+//     the only keep-alive timer (that would let the process exit immediately).
+export async function runDaemon() {
+    let config;
+    try {
+        config = loadServerConfig();
+    }
+    catch (error) {
+        process.stderr.write(`${errorMessage(error)}\n`);
+        process.exit(1);
+    }
+    const logger = createLogger(config.log);
+    logger.info(`daemon starting agent-infra ${VERSION} pid=${process.pid}`);
+    const abortController = new AbortController();
+    let resolveShutdown = () => { };
+    const shutdown = new Promise((resolve) => {
+        resolveShutdown = resolve;
+    });
+    const dispatch = async (message) => {
+        const plan = parseCommand(message.text);
+        if (plan.kind === 'ignore')
+            return;
+        if (plan.kind === 'error') {
+            await message.reply(plan.message);
+            logger.info(`command rejected from ${message.adapter}:${message.userId}: ${plan.message}`);
+            return;
+        }
+        if (plan.kind === 'builtin' && plan.name === 'ping') {
+            await message.reply(`pong ${VERSION}`);
+            return;
+        }
+        if (plan.kind === 'builtin' && plan.name === 'help') {
+            await message.reply(commandHelp());
+            return;
+        }
+        if (plan.kind === 'builtin' && plan.name === 'version') {
+            await message.reply(`agent-infra ${VERSION}`);
+            return;
+        }
+        if (plan.kind === 'ai') {
+            const allowed = authorize({ adapter: message.adapter, userId: message.userId }, plan.role, config.auth);
+            if (!allowed.ok) {
+                await message.reply(allowed.message);
+                logger.info(`unauthorized command from ${message.adapter}:${message.userId}: ${allowed.message}`);
+                return;
+            }
+            await streamCommand({
+                title: `ai ${plan.argv.join(' ')}`,
+                chunkChars: typeof config.stream?.chunkChars === 'number' ? config.stream.chunkChars : 4000,
+                throttleMs: typeof config.stream?.throttleMs === 'number' ? config.stream.throttleMs : 1500
+            }, (emit) => runAi(plan.argv, { onChunk: emit }), (text) => message.reply(text));
+        }
+    };
+    const ctx = { config, logger, dispatch, signal: abortController.signal };
+    const adapters = await loadAdapters(config, ctx);
+    logger.ok(`loaded ${adapters.length} adapter(s)`);
+    const heartbeat = setInterval(() => logger.info('heartbeat'), config.heartbeatMs);
+    let shuttingDown = false;
+    const handleSignal = (signal) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        logger.info(`received ${signal}, shutting down`);
+        abortController.abort();
+        void (async () => {
+            await unloadAdapters(adapters);
+            clearInterval(heartbeat);
+            logger.close();
+            resolveShutdown();
+        })();
+    };
+    process.on('SIGINT', () => handleSignal('SIGINT'));
+    process.on('SIGTERM', () => handleSignal('SIGTERM'));
+    await shutdown;
+    process.exit(0);
+}
+//# sourceMappingURL=daemon.js.map

package/dist/lib/server/index.js

@@ -0,0 +1,47 @@
+import { runDaemon } from "./daemon.js";
+import { start, stop, status, logs } from "./process-control.js";
+const USAGE = `Usage: ai server <command> [options]
+
+Commands:
+  start [--foreground]   Start the local daemon (detached; --foreground stays attached for debugging)
+  stop                   Stop the running daemon
+  status                 Show whether the daemon is running
+  logs [-f | --follow]   Print the daemon log ('-f' to follow new lines)
+  help                   Show this help message
+
+The daemon hosts IM adapters and command routing for agent-infra.`;
+export async function runServer(args) {
+    const [subcommand, ...rest] = args;
+    if (!subcommand) {
+        process.stdout.write(`${USAGE}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    if (subcommand === 'help' || subcommand === '--help' || subcommand === '-h') {
+        process.stdout.write(`${USAGE}\n`);
+        return;
+    }
+    switch (subcommand) {
+        case 'start':
+            await start({ foreground: rest.includes('--foreground') });
+            break;
+        case 'stop':
+            await stop();
+            break;
+        case 'status':
+            status();
+            break;
+        case 'logs':
+            await logs({ follow: rest.includes('-f') || rest.includes('--follow') });
+            break;
+        // Internal entry point for the detached daemon child (not shown in USAGE).
+        case '__daemon':
+            await runDaemon();
+            break;
+        default:
+            process.stderr.write(`Unknown server command: ${subcommand}\n`);
+            process.stdout.write(`${USAGE}\n`);
+            process.exitCode = 1;
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/lib/server/logger.js

@@ -0,0 +1,34 @@
+import fs from 'node:fs';
+import path from 'node:path';
+// Startup-only rotation: if the existing log already exceeds the threshold,
+// move it aside to `<path>.1` before the daemon starts appending. We do not
+// rotate again while running — keeping a single append stream is simpler and
+// good enough for a local daemon log.
+function rotateIfOversized(logPath, rotateAtBytes) {
+    try {
+        const { size } = fs.statSync(logPath);
+        if (size > rotateAtBytes) {
+            fs.renameSync(logPath, `${logPath}.1`);
+        }
+    }
+    catch {
+        // No existing log file (or stat failed) → nothing to rotate.
+    }
+}
+export function createLogger({ path: logPath, rotateAtBytes }) {
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    rotateIfOversized(logPath, rotateAtBytes);
+    const write = (level, message) => {
+        const line = `[${new Date().toISOString()}] [${level}] ${message}\n`;
+        fs.appendFileSync(logPath, line);
+    };
+    return {
+        info: (message) => write('INFO', message),
+        ok: (message) => write('OK', message),
+        err: (message) => write('ERROR', message),
+        // Synchronous appendFileSync keeps no open handle to flush; close() exists
+        // so the daemon shutdown path has a single, stable hook to call.
+        close: () => { }
+    };
+}
+//# sourceMappingURL=logger.js.map

package/dist/lib/server/plugin-loader.js

@@ -0,0 +1,73 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+const defaultImportAdapter = (name) => {
+    // Test-only seam: when AGENT_INFRA_SERVER_TEST_ADAPTERS_DIR is set (never in
+    // production), resolve the named adapter as a plain ESM `.js` from that
+    // fixtures dir. This lets a built daemon (`node dist/bin/cli.js`) load a test
+    // injection adapter on any node>=22 without depending on type stripping.
+    const testDir = process.env.AGENT_INFRA_SERVER_TEST_ADAPTERS_DIR;
+    if (testDir) {
+        return import(__rewriteRelativeImportExtension(pathToFileURL(path.join(testDir, name, 'index.js')).href));
+    }
+    return import(__rewriteRelativeImportExtension(`./adapters/${name}/index.ts`));
+};
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isAdapter(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const candidate = value;
+    return (typeof candidate.name === 'string' &&
+        typeof candidate.start === 'function' &&
+        typeof candidate.stop === 'function' &&
+        typeof candidate.sendMessage === 'function');
+}
+// Load every adapter whose config has `enabled === true`. Each adapter is
+// loaded, instantiated and started in isolation: a failure in one adapter is
+// logged and skipped so it never blocks the others.
+export async function loadAdapters(config, ctx, options = {}) {
+    const importAdapter = options.importAdapter ?? defaultImportAdapter;
+    const loaded = [];
+    for (const [name, adapterConfig] of Object.entries(config.adapters)) {
+        if (adapterConfig?.enabled !== true)
+            continue;
+        try {
+            const mod = (await importAdapter(name));
+            const factory = mod?.default;
+            if (typeof factory !== 'function') {
+                throw new Error(`adapter "${name}" has no default export factory`);
+            }
+            const instance = factory(adapterConfig);
+            if (!isAdapter(instance)) {
+                throw new Error(`adapter "${name}" does not satisfy the Adapter contract`);
+            }
+            await instance.start(ctx);
+            loaded.push(instance);
+        }
+        catch (error) {
+            ctx.logger.err(`failed to load adapter "${name}": ${errorMessage(error)}`);
+        }
+    }
+    return loaded;
+}
+// Stop adapters in reverse load order, isolating per-adapter stop failures.
+export async function unloadAdapters(adapters) {
+    for (const adapter of [...adapters].reverse()) {
+        try {
+            await adapter.stop();
+        }
+        catch {
+            // A failing stop must not block the rest of shutdown.
+        }
+    }
+}
+//# sourceMappingURL=plugin-loader.js.map

package/dist/lib/server/process-control.js

@@ -0,0 +1,200 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn, execFileSync } from 'node:child_process';
+import { loadServerConfig } from "./config.js";
+import { runDaemon } from "./daemon.js";
+export function buildStopCommand(pid, platform) {
+    if (platform === 'win32') {
+        return { kind: 'exec', command: 'taskkill', args: ['/PID', String(pid), '/T', '/F'] };
+    }
+    return { kind: 'signal', signal: 'SIGTERM' };
+}
+// Liveness check that treats an exited-but-unreaped daemon as dead.
+//
+// The daemon is spawned detached and re-parented to init when `ai server start`
+// exits. After it terminates, `process.kill(pid, 0)` still succeeds until init
+// reaps the zombie. On Linux we therefore also check /proc state so status/stop
+// /start don't treat an already-exited daemon as running. macOS reaps orphans
+// via launchd and Windows has no zombies, so the kill(pid, 0) result is enough.
+export function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+    }
+    catch (error) {
+        // EPERM means the process exists but we may not signal it → still alive.
+        return error.code === 'EPERM';
+    }
+    if (process.platform === 'linux') {
+        try {
+            const stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8');
+            // The process state is the first token after the parenthesised comm.
+            const state = stat.slice(stat.lastIndexOf(')') + 1).trim().charAt(0);
+            if (state === 'Z')
+                return false;
+        }
+        catch {
+            return false; // /proc entry vanished → not alive
+        }
+    }
+    return true;
+}
+function readPid(pidFile) {
+    try {
+        const raw = fs.readFileSync(pidFile, 'utf8').trim();
+        const pid = Number.parseInt(raw, 10);
+        return Number.isInteger(pid) && pid > 0 ? pid : null;
+    }
+    catch {
+        return null;
+    }
+}
+function removePidFile(pidFile) {
+    try {
+        fs.unlinkSync(pidFile);
+    }
+    catch {
+        // Already gone.
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+function enabledAdapterNames(config) {
+    return Object.entries(config.adapters)
+        .filter(([, adapter]) => adapter?.enabled === true)
+        .map(([name]) => name);
+}
+export async function start({ foreground = false } = {}) {
+    const config = loadServerConfig();
+    const pidPath = config.pidFile;
+    // Zombie PID cleanup: a stale PID file from a crashed daemon must not block a
+    // fresh start.
+    const existing = readPid(pidPath);
+    if (existing !== null && isProcessAlive(existing)) {
+        process.stdout.write(`server already running (pid ${existing})\n`);
+        return;
+    }
+    if (existing !== null) {
+        removePidFile(pidPath);
+    }
+    if (foreground) {
+        await runDaemon();
+        return;
+    }
+    const cliEntry = process.argv[1];
+    if (!cliEntry) {
+        throw new Error('server: unable to determine CLI entry point for daemon spawn');
+    }
+    // Re-spawn ourselves detached. process.execArgv is forwarded so the dev path
+    // (node --experimental-strip-types ./bin/cli.ts) and the built path
+    // (node dist/bin/cli.js) both work.
+    const child = spawn(process.execPath, [...process.execArgv, cliEntry, 'server', '__daemon'], {
+        detached: true,
+        stdio: 'ignore'
+    });
+    child.unref();
+    if (typeof child.pid !== 'number') {
+        throw new Error('server: failed to spawn daemon process');
+    }
+    fs.mkdirSync(path.dirname(pidPath), { recursive: true });
+    fs.writeFileSync(pidPath, `${child.pid}\n`);
+    process.stdout.write(`server started (pid ${child.pid})\n`);
+}
+export async function stop() {
+    const config = loadServerConfig();
+    const pid = readPid(config.pidFile);
+    if (pid === null) {
+        process.stdout.write('server is not running (no pid file)\n');
+        return;
+    }
+    if (!isProcessAlive(pid)) {
+        removePidFile(config.pidFile);
+        process.stdout.write('server is not running (removed stale pid file)\n');
+        return;
+    }
+    const command = buildStopCommand(pid, process.platform);
+    if (command.kind === 'exec') {
+        execFileSync(command.command, command.args);
+    }
+    else {
+        process.kill(pid, command.signal);
+        const deadline = Date.now() + 5000;
+        while (isProcessAlive(pid) && Date.now() < deadline) {
+            await delay(100);
+        }
+        if (isProcessAlive(pid)) {
+            process.kill(pid, 'SIGKILL');
+        }
+    }
+    removePidFile(config.pidFile);
+    process.stdout.write(`server stopped (pid ${pid})\n`);
+}
+export function status() {
+    const config = loadServerConfig();
+    const pid = readPid(config.pidFile);
+    if (pid === null || !isProcessAlive(pid)) {
+        process.stdout.write('server: stopped\n');
+        if (pid !== null) {
+            process.stdout.write(`  (stale pid file references pid ${pid})\n`);
+        }
+        return;
+    }
+    let startedAt = 'unknown';
+    try {
+        startedAt = fs.statSync(config.pidFile).mtime.toISOString();
+    }
+    catch {
+        // Leave as unknown.
+    }
+    const adapters = enabledAdapterNames(config);
+    process.stdout.write(`server: running\n` +
+        `  pid: ${pid}\n` +
+        `  started: ${startedAt}\n` +
+        `  adapters: ${adapters.length > 0 ? adapters.join(', ') : '(none)'}\n` +
+        `  pid file: ${config.pidFile}\n` +
+        `  log: ${config.log.path}\n`);
+}
+export async function logs({ follow = false } = {}) {
+    const config = loadServerConfig();
+    const logPath = config.log.path;
+    if (!fs.existsSync(logPath)) {
+        process.stdout.write('server: no log file yet\n');
+        return;
+    }
+    const initial = fs.readFileSync(logPath, 'utf8');
+    process.stdout.write(initial);
+    if (!follow)
+        return;
+    let position = Buffer.byteLength(initial);
+    const watcher = fs.watch(logPath, () => {
+        try {
+            const { size } = fs.statSync(logPath);
+            if (size < position)
+                position = 0; // truncated or rotated
+            if (size > position) {
+                const fd = fs.openSync(logPath, 'r');
+                try {
+                    const buffer = Buffer.alloc(size - position);
+                    fs.readSync(fd, buffer, 0, buffer.length, position);
+                    process.stdout.write(buffer.toString('utf8'));
+                }
+                finally {
+                    fs.closeSync(fd);
+                }
+                position = size;
+            }
+        }
+        catch {
+            // Transient read error during rotation; ignore and wait for next event.
+        }
+    });
+    await new Promise((resolve) => {
+        process.on('SIGINT', () => {
+            watcher.close();
+            resolve();
+        });
+    });
+}
+//# sourceMappingURL=process-control.js.map

package/dist/lib/server/protocol.js

@@ -0,0 +1,69 @@
+import { VERSION } from "../version.js";
+import { getSkillRunSpec } from "../run/skills.js";
+const TASK_READ = new Set(['ls', 'list', 'status', 'show', 'log', 'decisions']);
+const SANDBOX_READ = new Set(['ls', 'list', 'show']);
+const SANDBOX_WRITE = new Set(['create', 'start']);
+function splitWords(text) {
+    return text.trim().split(/\s+/).filter(Boolean);
+}
+function taskSubcommand(subcommand) {
+    return subcommand === 'list' ? 'ls' : subcommand;
+}
+export function commandHelp() {
+    return [
+        `agent-infra ${VERSION}`,
+        'Built-ins: /help, /ping, /version',
+        'Read: /sandbox ls|show|vm status, /task decisions|log|ls|show|status',
+        'Write: /sandbox create|start',
+        'Exec: /decide <task-ref> <HD-id> <decision>, /run create-task <description>, /run <skill> <task-ref> ...'
+    ].join('\n');
+}
+export function parseCommand(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith('/'))
+        return { kind: 'ignore' };
+    const words = splitWords(trimmed);
+    const [command = '', subcommand = '', ...rest] = words;
+    if (command === '/help')
+        return { kind: 'builtin', name: 'help', role: 'read', args: rest };
+    if (command === '/ping')
+        return { kind: 'builtin', name: 'ping', role: 'read', args: rest };
+    if (command === '/version')
+        return { kind: 'builtin', name: 'version', role: 'read', args: rest };
+    if (command === '/decide') {
+        return { kind: 'ai', role: 'exec', argv: ['decide', subcommand, ...rest] };
+    }
+    if (command === '/task') {
+        if (!TASK_READ.has(subcommand))
+            return { kind: 'error', message: 'Unknown /task command' };
+        return { kind: 'ai', role: 'read', argv: ['task', taskSubcommand(subcommand), ...rest] };
+    }
+    if (command === '/sandbox') {
+        if (subcommand === 'vm') {
+            if (rest[0] !== 'status')
+                return { kind: 'error', message: 'Only /sandbox vm status is allowed' };
+            return { kind: 'ai', role: 'read', argv: ['sandbox', 'vm', 'status'] };
+        }
+        if (SANDBOX_READ.has(subcommand)) {
+            return { kind: 'ai', role: 'read', argv: ['sandbox', taskSubcommand(subcommand), ...rest] };
+        }
+        if (SANDBOX_WRITE.has(subcommand)) {
+            return { kind: 'ai', role: 'write', argv: ['sandbox', subcommand, ...rest] };
+        }
+        if (subcommand === 'rm') {
+            return {
+                kind: 'error',
+                message: '/sandbox rm is not available from IM because it requires interactive confirmation'
+            };
+        }
+        return { kind: 'error', message: 'Unknown /sandbox command' };
+    }
+    if (command === '/run') {
+        const spec = getSkillRunSpec(subcommand);
+        if (!spec)
+            return { kind: 'error', message: `Unknown skill: ${subcommand}` };
+        return { kind: 'ai', role: spec.role, argv: ['run', subcommand, ...rest] };
+    }
+    return { kind: 'error', message: `Unknown command: ${command}` };
+}
+//# sourceMappingURL=protocol.js.map

package/dist/lib/server/redact.js

@@ -0,0 +1,12 @@
+const SECRET_PATTERNS = [
+    /\b(token|secret|password|passwd|api[_-]?key)=([^\s]+)/gi,
+    /\b(Bearer\s+)[A-Za-z0-9._~+/=-]+/g
+];
+export function redactSecrets(text) {
+    let out = text;
+    for (const pattern of SECRET_PATTERNS) {
+        out = out.replace(pattern, (_match, prefix) => `${prefix}=<redacted>`);
+    }
+    return out;
+}
+//# sourceMappingURL=redact.js.map

package/dist/lib/server/runner.js

@@ -0,0 +1,75 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+function resolveCommand(file) {
+    if (process.platform !== 'win32' || path.extname(file)) {
+        return file;
+    }
+    const pathValue = process.env.Path || process.env.PATH || '';
+    const extensions = (process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD').split(';').filter(Boolean);
+    for (const dir of pathValue.split(path.delimiter).filter(Boolean)) {
+        for (const extension of extensions) {
+            const lowerCandidate = path.join(dir, `${file}${extension.toLowerCase()}`);
+            if (fs.existsSync(lowerCandidate))
+                return lowerCandidate;
+            const upperCandidate = path.join(dir, `${file}${extension.toUpperCase()}`);
+            if (fs.existsSync(upperCandidate))
+                return upperCandidate;
+        }
+    }
+    return file;
+}
+function needsShell(file) {
+    return process.platform === 'win32' && /\.(?:bat|cmd)$/i.test(file);
+}
+function spawnCapture(file, args, onChunk) {
+    return new Promise((resolve, reject) => {
+        const resolvedFile = resolveCommand(file);
+        const child = spawn(resolvedFile, args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell: needsShell(resolvedFile)
+        });
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        let pendingChunks = Promise.resolve();
+        const rejectOnce = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            reject(error);
+        };
+        const resolveOnce = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(result);
+        };
+        const enqueueChunk = (chunk) => {
+            if (!onChunk)
+                return;
+            pendingChunks = pendingChunks.then(() => onChunk(chunk));
+            pendingChunks.catch(rejectOnce);
+        };
+        child.stdout.setEncoding('utf8');
+        child.stderr.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk;
+            enqueueChunk(chunk);
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk;
+            enqueueChunk(chunk);
+        });
+        child.on('error', rejectOnce);
+        child.on('close', (exitCode, signal) => {
+            pendingChunks
+                .then(() => resolveOnce({ exitCode, signal, stdout, stderr }))
+                .catch(rejectOnce);
+        });
+    });
+}
+export async function runAi(args, options = {}) {
+    return (options.spawn ?? spawnCapture)('ai', args, options.onChunk);
+}
+//# sourceMappingURL=runner.js.map

package/dist/lib/server/streamer.js

@@ -0,0 +1,44 @@
+import { redactSecrets } from "./redact.js";
+function chunks(text, size) {
+    if (text.length === 0)
+        return [];
+    const out = [];
+    for (let i = 0; i < text.length; i += size) {
+        out.push(text.slice(i, i + size));
+    }
+    return out;
+}
+export async function streamCommand(options, run, send) {
+    await send(`started ${options.title}`);
+    const size = options.chunkChars ?? 4000;
+    const throttleMs = options.throttleMs ?? 0;
+    let streamed = false;
+    let buffer = '';
+    let lastFlush = 0;
+    const flush = async () => {
+        if (!buffer)
+            return;
+        const text = redactSecrets(buffer);
+        buffer = '';
+        lastFlush = Date.now();
+        for (const chunk of chunks(text, size)) {
+            await send(chunk);
+        }
+    };
+    const emit = async (chunk) => {
+        streamed = true;
+        buffer += chunk;
+        const due = throttleMs === 0 || Date.now() - lastFlush >= throttleMs;
+        if (buffer.length >= size || due) {
+            await flush();
+        }
+    };
+    const result = await run(emit);
+    if (!streamed) {
+        buffer += [result.stdout, result.stderr].filter(Boolean).join('\n');
+    }
+    await flush();
+    await send(`finished ${options.title} exitCode=${result.exitCode} signal=${result.signal ?? 'null'}`);
+    return result;
+}
+//# sourceMappingURL=streamer.js.map