@thegitai/cli 1.0.0-beta.2 → 1.0.0-beta.21

package/dist/src/background-jobs.js

@@ -0,0 +1,410 @@
+import chalk from './colors.js';
+import { spawn } from 'child_process';
+import { buildCommandEnv, commandUsesSudo, sanitizeCommandText, terminateChild, } from './executor.js';
+import { isTuiMode } from './runtime-mode.js';
+import { redactConnectionStringCredentials } from './secret-preview.js';
+const MAX_RUNNING_JOBS = 8;
+const MAX_FINISHED_JOBS = 20;
+const MAX_JOB_BUFFER_CHARS = 200 * 1024;
+export const DEFAULT_STARTUP_WAIT_MS = 5000;
+export const MAX_JOB_WAIT_MS = 30_000;
+const KILL_ESCALATION_MS = 2000;
+const jobs = new Map();
+let jobCounter = 0;
+let activeSessionId = null;
+let updateHook = null;
+let exitCleanupRegistered = false;
+let pendingModelNotifications = [];
+export function setBackgroundJobUpdateHook(hook) {
+    updateHook = hook;
+}
+function normalizeSessionId(sessionId) {
+    return String(sessionId ?? activeSessionId ?? 'default').trim() || 'default';
+}
+function sessionFilter(sessionId) {
+    const value = String(sessionId ?? activeSessionId ?? '').trim();
+    return value || null;
+}
+function belongsToSession(record, sessionId) {
+    const filter = sessionFilter(sessionId);
+    return !filter || record.sessionId === filter;
+}
+export function setBackgroundJobSession(sessionId) {
+    const next = String(sessionId ?? '').trim() || null;
+    if (activeSessionId && activeSessionId !== next) {
+        killAllBackgroundJobs({ sessionId: activeSessionId, remove: true });
+        pendingModelNotifications = pendingModelNotifications.filter((snapshot) => snapshot.sessionId === next);
+    }
+    activeSessionId = next;
+}
+function snapshotOf(record) {
+    return {
+        id: record.id,
+        sessionId: record.sessionId,
+        command: record.command,
+        status: record.status,
+        pid: record.child.pid ?? null,
+        exitCode: record.exitCode,
+        signal: record.signal,
+        startedAt: record.startedAt,
+        endedAt: record.endedAt,
+    };
+}
+function notifyUpdate(record) {
+    if (!belongsToSession(record))
+        return;
+    try {
+        updateHook?.(snapshotOf(record));
+    }
+    catch { }
+}
+function logJobStatus(record) {
+    if (isTuiMode())
+        return;
+    if (record.status === 'running') {
+        console.log(chalk.cyan(`\n  ⚙ Background job ${record.id} started: ${record.command}`));
+        return;
+    }
+    if (record.status === 'killed') {
+        console.log(chalk.dim(`\n  ■ Background job ${record.id} killed.`));
+        return;
+    }
+    if (record.status === 'error') {
+        console.log(chalk.red(`\n  ✖ Background job ${record.id} failed to run.`));
+        return;
+    }
+    const color = record.exitCode === 0 ? chalk.green : chalk.red;
+    console.log(color(`\n  ${record.exitCode === 0 ? '✓' : '✖'} Background job ${record.id} exited with code ${record.exitCode ?? 1}`));
+}
+function appendJobOutput(record, chunk) {
+    if (!chunk)
+        return;
+    if (record.firstOutputLine == null) {
+        record.firstOutputFragment = `${record.firstOutputFragment}${chunk}`.slice(0, 8000);
+        const firstLine = record.firstOutputFragment
+            .split(/\r?\n/)
+            .find((line) => line.trim().length > 0);
+        if (firstLine) {
+            record.firstOutputLine = firstLine;
+        }
+    }
+    record.totalCaptured += chunk.length;
+    record.buffer += chunk;
+    if (record.buffer.length > MAX_JOB_BUFFER_CHARS) {
+        record.buffer = record.buffer.slice(record.buffer.length - MAX_JOB_BUFFER_CHARS);
+    }
+    const waiters = record.outputWaiters;
+    record.outputWaiters = [];
+    for (const waiter of waiters)
+        waiter();
+}
+function settleJob(record, status, exitCode, signal) {
+    if (record.status !== 'running')
+        return;
+    record.status = status;
+    record.exitCode = exitCode;
+    record.signal = signal;
+    record.endedAt = Date.now();
+    const waiters = [...record.exitWaiters, ...record.outputWaiters];
+    record.exitWaiters = [];
+    record.outputWaiters = [];
+    for (const waiter of waiters)
+        waiter();
+    if (jobs.has(record.id) && belongsToSession(record)) {
+        pendingModelNotifications.push(snapshotOf(record));
+    }
+    logJobStatus(record);
+    if (status === 'killed' || record.removeOnSettle) {
+        jobs.delete(record.id);
+    }
+    else {
+        pruneFinishedJobs();
+    }
+    notifyUpdate(record);
+}
+function pruneFinishedJobs() {
+    const finished = [...jobs.values()].filter((record) => record.status !== 'running');
+    if (finished.length <= MAX_FINISHED_JOBS)
+        return;
+    finished.sort((a, b) => (a.endedAt ?? 0) - (b.endedAt ?? 0));
+    for (const record of finished.slice(0, finished.length - MAX_FINISHED_JOBS)) {
+        jobs.delete(record.id);
+    }
+}
+function registerExitCleanup() {
+    if (exitCleanupRegistered)
+        return;
+    exitCleanupRegistered = true;
+    process.on('exit', () => {
+        for (const record of jobs.values()) {
+            if (record.status !== 'running')
+                continue;
+            terminateChild(record.child, 'SIGKILL');
+        }
+    });
+}
+function sanitizeJobText(record, raw) {
+    return redactConnectionStringCredentials(sanitizeCommandText(record.command, raw, record.cwd));
+}
+function readNewOutput(record) {
+    const dropped = record.totalCaptured - record.buffer.length;
+    const droppedUnread = Math.max(dropped - record.readOffset, 0);
+    const start = Math.max(record.readOffset - dropped, 0);
+    const raw = record.buffer.slice(start);
+    record.readOffset = record.totalCaptured;
+    return {
+        newOutput: sanitizeJobText(record, raw),
+        droppedChars: droppedUnread,
+    };
+}
+function waitForJobEvent(record, waitMs, kind) {
+    if (record.status !== 'running' || waitMs <= 0)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const waiters = kind === 'exit' ? record.exitWaiters : record.outputWaiters;
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            const index = waiters.indexOf(finish);
+            if (index !== -1)
+                waiters.splice(index, 1);
+            resolve();
+        };
+        const timer = setTimeout(finish, Math.min(waitMs, MAX_JOB_WAIT_MS));
+        timer.unref?.();
+        waiters.push(finish);
+    });
+}
+export async function startBackgroundJob(command, cwd, { startupWaitMs, sessionId, } = {}) {
+    if (commandUsesSudo(command)) {
+        return {
+            ok: false,
+            error: 'sudo commands cannot run as background jobs because the password prompt is interactive. Run it in the foreground instead.',
+        };
+    }
+    const running = [...jobs.values()].filter((record) => record.status === 'running' && belongsToSession(record, sessionId));
+    if (running.length >= MAX_RUNNING_JOBS) {
+        return {
+            ok: false,
+            error: `Too many background jobs are already running (${running.length}). Kill one with shell_job_kill first.`,
+        };
+    }
+    registerExitCleanup();
+    const id = `bg_${++jobCounter}`;
+    const child = spawn(command, {
+        cwd,
+        shell: true,
+        detached: process.platform !== 'win32',
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: buildCommandEnv(cwd),
+    });
+    child.stdin?.end();
+    const record = {
+        id,
+        sessionId: normalizeSessionId(sessionId),
+        command,
+        cwd,
+        child,
+        status: 'running',
+        exitCode: null,
+        signal: null,
+        startedAt: Date.now(),
+        endedAt: null,
+        buffer: '',
+        totalCaptured: 0,
+        readOffset: 0,
+        firstOutputLine: null,
+        firstOutputFragment: '',
+        killRequested: false,
+        removeOnSettle: false,
+        exitWaiters: [],
+        outputWaiters: [],
+    };
+    jobs.set(id, record);
+    child.stdout?.on('data', (chunk) => {
+        appendJobOutput(record, chunk.toString('utf-8'));
+    });
+    child.stderr?.on('data', (chunk) => {
+        appendJobOutput(record, chunk.toString('utf-8'));
+    });
+    child.on('error', (error) => {
+        appendJobOutput(record, error.message ? `${error.message}\n` : '');
+        terminateChild(child, 'SIGKILL');
+        settleJob(record, 'error', 1, null);
+    });
+    child.on('close', (code, signal) => {
+        settleJob(record, record.killRequested ? 'killed' : 'exited', code ?? (signal ? 1 : 0), signal);
+    });
+    logJobStatus(record);
+    notifyUpdate(record);
+    const waitMs = Math.min(Math.max(startupWaitMs ?? DEFAULT_STARTUP_WAIT_MS, 0), MAX_JOB_WAIT_MS);
+    await waitForJobEvent(record, waitMs, 'exit');
+    const { newOutput, droppedChars } = readNewOutput(record);
+    return {
+        ok: true,
+        snapshot: snapshotOf(record),
+        startupOutput: newOutput,
+        droppedChars,
+    };
+}
+export function getBackgroundJob(id, { sessionId } = {}) {
+    const record = jobs.get(String(id ?? '').trim());
+    return record && belongsToSession(record, sessionId) ? snapshotOf(record) : null;
+}
+export function listBackgroundJobs({ sessionId, } = {}) {
+    return [...jobs.values()]
+        .filter((record) => belongsToSession(record, sessionId))
+        .sort((a, b) => a.startedAt - b.startedAt)
+        .map(snapshotOf);
+}
+export function getJobOutputTail(id, maxLines) {
+    const record = jobs.get(String(id ?? '').trim());
+    if (!record || !belongsToSession(record) || maxLines <= 0)
+        return [];
+    const lines = sanitizeJobText(record, record.buffer)
+        .split('\n')
+        .filter((line) => line.trim().length > 0);
+    return lines.slice(-maxLines);
+}
+export function getJobOutputPreview(id, maxTailLines) {
+    const record = jobs.get(String(id ?? '').trim());
+    if (!record || !belongsToSession(record))
+        return null;
+    const firstLine = record.firstOutputLine
+        ? sanitizeJobText(record, record.firstOutputLine).trim()
+        : '';
+    return {
+        firstLine,
+        tailLines: getJobOutputTail(id, maxTailLines),
+    };
+}
+export function getJobBufferedOutput(id) {
+    const record = jobs.get(String(id ?? '').trim());
+    if (!record || !belongsToSession(record))
+        return null;
+    return {
+        output: sanitizeJobText(record, record.buffer),
+        droppedChars: Math.max(record.totalCaptured - record.buffer.length, 0),
+    };
+}
+export async function readBackgroundJobOutput(id, { waitMs, sessionId } = {}) {
+    const record = jobs.get(String(id ?? '').trim());
+    if (!record || !belongsToSession(record, sessionId)) {
+        return { ok: false, error: unknownJobError(id) };
+    }
+    if (waitMs && waitMs > 0 && record.status === 'running') {
+        const hasUnread = record.totalCaptured > record.readOffset;
+        if (!hasUnread)
+            await waitForJobEvent(record, waitMs, 'output');
+    }
+    const { newOutput, droppedChars } = readNewOutput(record);
+    return { ok: true, snapshot: snapshotOf(record), newOutput, droppedChars };
+}
+export async function killBackgroundJob(id, { waitMs = 5000, sessionId, } = {}) {
+    const record = jobs.get(String(id ?? '').trim());
+    if (!record || !belongsToSession(record, sessionId)) {
+        return { ok: false, error: unknownJobError(id) };
+    }
+    if (record.status !== 'running') {
+        const { newOutput, droppedChars } = readNewOutput(record);
+        const snapshot = snapshotOf(record);
+        if (record.status === 'killed') {
+            jobs.delete(record.id);
+        }
+        return {
+            ok: true,
+            alreadyFinished: true,
+            snapshot,
+            finalOutput: newOutput,
+            droppedChars,
+        };
+    }
+    record.killRequested = true;
+    terminateChild(record.child, 'SIGTERM');
+    const killTimer = setTimeout(() => {
+        if (record.status === 'running') {
+            terminateChild(record.child, 'SIGKILL');
+        }
+    }, KILL_ESCALATION_MS);
+    killTimer.unref?.();
+    await waitForJobEvent(record, Math.max(waitMs, KILL_ESCALATION_MS + 1000), 'exit');
+    clearTimeout(killTimer);
+    const { newOutput, droppedChars } = readNewOutput(record);
+    return {
+        ok: true,
+        snapshot: snapshotOf(record),
+        finalOutput: newOutput,
+        droppedChars,
+    };
+}
+export function killAllBackgroundJobs({ sessionId, remove = false, } = {}) {
+    for (const record of jobs.values()) {
+        if (!belongsToSession(record, sessionId))
+            continue;
+        if (record.status !== 'running')
+            continue;
+        record.killRequested = true;
+        record.removeOnSettle = record.removeOnSettle || remove;
+        terminateChild(record.child, 'SIGTERM');
+        const killTimer = setTimeout(() => {
+            if (record.status === 'running') {
+                terminateChild(record.child, 'SIGKILL');
+            }
+        }, KILL_ESCALATION_MS);
+        killTimer.unref?.();
+    }
+}
+export function hasRunningBackgroundJobs({ sessionId, } = {}) {
+    for (const record of jobs.values()) {
+        if (!belongsToSession(record, sessionId))
+            continue;
+        if (record.status === 'running')
+            return true;
+    }
+    return false;
+}
+function formatRunTime(snapshot) {
+    const ms = (snapshot.endedAt ?? Date.now()) - snapshot.startedAt;
+    const totalSeconds = Math.max(0, Math.floor(ms / 1000));
+    if (totalSeconds < 60)
+        return `${totalSeconds}s`;
+    const minutes = Math.floor(totalSeconds / 60);
+    if (minutes < 60)
+        return `${minutes}m${String(totalSeconds % 60).padStart(2, '0')}s`;
+    return `${Math.floor(minutes / 60)}h${String(minutes % 60).padStart(2, '0')}m`;
+}
+export function drainBackgroundJobNotifications({ sessionId } = {}) {
+    if (pendingModelNotifications.length === 0)
+        return null;
+    const filter = sessionFilter(sessionId);
+    const pending = filter
+        ? pendingModelNotifications.filter((snapshot) => snapshot.sessionId === filter)
+        : pendingModelNotifications;
+    pendingModelNotifications = filter
+        ? pendingModelNotifications.filter((snapshot) => snapshot.sessionId !== filter)
+        : [];
+    if (pending.length === 0)
+        return null;
+    const lines = pending.map((snapshot) => {
+        const ran = formatRunTime(snapshot);
+        if (snapshot.status === 'error') {
+            return `Background job ${snapshot.id} (${snapshot.command}) failed to start.`;
+        }
+        if (snapshot.status === 'killed') {
+            return `Background job ${snapshot.id} (${snapshot.command}) was killed after ${ran}.`;
+        }
+        return `Background job ${snapshot.id} (${snapshot.command}) exited with code ${snapshot.exitCode ?? 1} after ${ran}.`;
+    });
+    const hasReadableFinalOutput = pending.some((snapshot) => snapshot.status !== 'killed');
+    return `${lines.join(' ')}${hasReadableFinalOutput ? ' Use shell_job_output to read any final output.' : ''}`;
+}
+function unknownJobError(id) {
+    const known = listBackgroundJobs().map((job) => job.id);
+    const hint = known.length
+        ? ` Known jobs: ${known.join(', ')}.`
+        : ' No background jobs have been started this session.';
+    return `Unknown background job id: ${String(id ?? '').trim() || '(empty)'}.${hint}`;
+}

package/dist/src/cli-args.js

@@ -0,0 +1,60 @@
+export const AUTH_COMMANDS = new Set(['login', 'whoami', 'logout']);
+export function parseArgs(argv) {
+    const args = argv.slice(2);
+    const firstArg = args[0];
+    const command = firstArg && AUTH_COMMANDS.has(firstArg) ? firstArg : null;
+    const commandArgs = command ? args.slice(1) : [];
+    let autoYes = false;
+    let help = false;
+    let version = false;
+    let usage = false;
+    let session = null;
+    let listSessions = false;
+    let unknownOption = null;
+    const promptParts = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--yes' || arg === '-y') {
+            autoYes = true;
+            continue;
+        }
+        if ((arg === '--session' || arg === '--resume') && i + 1 < args.length) {
+            session = args[i + 1] ?? null;
+            i += 1;
+            continue;
+        }
+        if (arg === '--list-sessions') {
+            listSessions = true;
+            continue;
+        }
+        if (arg === '--help' || arg === '-h') {
+            help = true;
+            continue;
+        }
+        if (arg === '--version' || arg === '-v') {
+            version = true;
+            continue;
+        }
+        if (arg === '--usage') {
+            usage = true;
+            continue;
+        }
+        if (command === null && unknownOption === null && /^-/.test(arg)) {
+            unknownOption = arg;
+            continue;
+        }
+        promptParts.push(arg);
+    }
+    return {
+        command,
+        commandArgs,
+        autoYes,
+        help,
+        version,
+        usage,
+        session,
+        listSessions,
+        unknownOption,
+        prompt: promptParts.join(' ').trim(),
+    };
+}

package/dist/src/client-environment.js

@@ -0,0 +1,129 @@
+import { accessSync, constants, readFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { ensureSessionScratchDir } from './scratch-dir.js';
+const PACKAGE_MANAGER_CANDIDATES = [
+    'apt',
+    'apt-get',
+    'dnf',
+    'yum',
+    'pacman',
+    'zypper',
+    'apk',
+    'brew',
+    'nix',
+    'snap',
+    'flatpak',
+    'winget',
+    'choco',
+    'scoop',
+];
+function detectShell(platform, env) {
+    if (platform === 'win32') {
+        const comspec = env.COMSPEC;
+        return comspec ? path.win32.basename(comspec) : 'unknown';
+    }
+    const shell = env.SHELL;
+    return shell ? path.basename(shell) : 'unknown';
+}
+function unquoteOsReleaseValue(value) {
+    const trimmed = value.trim();
+    if (trimmed.length < 2)
+        return trimmed;
+    const quote = trimmed[0];
+    if ((quote !== '"' && quote !== "'") || trimmed.at(-1) !== quote) {
+        return trimmed;
+    }
+    return trimmed
+        .slice(1, -1)
+        .replace(/\\(["'`$\\])/g, '$1')
+        .trim();
+}
+export function parseLinuxOsRelease(text) {
+    const values = {};
+    for (const line of text.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const index = trimmed.indexOf('=');
+        if (index <= 0)
+            continue;
+        const key = trimmed.slice(0, index);
+        const value = unquoteOsReleaseValue(trimmed.slice(index + 1));
+        values[key] = value;
+    }
+    return {
+        distroId: values.ID,
+        distroName: values.PRETTY_NAME ?? values.NAME,
+        distroVersion: values.VERSION_ID ?? values.VERSION,
+    };
+}
+function readLinuxOsReleaseText(options) {
+    if ('osReleaseText' in options) {
+        return options.osReleaseText ?? '';
+    }
+    try {
+        return readFileSync('/etc/os-release', 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+function pathEnv(env) {
+    return env.PATH ?? env.Path ?? env.path ?? '';
+}
+function windowsExecutableNames(command, env) {
+    if (path.extname(command))
+        return [command];
+    const extensions = (env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD')
+        .split(';')
+        .map((extension) => extension.trim())
+        .filter(Boolean);
+    return [command, ...extensions.map((extension) => `${command}${extension}`)];
+}
+function defaultExecutableExists(command, env, platform) {
+    const searchPath = pathEnv(env);
+    if (!searchPath)
+        return false;
+    const names = platform === 'win32' ? windowsExecutableNames(command, env) : [command];
+    for (const dir of searchPath.split(path.delimiter)) {
+        if (!dir.trim())
+            continue;
+        for (const name of names) {
+            try {
+                accessSync(path.join(dir, name), constants.X_OK);
+                return true;
+            }
+            catch {
+                try {
+                    accessSync(path.join(dir, name));
+                    return platform === 'win32';
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+    }
+    return false;
+}
+function detectPackageManagers(env, platform, executableExists) {
+    return PACKAGE_MANAGER_CANDIDATES.filter((command) => executableExists(command, env, platform));
+}
+export function collectClientEnvironment(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const env = options.env ?? process.env;
+    const executableExists = options.executableExists ?? defaultExecutableExists;
+    const linuxDistro = platform === 'linux'
+        ? parseLinuxOsRelease(readLinuxOsReleaseText(options))
+        : {};
+    return {
+        platform,
+        arch: options.arch ?? process.arch,
+        release: options.release ?? os.release(),
+        shell: detectShell(platform, env),
+        ...linuxDistro,
+        packageManagers: detectPackageManagers(env, platform, executableExists),
+        scratchDir: options.scratchDir ?? ensureSessionScratchDir(),
+    };
+}

package/dist/src/colors.js

@@ -0,0 +1,50 @@
+const STYLE_NAMES = ['bold', 'dim', 'red', 'green', 'yellow', 'cyan'];
+const OPEN = {
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+};
+const CLOSE = {
+    bold: '\x1b[22m',
+    dim: '\x1b[22m',
+    red: '\x1b[39m',
+    green: '\x1b[39m',
+    yellow: '\x1b[39m',
+    cyan: '\x1b[39m',
+};
+function colorEnabled() {
+    const force = process.env.FORCE_COLOR;
+    if (force !== undefined)
+        return force !== '0' && force !== 'false';
+    if (process.env.NO_COLOR !== undefined && process.env.NO_COLOR !== '') {
+        return false;
+    }
+    return Boolean(process.stdout.isTTY);
+}
+function applyStyle(name, text) {
+    const open = OPEN[name];
+    const close = CLOSE[name];
+    const body = text.includes(close) ? text.split(close).join(close + open) : text;
+    return open + body + close;
+}
+function createStyler(styles) {
+    const fn = ((text) => {
+        const value = String(text);
+        if (!colorEnabled() || styles.length === 0)
+            return value;
+        return styles.reduceRight((acc, name) => applyStyle(name, acc), value);
+    });
+    for (const name of STYLE_NAMES) {
+        Object.defineProperty(fn, name, {
+            configurable: true,
+            enumerable: false,
+            get: () => createStyler([...styles, name]),
+        });
+    }
+    return fn;
+}
+const colors = createStyler([]);
+export default colors;