sublera-cli 0.0.0-stage → 1.3.0

package/dist/health.js

@@ -0,0 +1,38 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { subletHome } from './config.js';
+export function healthPath(env = process.env) {
+    return join(subletHome(env), 'health.json');
+}
+/** Local readiness only: not server attestation, billing approval, or a GPU benchmark. */
+export async function readHealth(env = process.env) {
+    const data = JSON.parse(await readFile(healthPath(env), 'utf8'));
+    const now = Date.now();
+    if (!data || typeof data !== 'object' || data.schemaVersion !== 1 || !Number.isSafeInteger(data.pid) || data.pid <= 0
+        || !Number.isFinite(data.updatedAt) || data.updatedAt > now + 5_000 || now - data.updatedAt > 15_000
+        || typeof data.live !== 'boolean' || typeof data.ready !== 'boolean'
+        || typeof data.draining !== 'boolean' || typeof data.simulation !== 'boolean'
+        || !Number.isSafeInteger(data.activeJobs) || data.activeJobs < 0
+        || typeof data.tunnel !== 'string' || typeof data.engine !== 'string'
+        || typeof data.agentVersion !== 'string' || typeof data.loading !== 'boolean'
+        || (data.ready && (!data.live || data.draining || data.loading || data.tunnel !== 'open'
+            || (data.simulation ? data.engine !== 'simulation' : data.engine !== 'ready')))) {
+        throw new Error('Agent health snapshot is stale or invalid');
+    }
+    try {
+        process.kill(data.pid, 0);
+    }
+    catch (error) {
+        if (error.code !== 'EPERM')
+            throw new Error('Agent process is not running');
+    }
+    // Return a fixed allowlist: a damaged or user-edited snapshot must not cause
+    // arbitrary extra fields (credentials, prompts) to be printed by health.
+    return {
+        schemaVersion: 1, agentVersion: String(data.agentVersion), pid: data.pid,
+        updatedAt: data.updatedAt, live: data.live, ready: data.ready,
+        draining: data.draining, simulation: data.simulation, tunnel: data.tunnel,
+        engine: data.engine, activeJobs: data.activeJobs, loading: data.loading === true,
+    };
+}
+//# sourceMappingURL=health.js.map

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { type GlobalFlags } from './commands.js';
+/** `explicit` lists the flags typed on the command line, so settings never override them. */
+type Parsed = {
+    flags: GlobalFlags;
+    command: string;
+    explicit: Set<string>;
+};
+export declare function parseArgv(argv: string[]): Parsed;
+declare function main(): Promise<number>;
+export { main };

package/dist/index.js

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+import process from 'node:process';
+import { join } from 'node:path';
+import { BRAND, VERSION } from './version.js';
+import { isLogLevel, LogFile, Logger, redactSecrets } from './logger.js';
+import { logsDir } from './config.js';
+import { EXIT, UsageError } from './exitCodes.js';
+import { applySettings } from './settings.js';
+import { installFetchProxy } from './network/proxy.js';
+import { colorEnabled } from './util/format.js';
+import { readHealth } from './health.js';
+import { storageAction, storageReport } from './storageCommand.js';
+import { cmdConfig, cmdDoctor, cmdHost, cmdJobs, cmdLogin, cmdLogout, cmdStart, cmdStatus, globalHelp, } from './commands.js';
+const BOOLEAN_FLAGS = {
+    '--json': 'json',
+    '--verbose': 'verbose',
+    '--no-color': 'color',
+    '--simulation': 'simulation',
+    '--fix': 'fix',
+    '--force': 'force',
+    '--once': 'once',
+    '--no-install': 'noInstall',
+    '--watch': 'watch',
+    '--require-checksum': 'requireChecksum',
+    '--no-browser': 'noBrowser',
+    '--non-interactive': 'nonInteractive',
+    '--help': 'help',
+    '--version': 'version',
+};
+const VALUE_FLAGS = {
+    '--server': 'server',
+    '--key': 'token',
+    '--token': 'token',
+    '--ws-path': 'wsPath',
+    '--model': 'model',
+    '--ctx': 'context',
+    '--slots': 'slots',
+    '--price': 'price',
+    '--price-in': 'priceIn',
+    '--price-out': 'priceOut',
+    '--price-hour': 'priceHour',
+    '--gpu': 'gpu',
+    '--vram': 'vram',
+    '--tok-s': 'tokPerSec',
+    '--claim': 'claim',
+    '--timeout': 'timeoutMs',
+    '--log-level': 'logLevel',
+    '--log-file': 'logFile',
+    '--drain-timeout': 'drainTimeoutMs',
+};
+const NUMERIC = new Set(['context', 'slots', 'price', 'priceIn', 'priceOut', 'priceHour', 'vram', 'tokPerSec', 'timeoutMs', 'drainTimeoutMs']);
+const INTEGER = new Set(['context', 'slots', 'vram', 'drainTimeoutMs']);
+function numberFlag(name, raw, integer) {
+    const value = raw.trim() ? Number(raw) : Number.NaN;
+    if (!Number.isFinite(value))
+        throw new Error(`${name} expects a number, got "${raw}"`);
+    if (value < 0)
+        throw new Error(`${name} must not be negative, got "${raw}"`);
+    if (integer && !Number.isInteger(value))
+        throw new Error(`${name} expects a whole number, got "${raw}"`);
+    return value;
+}
+export function parseArgv(argv) {
+    const flags = {
+        json: false,
+        verbose: false,
+        color: true,
+        simulation: false,
+        fix: false,
+        force: false,
+        once: false,
+        noInstall: false,
+        help: false,
+        version: false,
+        watch: false,
+        requireChecksum: false,
+        noBrowser: false,
+        positionals: [],
+    };
+    let command = '';
+    const explicit = new Set();
+    const args = [...argv];
+    while (args.length) {
+        const arg = args.shift();
+        if (arg === '--') {
+            flags.positionals.push(...args.splice(0));
+            break;
+        }
+        if (arg === '-h') {
+            flags.help = true;
+            continue;
+        }
+        if (arg === '-v' || arg === '-V') {
+            flags.version = true;
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            const eq = arg.indexOf('=');
+            const name = eq >= 0 ? arg.slice(0, eq) : arg;
+            const inline = eq >= 0 ? arg.slice(eq + 1) : undefined;
+            const booleanKey = Object.hasOwn(BOOLEAN_FLAGS, name) ? BOOLEAN_FLAGS[name] : undefined;
+            if (booleanKey) {
+                if (inline !== undefined && inline !== 'true' && inline !== 'false')
+                    throw new Error(`${name} accepts true or false`);
+                const enabled = inline !== 'false';
+                if (booleanKey === 'color')
+                    flags.color = !enabled;
+                else
+                    flags[booleanKey] = enabled;
+                explicit.add(booleanKey);
+                continue;
+            }
+            const valueKey = Object.hasOwn(VALUE_FLAGS, name) ? VALUE_FLAGS[name] : undefined;
+            if (valueKey) {
+                const value = inline ?? (args[0]?.startsWith('--') ? undefined : args.shift());
+                if (value == null || (!NUMERIC.has(valueKey) && !value.trim()))
+                    throw new Error(`${name} needs a value`);
+                if (NUMERIC.has(valueKey))
+                    flags[valueKey] = numberFlag(name, value, INTEGER.has(valueKey));
+                else if (valueKey === 'logLevel' && !isLogLevel(value))
+                    throw new Error(`--log-level must be one of debug, info, warn, error, silent; got "${value}"`);
+                else
+                    flags[valueKey] = value;
+                explicit.add(valueKey);
+                continue;
+            }
+            throw new Error(`Unknown option: ${name}`);
+        }
+        if (arg.startsWith('-') && arg !== '-')
+            throw new Error(`Unknown option: ${arg}`);
+        if (!command)
+            command = arg.toLowerCase();
+        else
+            flags.positionals.push(arg);
+    }
+    if (explicit.has('slots') && (flags.slots < 1 || flags.slots > 16))
+        throw new Error('--slots must be between 1 and 16');
+    if (explicit.has('context') && flags.context < 256)
+        throw new Error('--ctx must be at least 256 tokens');
+    if (explicit.has('priceHour') && flags.priceHour > 50)
+        throw new Error('--price-hour must be between 0 and 50 USD');
+    return { flags, command, explicit };
+}
+/** Commands that run for hours keep a rotating log file by default; quick commands only when asked. */
+const LONG_RUNNING = new Set(['start', 'host', 'jobs']);
+function logFileFor(command, flags) {
+    const setting = flags.logFile?.trim();
+    if (setting && /^(off|none|false|0)$/i.test(setting))
+        return null;
+    if (!setting && !LONG_RUNNING.has(command))
+        return null;
+    return new LogFile({ path: setting || join(logsDir(), 'agent.log') });
+}
+const COMMANDS = new Set(['login', 'doctor', 'start', 'host', 'jobs', 'status', 'logout', 'config', 'health', 'storage']);
+function reportError(error, json, code) {
+    const message = redactSecrets(error instanceof Error ? error.message : String(error));
+    if (json)
+        process.stdout.write(`${JSON.stringify({ ok: false, error: message, exitCode: code })}\n`);
+    process.stderr.write(`${message}\n`);
+}
+async function main() {
+    let parsed;
+    try {
+        parsed = parseArgv(process.argv.slice(2));
+    }
+    catch (error) {
+        const args = process.argv.slice(2);
+        const beforeSeparator = args.slice(0, args.indexOf('--') >= 0 ? args.indexOf('--') : args.length);
+        reportError(error, beforeSeparator.includes('--json') || beforeSeparator.includes('--json=true'), EXIT.USAGE);
+        return EXIT.USAGE;
+    }
+    const { flags, command, explicit } = parsed;
+    if (flags.version) {
+        process.stdout.write(`${BRAND} agent v${VERSION}\n`);
+        return EXIT.OK;
+    }
+    if (flags.help || !command) {
+        process.stdout.write(`${globalHelp()}\n`);
+        return EXIT.OK;
+    }
+    if (!COMMANDS.has(command)) {
+        reportError(new UsageError(`Unknown command: ${command}. Run sublera --help.`), flags.json, EXIT.USAGE);
+        return EXIT.USAGE;
+    }
+    let resolved;
+    try {
+        // SUBLET_* variables and agent.json fill in every flag that was not typed.
+        resolved = applySettings(flags, explicit);
+        // config and logout are local recovery commands; a broken proxy must not prevent them.
+        if (!['config', 'logout', 'health', 'storage'].includes(command))
+            await installFetchProxy();
+    }
+    catch (error) {
+        reportError(error, flags.json, EXIT.USAGE);
+        return EXIT.USAGE;
+    }
+    const level = flags.verbose ? 'debug' : isLogLevel(flags.logLevel) ? flags.logLevel : 'info';
+    const logger = new Logger({
+        level,
+        json: flags.json,
+        color: flags.color && colorEnabled(process.stderr),
+        file: logFileFor(command, flags),
+    });
+    if (logger.file)
+        logger.debug(`${BRAND} agent v${VERSION} ${command}`, { node: process.versions.node, platform: `${process.platform}/${process.arch}`, pid: process.pid });
+    try {
+        switch (command) {
+            case 'health': {
+                if (flags.positionals.length > 1 || (flags.positionals[0] && !['live', 'ready'].includes(flags.positionals[0])))
+                    throw new UsageError('Usage: sublera health [live|ready] [--json]');
+                const health = await readHealth();
+                process.stdout.write(`${JSON.stringify(health)}\n`);
+                return (flags.positionals[0] === 'live' ? health.live : health.ready) ? EXIT.OK : EXIT.ERROR;
+            }
+            case 'storage': {
+                const action = storageAction(flags.positionals, flags.force);
+                const report = await storageReport(action.prune, action.apply);
+                process.stdout.write(`${JSON.stringify(report, null, flags.json ? undefined : 2)}\n`);
+                return EXIT.OK;
+            }
+            case 'login': return await cmdLogin(flags, logger);
+            case 'doctor': return await cmdDoctor(flags, logger);
+            case 'start': return await cmdStart(flags, logger);
+            case 'host': return await cmdHost(flags, logger);
+            case 'jobs': return await cmdJobs(flags, logger);
+            case 'status': return await cmdStatus(flags, logger);
+            case 'logout': return await cmdLogout(flags, logger);
+            case 'config': return await cmdConfig(flags, logger, resolved);
+            default: return EXIT.USAGE;
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const code = error instanceof UsageError ? EXIT.USAGE : EXIT.ERROR;
+        if (flags.json)
+            process.stdout.write(`${JSON.stringify({ ok: false, error: redactSecrets(message), exitCode: code })}\n`);
+        logger.error(message);
+        if (error instanceof Error && error.stack)
+            logger.debug(error.stack);
+        return code;
+    }
+}
+const invoked = process.argv[1] && (process.argv[1].endsWith('index.js') || process.argv[1].endsWith('index.ts') || process.argv[1].endsWith('sublera-cli') || process.argv[1].endsWith('sublera') || process.argv[1].endsWith('sublet-cli') || process.argv[1].endsWith('sublet'));
+if (invoked) {
+    let fatal = false;
+    let fatalTimer;
+    // Stop serving after an unexpected failure, allowing existing SIGTERM cleanup a bounded grace period.
+    process.on('unhandledRejection', (reason) => {
+        if (fatal)
+            return;
+        fatal = true;
+        process.stderr.write(`Unexpected error: ${redactSecrets(reason instanceof Error ? reason.stack || reason.message : String(reason))}\n`);
+        process.exitCode = EXIT.ERROR;
+        fatalTimer = setTimeout(() => process.exit(EXIT.ERROR), 5_000);
+        fatalTimer.unref();
+        process.emit('SIGTERM');
+    });
+    main().then((code) => {
+        process.exitCode = fatal ? EXIT.ERROR : code;
+        if (fatalTimer)
+            clearTimeout(fatalTimer);
+    }).catch((error) => {
+        process.stderr.write(`${redactSecrets(error instanceof Error ? error.stack || error.message : String(error))}\n`);
+        process.exitCode = 1;
+    });
+}
+export { main };
+//# sourceMappingURL=index.js.map

package/dist/logger.d.ts

@@ -0,0 +1,53 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
+export declare const LOG_LEVELS: readonly LogLevel[];
+export declare function isLogLevel(value: unknown): value is LogLevel;
+export type LogFields = Record<string, unknown>;
+export declare function redactSecrets(text: string): string;
+export type LogFileOptions = {
+    path: string;
+    /** Rotate when the file reaches this size. Default 10 MB. */
+    maxBytes?: number;
+    /** Rotated files to keep (agent.log.1 ... agent.log.N). Default 5. */
+    keep?: number;
+    /** Called once if logging fails. No error text or credentials are passed. */
+    onError?: () => void;
+};
+/**
+ * A synchronous, size-rotated JSON-lines log file. Synchronous writes keep the
+ * last lines before a crash; agent logs are a few lines a minute, so the cost is negligible.
+ */
+export declare class LogFile {
+    readonly path: string;
+    private readonly maxBytes;
+    private readonly keep;
+    private size;
+    private failed;
+    private readonly onError;
+    constructor(options: LogFileOptions);
+    write(line: string): void;
+    private rotate;
+}
+export type LoggerOptions = {
+    level?: LogLevel;
+    json?: boolean;
+    color?: boolean;
+    stream?: NodeJS.WriteStream;
+    /** Every record (debug included) is also written here as JSON lines. */
+    file?: LogFile | null;
+};
+export declare class Logger {
+    readonly level: LogLevel;
+    readonly json: boolean;
+    readonly color: boolean;
+    readonly file: LogFile | null;
+    private readonly stream;
+    constructor(options?: LoggerOptions);
+    child(options: Partial<LoggerOptions>): Logger;
+    debug(message: string, fields?: LogFields): void;
+    info(message: string, fields?: LogFields): void;
+    warn(message: string, fields?: LogFields): void;
+    error(message: string, fields?: LogFields): void;
+    success(message: string, fields?: LogFields): void;
+    private write;
+}
+export declare function redactFields(fields: LogFields): LogFields;

package/dist/logger.js

@@ -0,0 +1,201 @@
+import { appendFileSync, chmodSync, lstatSync, mkdirSync, renameSync, rmSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { colorEnabled, paint } from './util/format.js';
+const ORDER = { debug: 10, info: 20, warn: 30, error: 40, silent: 100 };
+export const LOG_LEVELS = ['debug', 'info', 'warn', 'error', 'silent'];
+export function isLogLevel(value) {
+    return typeof value === 'string' && LOG_LEVELS.includes(value);
+}
+/** Host keys (sh_...), API keys (sk-...), and bearer tokens never reach a terminal or a log file in full. */
+// Order matters: whole bearer values and token= parameters first, then any bare key left in free text.
+const SECRET_PATTERNS = [
+    [/\b(Bearer|Basic)\s+[^\s"'<>]+/gi, (m) => `${m.split(/\s+/)[0]} ***`],
+    [/([?&](?:token|access_token|api_key|key|signature|sig)=)[^&\s"']+/gi, (m) => `${m.slice(0, m.indexOf('=') + 1)}***`],
+    [/[a-z][a-z0-9+.-]*:\/\/[^\s/@]+@/gi, (m) => `${m.slice(0, m.indexOf('://') + 3)}***@`],
+    [/\b(sh_|sk-)[A-Za-z0-9_-]{6,}/g, (m) => `${m.slice(0, 6)}***`],
+];
+export function redactSecrets(text) {
+    let out = text;
+    for (const [pattern, replace] of SECRET_PATTERNS)
+        out = out.replace(pattern, replace);
+    // Do not let a remote error string clear the terminal or forge a second log line.
+    return out.replace(/[\u0000-\u001f\u007f-\u009f]/g, (char) => `\\u${char.charCodeAt(0).toString(16).padStart(4, '0')}`);
+}
+/**
+ * A synchronous, size-rotated JSON-lines log file. Synchronous writes keep the
+ * last lines before a crash; agent logs are a few lines a minute, so the cost is negligible.
+ */
+export class LogFile {
+    path;
+    maxBytes;
+    keep;
+    size = -1;
+    failed = false;
+    onError;
+    constructor(options) {
+        this.path = options.path;
+        this.maxBytes = Number.isFinite(options.maxBytes) ? Math.max(64 * 1024, Math.floor(options.maxBytes)) : 10 * 1024 * 1024;
+        this.keep = Number.isFinite(options.keep) ? Math.max(1, Math.min(50, Math.floor(options.keep))) : 5;
+        this.onError = options.onError ?? (() => { process.stderr.write('Warning: agent file logging stopped; check disk space and log-file permissions.\n'); });
+    }
+    write(line) {
+        if (this.failed)
+            return;
+        try {
+            if (this.size < 0) {
+                mkdirSync(dirname(this.path), { recursive: true, mode: 0o700 });
+                try {
+                    const stat = lstatSync(this.path);
+                    if (!stat.isFile() || stat.isSymbolicLink())
+                        throw new Error('Log must be a regular file');
+                    this.size = stat.size;
+                    if (process.platform !== 'win32')
+                        chmodSync(this.path, 0o600);
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT')
+                        throw error;
+                    this.size = 0;
+                }
+            }
+            // Do not persist an oversized record, even when the file was empty.
+            const data = Buffer.byteLength(line) + 1 > this.maxBytes
+                ? `${JSON.stringify({ ts: new Date().toISOString(), level: 'warn', message: 'Oversized log record omitted', truncated: true })}\n`
+                : `${line}\n`;
+            if (this.size + Buffer.byteLength(data) > this.maxBytes && this.size > 0)
+                this.rotate();
+            appendFileSync(this.path, data, { encoding: 'utf8', mode: 0o600 });
+            this.size += Buffer.byteLength(data);
+        }
+        catch {
+            // A full disk or a read-only home must never stop a booking; the terminal still has the logs.
+            this.failed = true;
+            try {
+                this.onError();
+            }
+            catch { /* diagnostics must not stop serving */ }
+        }
+    }
+    rotate() {
+        rmSync(`${this.path}.${this.keep}`, { force: true });
+        for (let i = this.keep - 1; i >= 1; i--) {
+            try {
+                renameSync(`${this.path}.${i}`, `${this.path}.${i + 1}`);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+        }
+        try {
+            renameSync(this.path, `${this.path}.1`);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        this.size = 0;
+    }
+}
+export class Logger {
+    level;
+    json;
+    color;
+    file;
+    stream;
+    constructor(options = {}) {
+        this.level = options.level ?? 'info';
+        this.json = options.json ?? false;
+        this.color = options.color ?? colorEnabled(process.stderr);
+        this.stream = options.stream ?? process.stderr;
+        this.file = options.file ?? null;
+    }
+    child(options) {
+        return new Logger({ level: this.level, json: this.json, color: this.color, stream: this.stream, file: this.file, ...options });
+    }
+    debug(message, fields) { this.write('debug', message, fields); }
+    info(message, fields) { this.write('info', message, fields); }
+    warn(message, fields) { this.write('warn', message, fields); }
+    error(message, fields) { this.write('error', message, fields); }
+    success(message, fields) {
+        this.write('info', message, { ...fields, ok: true });
+    }
+    write(level, rawMessage, rawFields) {
+        const toFile = this.file != null;
+        const toStream = ORDER[level] >= ORDER[this.level];
+        if (!toFile && !toStream)
+            return;
+        const message = redactSecrets(rawMessage);
+        const fields = rawFields ? redactFields(rawFields) : undefined;
+        // Redact BEFORE serialization: rewriting escaped JSON can corrupt records.
+        const record = (toFile || this.json) ? JSON.stringify({ ...fields, ts: new Date().toISOString(), level, message }) : '';
+        if (toFile)
+            this.file.write(record);
+        if (!toStream)
+            return;
+        if (this.json) {
+            this.stream.write(`${record}\n`);
+            return;
+        }
+        const label = level === 'info' ? '•' : level === 'warn' ? '!' : level === 'error' ? 'x' : '·';
+        const color = level === 'warn' ? 'yellow' : level === 'error' ? 'red' : level === 'debug' ? 'gray' : 'cyan';
+        const prefix = paint(label, color, this.color);
+        const suffix = fields && Object.keys(fields).length
+            ? ` ${paint(formatFields(fields), 'gray', this.color)}`
+            : '';
+        this.stream.write(`${prefix} ${message}${suffix}\n`);
+    }
+}
+const SECRET_KEYS = /^(token|key|hostkey|apikey|authorization|proxyauthorization|password|secret|accesstoken|refreshtoken|devicecode|cookie|setcookie|prompt|messages|content)$/i;
+export function redactFields(fields) {
+    const seen = new WeakSet();
+    const visit = (value, depth) => {
+        if (typeof value === 'string')
+            return redactSecrets(value);
+        if (typeof value === 'bigint')
+            return value.toString();
+        if (value == null || typeof value !== 'object')
+            return typeof value === 'function' ? '[function]' : value;
+        if (depth > 8)
+            return '[depth limit]';
+        if (seen.has(value))
+            return '[circular]';
+        seen.add(value);
+        try {
+            if (Array.isArray(value))
+                return value.slice(0, 100).map((item) => visit(item, depth + 1));
+            const out = Object.create(null);
+            for (const key of Object.keys(value).slice(0, 100)) {
+                if (SECRET_KEYS.test(key.replace(/[-_]/g, ''))) {
+                    out[key] = '***';
+                    continue;
+                }
+                const descriptor = Object.getOwnPropertyDescriptor(value, key);
+                out[redactSecrets(key)] = descriptor && 'value' in descriptor ? visit(descriptor.value, depth + 1) : '[accessor]';
+            }
+            return out;
+        }
+        finally {
+            seen.delete(value);
+        }
+    };
+    try {
+        return visit(fields, 0);
+    }
+    catch {
+        return { fields: '[unavailable]' };
+    }
+}
+function formatFields(fields) {
+    return Object.entries(fields)
+        .filter(([, value]) => value !== undefined && value !== null && value !== '')
+        .map(([key, value]) => {
+        if (typeof value === 'string')
+            return `${key}=${value.includes(' ') ? JSON.stringify(value) : value}`;
+        if (typeof value === 'number' || typeof value === 'boolean')
+            return `${key}=${value}`;
+        return `${key}=${JSON.stringify(value)}`;
+    })
+        .join(' ');
+}
+//# sourceMappingURL=logger.js.map

package/dist/network/proxy.d.ts

@@ -0,0 +1,58 @@
+import { Agent as HttpAgent } from 'node:http';
+import { Agent as HttpsAgent, type AgentOptions } from 'node:https';
+import type { Duplex } from 'node:stream';
+import { type Socket } from 'node:net';
+/**
+ * Corporate network support. Standard proxy variables are honored for every
+ * outbound connection the agent makes (API, HuggingFace/GitHub downloads, and
+ * the WebSocket tunnel). llama-server on 127.0.0.1 is never proxied.
+ *
+ *   HTTPS_PROXY / https_proxy   proxy for https:// and wss:// (most common)
+ *   HTTP_PROXY  / http_proxy    proxy for http:// and ws://
+ *   NO_PROXY    / no_proxy      comma-separated hosts, .domains, host:port, or *
+ *   NODE_EXTRA_CA_CERTS         extra corporate root CA (read by Node itself at startup)
+ */
+export type ProxySettings = {
+    httpsProxy: string | null;
+    httpProxy: string | null;
+    noProxy: string[];
+};
+export declare function proxySettings(env?: NodeJS.ProcessEnv): ProxySettings;
+export declare function proxyConfigured(settings?: ProxySettings): boolean;
+/** True when NO_PROXY (or loopback) says this host must be reached directly. */
+export declare function bypassProxy(target: URL, noProxy: string[]): boolean;
+/** The proxy URL to use for a target, or null for a direct connection. */
+export declare function proxyFor(target: string | URL, settings?: ProxySettings): URL | null;
+export declare function parseProxyUrl(raw: string): URL;
+/** Proxy URL safe for logs and doctor output: credentials are hidden. */
+export declare function redactProxy(raw: string | URL | null): string;
+/** Opens an HTTP CONNECT tunnel through the proxy and returns the raw socket to host:port. */
+export declare function openConnectTunnel(proxy: URL, host: string, port: number, timeoutMs?: number, signal?: AbortSignal): Promise<Socket>;
+type ConnectionCallback = (error: Error | null, stream: Duplex) => void;
+/**
+ * An https.Agent that reaches the target through an HTTP CONNECT proxy. Used
+ * for the wss:// tunnel, because the `ws` package takes a Node agent and ignores proxy variables.
+ */
+export declare class ConnectProxyAgent extends HttpsAgent {
+    readonly proxy: URL;
+    private readonly pending;
+    constructor(proxy: URL, options?: AgentOptions);
+    createConnection(rawOptions: object, callback?: ConnectionCallback): Duplex | null | undefined;
+    destroy(): void;
+}
+/** The plain-HTTP twin of ConnectProxyAgent, for ws:// servers (local or test setups). */
+export declare class ConnectProxyHttpAgent extends HttpAgent {
+    readonly proxy: URL;
+    private readonly pending;
+    constructor(proxy: URL);
+    createConnection(rawOptions: object, callback?: ConnectionCallback): Duplex | null | undefined;
+    destroy(): void;
+}
+/** A Node agent for the `ws` tunnel when a proxy applies to this URL, else undefined (direct). */
+export declare function websocketAgentFor(url: string, settings?: ProxySettings): HttpAgent | undefined;
+/**
+ * Routes the global fetch() (API calls, model and engine downloads) through the
+ * configured proxy. Loads nothing and changes nothing when no proxy is set.
+ */
+export declare function installFetchProxy(env?: NodeJS.ProcessEnv): Promise<boolean>;
+export {};