sublera-cli 0.0.0-stage → 1.3.0

package/dist/ui/terminalDashboard.js

@@ -0,0 +1,295 @@
+import { formatClock, formatPercent, formatSpeed, formatUsdNanos, modelShortName, padRight, stripAnsi, truncate } from '../util/format.js';
+import { BRAND, VERSION } from '../version.js';
+export function initialState(server) {
+    return {
+        status: 'starting',
+        username: null,
+        endpoint: null,
+        server,
+        reliability: null,
+        held: false,
+        gpuName: null,
+        totalVramMb: 0,
+        freeVramMb: 0,
+        gpuTempC: null,
+        gpuPowerW: null,
+        gpuUtilPct: null,
+        wakeLock: false,
+        llamaStatus: 'not started',
+        job: null,
+        bookings: [],
+        liveTokPerSec: null,
+        sessionEarnedNanos: 0,
+        sessionGuaranteedNanos: 0,
+        tokenEarnedNanos: 0,
+        publicMode: false,
+        priceOutUsd: null,
+        priceHourUsd: null,
+        walletNanos: null,
+        lastHeartbeatAt: null,
+        message: null,
+        showLogs: false,
+        logTail: [],
+        keyHint: null,
+    };
+}
+function statusLabel(state) {
+    if (state.status === 'auth-failed')
+        return { text: 'AUTH FAILED', status: state.status };
+    if (state.status === 'outdated')
+        return { text: 'UPDATE NEEDED', status: state.status };
+    if (state.status === 'reconnecting')
+        return { text: 'RECONNECTING', status: state.status };
+    if (state.status === 'paused')
+        return { text: 'HELD', status: state.status };
+    if (state.status === 'offline')
+        return { text: 'OFFLINE', status: state.status };
+    if (state.status === 'working')
+        return { text: 'WORKING', status: state.status };
+    if (state.status === 'starting')
+        return { text: 'STARTING', status: state.status };
+    return { text: 'ONLINE', status: state.status };
+}
+function valueOrDash(value) {
+    return value && value.trim() ? value : '-';
+}
+function gpuLine(state) {
+    if (!state.gpuName)
+        return 'No GPU detected (use --gpu / --vram for a test node)';
+    const total = state.totalVramMb > 0 ? `${(state.totalVramMb / 1024).toFixed(1)} GB` : '? GB';
+    const free = state.freeVramMb > 0 ? `${(state.freeVramMb / 1024).toFixed(1)} GB` : '? GB';
+    const util = state.gpuUtilPct != null ? ` · ${state.gpuUtilPct.toFixed(0)}% util` : '';
+    return `${state.gpuName} (${free} free / ${total})${util}`;
+}
+function thermalLine(state) {
+    const temp = state.gpuTempC != null ? `${state.gpuTempC.toFixed(0)}°C` : 'temp n/a';
+    const power = state.gpuPowerW != null ? `${state.gpuPowerW.toFixed(0)}W` : 'power n/a';
+    const lock = state.wakeLock ? 'Wake-Lock: ACTIVE - sleep blocked' : 'Wake-Lock: idle';
+    return `${temp} · ${power} · ${lock}`;
+}
+function tokS(value) {
+    return Number.isInteger(value) ? String(value) : value.toFixed(1);
+}
+/** A positive finite number, or null: a broken value never prints as NaN (or throws in toFixed). */
+function positive(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : null;
+}
+/** "50 tok/s" for a speed seat, "full GPU" for an exclusive rental. */
+export function rentalLabel(job) {
+    const speed = positive(job.tokS);
+    if (speed)
+        return `${tokS(speed)} tok/s`;
+    return job.shared ? 'shared seat' : 'full GPU';
+}
+/** "2 rentals: 50 tok/s + full GPU"; with more than three, "4 rentals, 150 tok/s reserved". */
+export function rentalsSummary(rentals) {
+    if (rentals.length <= 3)
+        return `${rentals.length} rental${rentals.length === 1 ? '' : 's'}: ${rentals.map(rentalLabel).join(' + ')}`;
+    const reserved = rentals.reduce((sum, job) => sum + (positive(job.tokS) ?? 0), 0);
+    const full = rentals.some((job) => !positive(job.tokS) && !job.shared) ? ' + full GPU' : '';
+    return `${rentals.length} rentals, ${tokS(reserved)} tok/s reserved${full}`;
+}
+function jobLine(state) {
+    const job = state.job;
+    const rentals = state.bookings ?? [];
+    const single = rentals[0];
+    // One full-GPU rental keeps the classic label; seats, several rentals, or public selling list every rental.
+    if (rentals.length > 1 || (single && (state.publicMode || single.tokS || single.shared))) {
+        const loading = job?.kind === 'request' && job.id && !rentals.some((rental) => rental.id === job.id) ? ' + 1 loading' : '';
+        return `${state.publicMode ? 'Per-token + ' : ''}${rentalsSummary(rentals)}${loading}`;
+    }
+    if (!job)
+        return 'Standby - waiting for a web request';
+    if (job.kind === 'public')
+        return `Public pay-per-token${job.model ? ` · ${modelShortName(job.model)}` : ''}`;
+    if (job.id?.startsWith('bench_'))
+        return 'Benchmark: measuring this GPU (no buyer)';
+    return `Dedicated Buyer Request${job.id ? ` (#${job.id.replace(/^req_/, '').slice(0, 12)})` : ''}`;
+}
+function pricesLine(state) {
+    if (!state.publicMode || state.priceOutUsd == null)
+        return null;
+    const hourly = state.priceHourUsd && state.priceHourUsd > 0 ? `$${state.priceHourUsd.toFixed(2)}/h full GPU` : 'no hourly rentals';
+    return `$${state.priceOutUsd.toFixed(2)} per 1M tokens · ${hourly}`;
+}
+function modelLine(state) {
+    const model = state.job?.model || null;
+    if (!model)
+        return state.llamaStatus === 'ready' ? 'llama-server ready' : state.llamaStatus;
+    const mark = state.job?.verified ? ' ✓ verified' : '';
+    return `${modelShortName(model)}${mark}`;
+}
+function timerLine(state) {
+    // With several rentals, show the one that ends first.
+    const timed = (state.bookings ?? []).filter((rental) => rental.timerEndsAt)
+        .sort((a, b) => (a.timerEndsAt ?? 0) - (b.timerEndsAt ?? 0));
+    const job = timed[0] ?? state.job;
+    if (!job?.timerEndsAt)
+        return job?.kind === 'request' ? 'Timer starts after the model is verified' : '-';
+    const remaining = Math.max(0, Math.floor((job.timerEndsAt - Date.now()) / 1000));
+    const total = job.hours ? Math.round(job.hours * 3600) : Math.max(remaining, 1);
+    return `${formatClock(remaining)} / ${formatClock(total)}${timed.length > 1 ? ` · first of ${timed.length} to end` : ''}`;
+}
+function speedLine(state) {
+    const speed = formatSpeed(state.liveTokPerSec);
+    const reserved = (state.bookings ?? []).reduce((sum, job) => sum + (positive(job.tokS) ?? 0), 0);
+    if (reserved > 0)
+        return `${speed} (${tokS(reserved)} tok/s reserved by seats)`;
+    const minTokS = positive(state.job?.minTokS);
+    const min = minTokS ? ` (min required: ${minTokS.toFixed(1)} tok/s${state.liveTokPerSec != null && state.liveTokPerSec >= minTokS ? ' ✓' : ' !'})` : '';
+    return `${speed}${min}`;
+}
+function earningsLine(state) {
+    const guaranteed = state.bookings?.length ? state.sessionGuaranteedNanos : (state.job?.guaranteedNanos ?? state.sessionGuaranteedNanos);
+    const tokens = state.tokenEarnedNanos ?? 0;
+    const split = tokens > 0 && state.sessionEarnedNanos > tokens ? ` (${formatUsdNanos(tokens)} per-token)` : '';
+    return `${formatUsdNanos(state.sessionEarnedNanos)}${split}${guaranteed > 0 ? ` / ${formatUsdNanos(guaranteed)} Guaranteed` : ' this session'}`;
+}
+export function renderFrame(state, options = {}) {
+    const width = Math.max(54, options.width ?? 72);
+    const unicode = options.unicode ?? true;
+    const tl = unicode ? '┌' : '+';
+    const tr = unicode ? '┐' : '+';
+    const bl = unicode ? '└' : '+';
+    const br = unicode ? '┘' : '+';
+    const h = unicode ? '─' : '-';
+    const v = unicode ? '│' : '|';
+    const ml = unicode ? '├' : '+';
+    const mr = unicode ? '┤' : '+';
+    const status = statusLabel(state);
+    const dot = unicode ? '●' : '*';
+    const title = `${BRAND} GPU TERMINAL AGENT v${VERSION}`;
+    const statusText = `${dot} ${status.text}`;
+    const inner = width - 2;
+    const top = `${tl}${h.repeat(inner)}${tr}`;
+    const divider = `${ml}${h.repeat(inner)}${mr}`;
+    const bottom = `${bl}${h.repeat(inner)}${br}`;
+    const lines = [];
+    const add = (left, right = '') => {
+        const leftText = `  ${left}`;
+        const available = inner - 2;
+        const rightWidth = stripAnsi(right).length;
+        const clippedLeft = truncate(leftText, Math.max(0, available - rightWidth - 1));
+        const leftWidth = stripAnsi(clippedLeft).length;
+        const gap = Math.max(1, available - leftWidth - rightWidth);
+        const body = clippedLeft + ' '.repeat(gap) + right;
+        lines.push(`${v}${padRight(truncate(body, inner), inner)}${v}`);
+    };
+    const single = (text) => {
+        const body = `  ${text}`;
+        lines.push(`${v}${padRight(truncate(body, inner), inner)}${v}`);
+    };
+    lines.push(top);
+    add(`${title}`, `STATUS: ${statusText}`);
+    lines.push(divider);
+    add(`Host Endpoint : ${valueOrDash(state.endpoint)}`);
+    add(`Reliability   : ${state.reliability != null ? formatPercent(state.reliability) : '-'}${state.held ? '  (HELD - see your host page)' : state.reliability != null ? '  (OK - held only after repeated failures)' : ''}`);
+    add(`GPU Detected  : ${truncate(gpuLine(state), inner - 20)}`);
+    add(`GPU Temp/Power: ${thermalLine(state)}`);
+    lines.push(divider);
+    add(`CURRENT JOB   : ${jobLine(state)}`);
+    const prices = pricesLine(state);
+    if (prices)
+        add(`Prices        : ${prices}`);
+    add(`Model Loaded  : ${modelLine(state)}`);
+    add(`Time Remaining: ${timerLine(state)}`);
+    add(`Live Speed    : ${speedLine(state)}`);
+    lines.push(divider);
+    add(`Session Earn. : ${earningsLine(state)}`);
+    add(`Total Wallet  : ${state.walletNanos != null ? formatUsdNanos(state.walletNanos) : '-'}`);
+    add(`Server        : ${truncate(state.server, inner - 20)}`, state.lastHeartbeatAt ? `hb ${Math.max(0, Math.round((Date.now() - state.lastHeartbeatAt) / 1000))}s` : 'no heartbeat');
+    if (state.keyHint)
+        add(`Keys          : ${truncate(state.keyHint, inner - 20)}`);
+    if (state.showLogs && state.logTail?.length) {
+        for (const line of state.logTail.slice(-3))
+            single(`log  ${truncate(line, inner - 8)}`);
+    }
+    if (state.message)
+        add(`Note          : ${truncate(state.message, inner - 20)}`);
+    lines.push(bottom);
+    if (!options.color)
+        return lines.join('\n');
+    const paintStatus = (text) => {
+        const color = status.status === 'online' || status.status === 'working'
+            ? '\x1b[32m'
+            : status.status === 'starting' || status.status === 'reconnecting'
+                ? '\x1b[33m'
+                : '\x1b[31m';
+        return `${text.replace(statusText, `${color}${statusText}\x1b[0m`)}`;
+    };
+    return lines.map((line, index) => index === 1 ? paintStatus(line) : line).join('\n');
+}
+export class TerminalDashboard {
+    state;
+    stream;
+    color;
+    unicode;
+    intervalMs;
+    enabled;
+    timer = null;
+    started = false;
+    lastFrame = '';
+    lastStatus = null;
+    constructor(state, options = {}) {
+        this.state = state;
+        this.stream = options.stream ?? process.stdout;
+        this.color = options.color ?? Boolean(this.stream.isTTY);
+        this.unicode = options.unicode ?? true;
+        this.intervalMs = options.intervalMs ?? 1_000;
+        this.enabled = options.enabled ?? true;
+    }
+    get current() { return this.state; }
+    start() {
+        if (this.started || !this.enabled)
+            return;
+        this.started = true;
+        this.lastStatus = this.state.status;
+        if (!this.stream.isTTY) {
+            this.printOnce();
+            return;
+        }
+        this.stream.write('\x1b[?25l');
+        this.rerender(true);
+        this.timer = setInterval(() => this.rerender(false), this.intervalMs);
+    }
+    update(partial) {
+        this.state = { ...this.state, ...partial };
+        if (!this.started)
+            return;
+        if (!this.stream.isTTY) {
+            if (this.state.status !== this.lastStatus) {
+                this.lastStatus = this.state.status;
+                this.printOnce();
+            }
+            return;
+        }
+        this.rerender(false);
+    }
+    setJob(job) {
+        this.update({ job });
+    }
+    printOnce() {
+        this.stream.write(`${renderFrame(this.state, { color: this.color, unicode: this.unicode })}\n`);
+    }
+    rerender(force) {
+        const frame = renderFrame(this.state, { color: this.color, unicode: this.unicode });
+        if (!force && frame === this.lastFrame)
+            return;
+        this.lastFrame = frame;
+        if (force)
+            this.stream.write('\x1b[H\x1b[2J');
+        else
+            this.stream.write('\x1b[H');
+        this.stream.write(frame);
+        this.stream.write('\x1b[0J');
+    }
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+        if (this.stream.isTTY && this.started)
+            this.stream.write('\x1b[?25h\n');
+        this.started = false;
+    }
+}
+//# sourceMappingURL=terminalDashboard.js.map

package/dist/util/env.d.ts

@@ -0,0 +1,3 @@
+/** Prefer the Sublera spelling while retaining legacy deployment settings.
+ * An explicitly supplied new value wins, even when empty or invalid. */
+export declare function brandEnv(env: NodeJS.ProcessEnv, legacyKey: string): string | undefined;

package/dist/util/env.js

@@ -0,0 +1,6 @@
+/** Prefer the Sublera spelling while retaining legacy deployment settings.
+ * An explicitly supplied new value wins, even when empty or invalid. */
+export function brandEnv(env, legacyKey) {
+    return env[legacyKey.replace(/^SUBLET_/, 'SUBLERA_')] ?? env[legacyKey];
+}
+//# sourceMappingURL=env.js.map

package/dist/util/exec.d.ts

@@ -0,0 +1,23 @@
+import { type ChildProcess } from 'node:child_process';
+export type ExecResult = {
+    code: number | null;
+    stdout: string;
+    stderr: string;
+    timedOut: boolean;
+    error?: string;
+};
+export type ExecOptions = {
+    timeoutMs?: number;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    input?: string;
+    maxOutputBytes?: number;
+    windowsHide?: boolean;
+};
+export declare function toError(value: unknown): Error;
+export declare function sleep(ms: number): Promise<void>;
+export declare function execFile(command: string, args?: string[], options?: ExecOptions): Promise<ExecResult>;
+export declare function killTree(child: ChildProcess | null | undefined): Promise<void>;
+export declare function which(command: string): Promise<string | null>;
+export declare function commandExists(command: string): Promise<boolean>;
+export declare function commandLine(command: string, args: string[]): string;

package/dist/util/exec.js

@@ -0,0 +1,116 @@
+import { spawn } from 'node:child_process';
+import { access, constants } from 'node:fs/promises';
+import { delimiter, extname, join } from 'node:path';
+export function toError(value) {
+    return value instanceof Error ? value : new Error(String(value));
+}
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function execFile(command, args = [], options = {}) {
+    const timeoutMs = options.timeoutMs ?? 15_000;
+    const maxBytes = options.maxOutputBytes ?? 2 * 1024 * 1024;
+    const spawnOptions = {
+        cwd: options.cwd,
+        env: { ...process.env, ...options.env },
+        windowsHide: options.windowsHide ?? true,
+        stdio: ['pipe', 'pipe', 'pipe'],
+    };
+    return new Promise((resolve) => {
+        let child;
+        try {
+            child = spawn(command, args, spawnOptions);
+        }
+        catch (error) {
+            resolve({ code: null, stdout: '', stderr: '', timedOut: false, error: toError(error).message });
+            return;
+        }
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        let settled = false;
+        const finish = (code, error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({ code, stdout, stderr, timedOut, error });
+        };
+        const append = (current, chunk) => {
+            if (current.length >= maxBytes)
+                return current;
+            const next = current + chunk.toString('utf8');
+            return next.length > maxBytes ? next.slice(0, maxBytes) : next;
+        };
+        child.stdout?.on('data', (chunk) => { stdout = append(stdout, chunk); });
+        child.stderr?.on('data', (chunk) => { stderr = append(stderr, chunk); });
+        child.on('error', (err) => finish(null, err.message));
+        child.on('close', (code) => finish(code));
+        const timer = setTimeout(() => {
+            timedOut = true;
+            void killTree(child).finally(() => finish(null, `Command timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        if (options.input != null) {
+            child.stdin?.end(options.input);
+        }
+        else {
+            child.stdin?.end();
+        }
+    });
+}
+export async function killTree(child) {
+    if (!child || child.killed || child.exitCode != null)
+        return;
+    const pid = child.pid;
+    if (!pid)
+        return;
+    if (process.platform === 'win32') {
+        await execFile('taskkill', ['/pid', String(pid), '/T', '/F'], { timeoutMs: 10_000 });
+        return;
+    }
+    try {
+        process.kill(pid, 'SIGTERM');
+    }
+    catch {
+        return;
+    }
+    await sleep(800);
+    try {
+        process.kill(pid, 'SIGKILL');
+    }
+    catch {
+        /* already gone */
+    }
+}
+async function isExecutable(path) {
+    try {
+        await access(path, process.platform === 'win32' ? constants.F_OK : constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function which(command) {
+    const hasExt = extname(command) !== '';
+    const names = process.platform === 'win32' && !hasExt
+        ? [`${command}.exe`, `${command}.cmd`, `${command}.bat`, command]
+        : [command];
+    const dirs = (process.env.PATH || '').split(delimiter).filter(Boolean);
+    for (const dir of dirs) {
+        for (const name of names) {
+            const full = join(dir, name);
+            if (await isExecutable(full))
+                return full;
+        }
+    }
+    return null;
+}
+export async function commandExists(command) {
+    return (await which(command)) != null;
+}
+export function commandLine(command, args) {
+    const quote = (value) => /[\s"]/g.test(value) ? `"${value.replace(/"/g, '\\"')}"` : value;
+    return [command, ...args].map(quote).join(' ');
+}
+//# sourceMappingURL=exec.js.map

package/dist/util/format.d.ts

@@ -0,0 +1,47 @@
+declare const ANSI: {
+    readonly reset: "\u001B[0m";
+    readonly bold: "\u001B[1m";
+    readonly dim: "\u001B[2m";
+    readonly red: "\u001B[31m";
+    readonly green: "\u001B[32m";
+    readonly yellow: "\u001B[33m";
+    readonly blue: "\u001B[34m";
+    readonly magenta: "\u001B[35m";
+    readonly cyan: "\u001B[36m";
+    readonly white: "\u001B[37m";
+    readonly gray: "\u001B[90m";
+};
+export type ColorName = keyof typeof ANSI;
+export declare function colorEnabled(stream?: NodeJS.WriteStream, env?: NodeJS.ProcessEnv): boolean;
+export declare function paint(text: string, color: ColorName, enabled: boolean): string;
+export declare function bold(text: string, enabled: boolean): string;
+export declare function dim(text: string, enabled: boolean): string;
+export declare const ansi: {
+    readonly reset: "\u001B[0m";
+    readonly bold: "\u001B[1m";
+    readonly dim: "\u001B[2m";
+    readonly red: "\u001B[31m";
+    readonly green: "\u001B[32m";
+    readonly yellow: "\u001B[33m";
+    readonly blue: "\u001B[34m";
+    readonly magenta: "\u001B[35m";
+    readonly cyan: "\u001B[36m";
+    readonly white: "\u001B[37m";
+    readonly gray: "\u001B[90m";
+};
+export declare function formatBytes(bytes: number | null | undefined, digits?: number): string;
+export declare function formatBytesPerSec(bytes: number): string;
+export declare function formatDuration(totalSeconds: number | null | undefined): string;
+export declare function formatClock(totalSeconds: number | null | undefined): string;
+export declare function formatUsdNanos(nanos: number | null | undefined): string;
+export declare function formatUsd(value: number | null | undefined): string;
+export declare function formatSpeed(tps: number | null | undefined): string;
+export declare function formatPercent(value: number | null | undefined, digits?: number): string;
+export declare function formatNumber(value: number | null | undefined): string;
+export declare function truncate(text: string, max: number): string;
+export declare function padRight(text: string, width: number): string;
+export declare function padLeft(text: string, width: number): string;
+export declare function timeAgo(timestamp: number | null | undefined): string;
+export declare function modelShortName(fileOrId: string | null | undefined): string;
+export declare function stripAnsi(text: string): string;
+export {};

package/dist/util/format.js

@@ -0,0 +1,125 @@
+const ANSI = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    gray: '\x1b[90m',
+};
+export function colorEnabled(stream = process.stdout, env = process.env) {
+    if ('NO_COLOR' in env && env.NO_COLOR !== '')
+        return false;
+    if (env.FORCE_COLOR === '0')
+        return false;
+    if (env.FORCE_COLOR && env.FORCE_COLOR !== '0')
+        return true;
+    return Boolean(stream.isTTY);
+}
+export function paint(text, color, enabled) {
+    return enabled ? `${ANSI[color]}${text}${ANSI.reset}` : text;
+}
+export function bold(text, enabled) {
+    return enabled ? `${ANSI.bold}${text}${ANSI.reset}` : text;
+}
+export function dim(text, enabled) {
+    return enabled ? `${ANSI.dim}${text}${ANSI.reset}` : text;
+}
+export const ansi = ANSI;
+export function formatBytes(bytes, digits = 1) {
+    if (bytes == null || !Number.isFinite(bytes) || bytes < 0)
+        return '-';
+    if (bytes === 0)
+        return '0 B';
+    const units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB'];
+    const i = Math.min(units.length - 1, Math.floor(Math.log(bytes) / Math.log(1024)));
+    const value = bytes / 1024 ** i;
+    return `${value.toFixed(i === 0 ? 0 : digits)} ${units[i]}`;
+}
+export function formatBytesPerSec(bytes) {
+    return `${formatBytes(bytes, 1)}/s`;
+}
+export function formatDuration(totalSeconds) {
+    if (totalSeconds == null || !Number.isFinite(totalSeconds) || totalSeconds < 0)
+        return '-';
+    const s = Math.floor(totalSeconds % 60);
+    const m = Math.floor((totalSeconds / 60) % 60);
+    const h = Math.floor(totalSeconds / 3600);
+    if (h > 0)
+        return `${h}h ${String(m).padStart(2, '0')}m ${String(s).padStart(2, '0')}s`;
+    if (m > 0)
+        return `${m}m ${String(s).padStart(2, '0')}s`;
+    return `${s}s`;
+}
+export function formatClock(totalSeconds) {
+    if (totalSeconds == null || !Number.isFinite(totalSeconds) || totalSeconds < 0)
+        return '--:--:--';
+    const s = Math.floor(totalSeconds % 60);
+    const m = Math.floor((totalSeconds / 60) % 60);
+    const h = Math.floor(totalSeconds / 3600);
+    return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}:${String(s).padStart(2, '0')}`;
+}
+export function formatUsdNanos(nanos) {
+    if (nanos == null || !Number.isFinite(nanos))
+        return '$0.00';
+    return `$${(nanos / 1e9).toFixed(2)}`;
+}
+export function formatUsd(value) {
+    if (value == null || !Number.isFinite(value))
+        return '$0.00';
+    return `$${value.toFixed(2)}`;
+}
+export function formatSpeed(tps) {
+    if (tps == null || !Number.isFinite(tps) || tps <= 0)
+        return '-';
+    return `${tps.toFixed(1)} tok/s`;
+}
+export function formatPercent(value, digits = 1) {
+    if (value == null || !Number.isFinite(value))
+        return '-';
+    return `${value.toFixed(digits)}%`;
+}
+export function formatNumber(value) {
+    if (value == null || !Number.isFinite(value))
+        return '-';
+    return new Intl.NumberFormat('en-US').format(value);
+}
+export function truncate(text, max) {
+    if (text.length <= max)
+        return text;
+    return `${text.slice(0, Math.max(0, max - 1))}…`;
+}
+export function padRight(text, width) {
+    return text.length >= width ? text : text + ' '.repeat(width - text.length);
+}
+export function padLeft(text, width) {
+    return text.length >= width ? text : ' '.repeat(width - text.length) + text;
+}
+export function timeAgo(timestamp) {
+    if (!timestamp)
+        return 'never';
+    const seconds = Math.max(0, Math.round((Date.now() - timestamp) / 1000));
+    if (seconds < 5)
+        return 'just now';
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)}m ago`;
+    if (seconds < 86400)
+        return `${Math.floor(seconds / 3600)}h ago`;
+    return `${Math.floor(seconds / 86400)}d ago`;
+}
+export function modelShortName(fileOrId) {
+    if (!fileOrId)
+        return '-';
+    const base = fileOrId.split(/[\\/]/).pop() || fileOrId;
+    return base.replace(/\.gguf$/i, '');
+}
+export function stripAnsi(text) {
+    return text.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, '');
+}
+//# sourceMappingURL=format.js.map

package/dist/util/fs.d.ts

@@ -0,0 +1,18 @@
+import { type AgentConfig } from '../config.js';
+export declare function ensureDir(path: string, mode?: number): Promise<void>;
+export declare function pathExists(path: string): Promise<boolean>;
+export declare function fileSize(path: string): Promise<number>;
+export declare function removeIfExists(path: string): Promise<void>;
+/** Bytes available to this user on the disk that holds `dir`, or null when the OS cannot tell. */
+export declare function freeDiskBytes(dir: string): Promise<number | null>;
+/** Serialize same-process writers; each replacement still uses a distinct, synced temporary file. */
+export declare function atomicWrite(path: string, data: string, mode?: number): Promise<void>;
+export declare function readConfigFile(path?: string): Promise<AgentConfig | null>;
+export declare function writeConfigFile(config: AgentConfig, path?: string): Promise<void>;
+export declare function logLine(file: string, line: string): Promise<void>;
+export declare function sha256Hex(input: string | Buffer): string;
+export declare function sha256File(path: string, onProgress?: (bytes: number, total: number) => void): Promise<string>;
+export declare function readFirstBytes(path: string, length: number): Promise<Buffer>;
+/** Refuse paths that escape a directory, e.g. from a malicious archive. */
+export declare function safeJoin(root: string, candidate: string): string;
+export declare function shortPath(path: string, max?: number): string;