sublera-cli 0.0.0-stage → 1.3.0

package/dist/network/tunnelClient.d.ts

@@ -0,0 +1,54 @@
+import { EventEmitter } from 'node:events';
+import WebSocket from 'ws';
+import type { HeartbeatPayload, HelloPayload } from '../types.js';
+import type { Logger } from '../logger.js';
+export type TunnelState = 'connecting' | 'open' | 'reconnecting' | 'closed' | 'auth-failed' | 'outdated';
+export type TunnelOptions = {
+    server: string;
+    token: string;
+    wsPath?: string;
+    hello: () => HelloPayload;
+    heartbeat?: () => HeartbeatPayload | null;
+    logger?: Logger;
+    reconnectDelaysMs?: number[];
+    heartbeatMs?: number;
+    pingIntervalMs?: number;
+    staleAfterMs?: number;
+    autoReconnect?: boolean;
+    authMode?: 'header' | 'query';
+    wsFactory?: (url: string) => WebSocket;
+};
+export declare class TunnelClient extends EventEmitter {
+    private readonly options;
+    private readonly logger?;
+    private readonly delays;
+    private socket;
+    private _state;
+    private attempts;
+    private reconnectTimer;
+    private heartbeatTimer;
+    private pingTimer;
+    private heartbeatMs;
+    private manuallyStopped;
+    private authMode;
+    private triedQueryFallback;
+    private welcomeWaiters;
+    private _username;
+    private _lastMessageAt;
+    constructor(options: TunnelOptions);
+    get state(): TunnelState;
+    get connected(): boolean;
+    get username(): string | null;
+    get lastMessageAt(): number;
+    private setState;
+    start(): void;
+    /** Resolves once the server has sent its welcome frame. */
+    waitForWelcome(timeoutMs?: number): Promise<void>;
+    private connect;
+    private startTimers;
+    private stopTimers;
+    private scheduleReconnect;
+    send(message: Record<string, unknown>): boolean;
+    stop(): Promise<void>;
+    private rejectWelcomeWaiters;
+}

package/dist/network/tunnelClient.js

@@ -0,0 +1,257 @@
+import { EventEmitter } from 'node:events';
+import WebSocket from 'ws';
+import { RECONNECT_DELAYS_MS, HEARTBEAT_MS, UPGRADE_REQUIRED_CLOSE, USER_AGENT, outdatedMessage } from '../version.js';
+import { wsUrl as buildWsUrl } from '../config.js';
+import { websocketAgentFor } from './proxy.js';
+export class TunnelClient extends EventEmitter {
+    options;
+    logger;
+    delays;
+    socket = null;
+    _state = 'closed';
+    attempts = 0;
+    reconnectTimer = null;
+    heartbeatTimer = null;
+    pingTimer = null;
+    heartbeatMs;
+    manuallyStopped = false;
+    authMode;
+    triedQueryFallback = false;
+    welcomeWaiters = [];
+    _username = null;
+    _lastMessageAt = 0;
+    constructor(options) {
+        super();
+        this.options = options;
+        this.logger = options.logger;
+        this.delays = options.reconnectDelaysMs || RECONNECT_DELAYS_MS;
+        this.heartbeatMs = options.heartbeatMs ?? HEARTBEAT_MS;
+        this.authMode = options.authMode ?? 'header';
+    }
+    get state() { return this._state; }
+    get connected() { return this._state === 'open' && this.socket?.readyState === WebSocket.OPEN; }
+    get username() { return this._username; }
+    get lastMessageAt() { return this._lastMessageAt; }
+    setState(state) {
+        if (this._state === state)
+            return;
+        this._state = state;
+        this.emit('state', state);
+    }
+    start() {
+        this.manuallyStopped = false;
+        if (this._state === 'open' || this._state === 'connecting')
+            return;
+        this.connect();
+    }
+    /** Resolves once the server has sent its welcome frame. */
+    waitForWelcome(timeoutMs = 10_000) {
+        if (this._state === 'open' && this._username != null)
+            return Promise.resolve();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.welcomeWaiters = this.welcomeWaiters.filter((w) => w.timer !== timer);
+                reject(new Error('Timed out waiting for the host tunnel welcome'));
+            }, timeoutMs);
+            this.welcomeWaiters.push({ resolve, reject, timer });
+        });
+    }
+    connect() {
+        if (this.manuallyStopped)
+            return;
+        this.setState(this.attempts === 0 ? 'connecting' : 'reconnecting');
+        const useQuery = this.authMode === 'query';
+        const url = buildWsUrl(this.options.server, useQuery ? this.options.token : '', this.options.wsPath, useQuery ? 'query' : 'header');
+        this.logger?.debug('Opening tunnel', { url: url.replace(/token=[^&]+/, 'token=***'), auth: this.authMode });
+        let socket;
+        try {
+            const headers = { 'user-agent': USER_AGENT };
+            if (!useQuery)
+                headers.authorization = `Bearer ${this.options.token}`;
+            socket = this.options.wsFactory ? this.options.wsFactory(url) : new WebSocket(url, {
+                headers,
+                handshakeTimeout: 15_000,
+                // A corporate HTTPS_PROXY is used for the tunnel too; undefined means a direct connection.
+                agent: websocketAgentFor(url),
+                // Server frames are small JSON messages; refuse anything absurd instead of buffering it.
+                maxPayload: 16 * 1024 * 1024,
+            });
+        }
+        catch (error) {
+            this.logger?.warn('Tunnel connection failed to start', { error: error instanceof Error ? error.message : String(error) });
+            this.scheduleReconnect();
+            return;
+        }
+        this.socket = socket;
+        let opened = false;
+        let handshakeStatus = 0;
+        socket.on('open', () => {
+            opened = true;
+            this.attempts = 0;
+            this._lastMessageAt = Date.now();
+            this.setState('open');
+            this.emit('open');
+            this.send(this.options.hello());
+            this.startTimers();
+            this.logger?.info('Tunnel connected');
+        });
+        socket.on('message', (raw) => {
+            this._lastMessageAt = Date.now();
+            let message;
+            try {
+                message = JSON.parse(raw.toString());
+            }
+            catch {
+                return;
+            }
+            if (!message || typeof message !== 'object')
+                return;
+            if (message.type === 'welcome') {
+                this._username = typeof message.username === 'string' ? message.username : this._username;
+                for (const waiter of this.welcomeWaiters) {
+                    clearTimeout(waiter.timer);
+                    waiter.resolve();
+                }
+                this.welcomeWaiters = [];
+            }
+            this.emit('message', message);
+        });
+        socket.on('pong', () => { this._lastMessageAt = Date.now(); });
+        socket.on('error', (error) => {
+            const refused = /Unexpected server response: (\d+)/.exec(error.message);
+            if (refused)
+                handshakeStatus = Number(refused[1]);
+            this.logger?.debug('Tunnel error', { error: error.message });
+        });
+        socket.on('close', (code, reason) => {
+            this.stopTimers();
+            this.socket = null;
+            if (this.manuallyStopped) {
+                this.setState('closed');
+                return;
+            }
+            const text = reason?.toString() || '';
+            if (code === UPGRADE_REQUIRED_CLOSE || handshakeStatus === 426) {
+                this.setState('outdated');
+                const error = new Error(outdatedMessage(/\d+\.\d+\.\d+/.exec(text)?.[0]));
+                this.rejectWelcomeWaiters(error);
+                this.emit('outdated', error);
+                return;
+            }
+            const authClose = code === 4001 || code === 4003 || handshakeStatus === 401 || handshakeStatus === 403 || /token|auth/i.test(text);
+            if (authClose) {
+                if (this.authMode === 'header' && !this.triedQueryFallback) {
+                    this.authMode = 'query';
+                    this.triedQueryFallback = true;
+                    this.logger?.debug('Header auth was rejected; retrying with the query-token fallback');
+                    this.setState('reconnecting');
+                    this.scheduleReconnect();
+                    return;
+                }
+                this.setState('auth-failed');
+                const error = new Error(`Host key was rejected by the server (${handshakeStatus ? `HTTP ${handshakeStatus}` : code}${text ? `: ${text}` : ''})`);
+                this.rejectWelcomeWaiters(error);
+                this.emit('auth-failed', error);
+                return;
+            }
+            this.logger?.warn('Tunnel closed; reconnecting', { code, reason: text || undefined });
+            this.setState('reconnecting');
+            this.emit('disconnected', { code, reason: text, opened });
+            this.scheduleReconnect();
+        });
+    }
+    startTimers() {
+        this.stopTimers();
+        this.heartbeatTimer = setInterval(() => {
+            if (!this.connected)
+                return;
+            const heartbeat = this.options.heartbeat?.();
+            if (heartbeat)
+                this.send(heartbeat);
+        }, this.heartbeatMs);
+        this.pingTimer = setInterval(() => {
+            if (!this.connected || !this.socket)
+                return;
+            const silentMs = Date.now() - this._lastMessageAt;
+            if (silentMs > (this.options.staleAfterMs ?? Math.max(45_000, this.heartbeatMs * 5))) {
+                // A half-open TCP connection never emits 'close' on its own; terminate it so the close handler reconnects.
+                this.logger?.warn('Tunnel stopped answering pings; reconnecting', { silentMs });
+                this.socket.terminate();
+                return;
+            }
+            try {
+                this.socket.ping();
+            }
+            catch { /* closing */ }
+        }, this.options.pingIntervalMs ?? Math.max(10_000, this.heartbeatMs * 2));
+    }
+    stopTimers() {
+        if (this.heartbeatTimer)
+            clearInterval(this.heartbeatTimer);
+        if (this.pingTimer)
+            clearInterval(this.pingTimer);
+        this.heartbeatTimer = null;
+        this.pingTimer = null;
+    }
+    scheduleReconnect() {
+        if (this.manuallyStopped || this.options.autoReconnect === false)
+            return;
+        if (this.reconnectTimer)
+            return;
+        const base = this.delays[Math.min(this.attempts, this.delays.length - 1)] || 30_000;
+        this.attempts++;
+        const jitter = Math.round(base * 0.15 * (Math.random() * 2 - 1));
+        const delay = Math.max(250, base + jitter);
+        this.logger?.info(`Reconnecting in ${(delay / 1000).toFixed(1)}s`, { attempt: this.attempts });
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.connect();
+        }, delay);
+    }
+    send(message) {
+        if (!this.connected || !this.socket)
+            return false;
+        try {
+            this.socket.send(JSON.stringify(message));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async stop() {
+        this.manuallyStopped = true;
+        this.stopTimers();
+        if (this.reconnectTimer)
+            clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = null;
+        const socket = this.socket;
+        this.socket = null;
+        if (socket && socket.readyState !== WebSocket.CLOSED) {
+            await new Promise((resolve) => {
+                const timer = setTimeout(() => { try {
+                    socket.terminate();
+                }
+                catch { /* */ } resolve(); }, 2_000);
+                socket.once('close', () => { clearTimeout(timer); resolve(); });
+                try {
+                    socket.close(1000, 'agent stopped');
+                }
+                catch {
+                    clearTimeout(timer);
+                    resolve();
+                }
+            });
+        }
+        this.setState('closed');
+        this.rejectWelcomeWaiters(new Error('Tunnel stopped'));
+    }
+    rejectWelcomeWaiters(error) {
+        for (const waiter of this.welcomeWaiters) {
+            clearTimeout(waiter.timer);
+            waiter.reject(error);
+        }
+        this.welcomeWaiters = [];
+    }
+}
+//# sourceMappingURL=tunnelClient.js.map

package/dist/settings.d.ts

@@ -0,0 +1,53 @@
+import { type LogLevel } from './logger.js';
+/**
+ * Settings that a fleet or a container can set without command-line flags.
+ * Precedence, highest first: command-line flag > SUBLET_* environment variable >
+ * agent.json > built-in default. The host key normally lives in config.json
+ * (written by `sublet login`) or comes from SUBLET_KEY / --key.
+ */
+export type Settings = {
+    server?: string;
+    token?: string;
+    wsPath?: string;
+    context?: number;
+    slots?: number;
+    price?: number;
+    priceIn?: number;
+    priceOut?: number;
+    priceHour?: number;
+    gpu?: string;
+    vram?: number;
+    tokPerSec?: number;
+    noInstall?: boolean;
+    noBrowser?: boolean;
+    nonInteractive?: boolean;
+    drainTimeoutMs?: number;
+    requireChecksum?: boolean;
+    logLevel?: LogLevel;
+    /** A path, or "off" to disable the agent log file. */
+    logFile?: string;
+};
+export type SettingSource = 'flag' | 'env' | 'file' | 'default';
+type Kind = 'string' | 'number' | 'integer' | 'boolean' | 'level';
+/** One row per setting: its agent.json key, environment variable, and type. */
+export declare const SETTINGS_SPEC: ReadonlyArray<{
+    key: keyof Settings;
+    env: string;
+    kind: Kind;
+    secret?: boolean;
+    help: string;
+}>;
+export declare function settingsPath(env?: NodeJS.ProcessEnv): string;
+/** Reads agent.json. A missing file is fine; a broken or misspelled one is an error, never silently ignored. */
+export declare function readSettingsFile(path?: string): Settings;
+export declare function readSettingsEnv(env?: NodeJS.ProcessEnv): Settings;
+export type ResolvedSettings = {
+    values: Settings;
+    sources: Partial<Record<keyof Settings, SettingSource>>;
+    file: string;
+};
+/** Fills every flag the person did not pass from SUBLET_* variables, then agent.json. Returns where each value came from. */
+export declare function applySettings<T extends object>(flags: T, explicit: ReadonlySet<string>, env?: NodeJS.ProcessEnv): ResolvedSettings;
+/** Merges flags over environment over agent.json. */
+export declare function resolveSettings(fromFlags: Settings, env?: NodeJS.ProcessEnv): ResolvedSettings;
+export {};

package/dist/settings.js

@@ -0,0 +1,171 @@
+import { readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { subletHome } from './config.js';
+import { brandEnv } from './util/env.js';
+import { isLogLevel } from './logger.js';
+/** One row per setting: its agent.json key, environment variable, and type. */
+export const SETTINGS_SPEC = [
+    { key: 'server', env: 'SUBLET_SERVER', kind: 'string', help: 'Central server URL' },
+    { key: 'token', env: 'SUBLET_KEY', kind: 'string', secret: true, help: 'Host key (sh_...); prefer sublet login' },
+    { key: 'wsPath', env: 'SUBLET_WS_PATH', kind: 'string', help: 'Tunnel path' },
+    { key: 'context', env: 'SUBLET_CTX', kind: 'integer', help: 'Context window per slot' },
+    { key: 'slots', env: 'SUBLET_SLOTS', kind: 'integer', help: 'Parallel slots for public mode' },
+    { key: 'price', env: 'SUBLET_PRICE', kind: 'number', help: 'Public price per 1M output tokens (USD)' },
+    { key: 'priceIn', env: 'SUBLET_PRICE_IN', kind: 'number', help: 'Public price per 1M input tokens (USD)' },
+    { key: 'priceOut', env: 'SUBLET_PRICE_OUT', kind: 'number', help: 'Public price per 1M output tokens (USD)' },
+    { key: 'priceHour', env: 'SUBLET_PRICE_HOUR', kind: 'number', help: 'Host mode price per hour for the full GPU (USD, 0-50; 0 = no hourly rentals)' },
+    { key: 'gpu', env: 'SUBLET_GPU', kind: 'string', help: 'Correct a wrongly detected GPU name' },
+    { key: 'vram', env: 'SUBLET_VRAM', kind: 'integer', help: 'Correct a wrongly detected VRAM size (MB)' },
+    { key: 'tokPerSec', env: 'SUBLET_TOK_S', kind: 'number', help: 'Advertised tokens/sec (the server measures its own)' },
+    { key: 'noInstall', env: 'SUBLET_NO_INSTALL', kind: 'boolean', help: 'Never download llama-server' },
+    { key: 'noBrowser', env: 'SUBLET_NO_BROWSER', kind: 'boolean', help: 'Never open a browser' },
+    { key: 'nonInteractive', env: 'SUBLET_NON_INTERACTIVE', kind: 'boolean', help: 'Never prompt or begin device login; fail when a key is missing' },
+    { key: 'drainTimeoutMs', env: 'SUBLET_DRAIN_TIMEOUT_MS', kind: 'integer', help: 'SIGTERM inference drain grace period (0–300000 ms; default 30000)' },
+    { key: 'requireChecksum', env: 'SUBLET_REQUIRE_CHECKSUM', kind: 'boolean', help: 'Refuse a llama.cpp release without a published SHA-256' },
+    { key: 'logLevel', env: 'SUBLET_LOG_LEVEL', kind: 'level', help: 'Terminal log level: debug, info, warn, error, silent' },
+    { key: 'logFile', env: 'SUBLET_LOG_FILE', kind: 'string', help: 'Agent log file path, or "off"' },
+];
+export function settingsPath(env = process.env) {
+    const explicit = brandEnv(env, 'SUBLET_CONFIG')?.trim();
+    return explicit ? resolve(explicit) : join(subletHome(env), 'agent.json');
+}
+function coerce(kind, raw, where) {
+    if (kind === 'string') {
+        if (typeof raw !== 'string' || !raw.trim())
+            throw new Error(`${where} must be a non-empty string`);
+        return raw.trim();
+    }
+    if (kind === 'boolean') {
+        if (typeof raw === 'boolean')
+            return raw;
+        const text = String(raw).trim().toLowerCase();
+        if (['1', 'true', 'yes', 'on'].includes(text))
+            return true;
+        if (['0', 'false', 'no', 'off'].includes(text))
+            return false;
+        throw new Error(`${where} must be true or false, got "${String(raw)}"`);
+    }
+    if (kind === 'level') {
+        const text = String(raw).trim().toLowerCase();
+        if (!isLogLevel(text))
+            throw new Error(`${where} must be one of debug, info, warn, error, silent; got "${String(raw)}"`);
+        return text;
+    }
+    const value = typeof raw === 'number' ? raw : typeof raw === 'string' && raw.trim() ? Number(raw) : Number.NaN;
+    if (!Number.isFinite(value))
+        throw new Error(`${where} must be a number, got "${String(raw)}"`);
+    if (value < 0)
+        throw new Error(`${where} must not be negative`);
+    if (kind === 'integer' && !Number.isInteger(value))
+        throw new Error(`${where} must be a whole number`);
+    return value;
+}
+/** Reads agent.json. A missing file is fine; a broken or misspelled one is an error, never silently ignored. */
+export function readSettingsFile(path = settingsPath()) {
+    let raw;
+    try {
+        raw = readFileSync(path, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return {};
+        throw new Error(`Could not read ${path}: ${error.message}`);
+    }
+    let data;
+    try {
+        data = JSON.parse(raw.replace(/^\uFEFF/, ''));
+    }
+    catch {
+        // JSON.parse errors may quote part of a secret-bearing configuration file.
+        throw new Error(`${path} is not valid JSON. Check commas, quotes and braces.`);
+    }
+    if (!data || typeof data !== 'object' || Array.isArray(data))
+        throw new Error(`${path} must contain a JSON object`);
+    if ('version' in data && data.version !== 1)
+        throw new Error(`${path}: unsupported settings version; expected 1`);
+    const known = new Map(SETTINGS_SPEC.map((row) => [row.key, row]));
+    const out = {};
+    for (const [key, value] of Object.entries(data)) {
+        if (key === '$schema' || key === 'version')
+            continue;
+        const row = known.get(key);
+        if (!row)
+            throw new Error(`${path}: unknown setting "${key}". Known settings: ${[...known.keys()].join(', ')}`);
+        if (value == null)
+            continue;
+        out[key] = coerce(row.kind, value, `${path}: ${key}`);
+    }
+    return out;
+}
+export function readSettingsEnv(env = process.env) {
+    const out = {};
+    for (const row of SETTINGS_SPEC) {
+        const value = brandEnv(env, row.env);
+        if (value == null || value === '')
+            continue;
+        out[row.key] = coerce(row.kind, value, row.env);
+    }
+    return out;
+}
+/** Fills every flag the person did not pass from SUBLET_* variables, then agent.json. Returns where each value came from. */
+export function applySettings(flags, explicit, env = process.env) {
+    const target = flags;
+    const fromFlags = {};
+    for (const row of SETTINGS_SPEC) {
+        if (explicit.has(row.key))
+            fromFlags[row.key] = target[row.key];
+    }
+    const resolved = resolveSettings(fromFlags, env);
+    for (const row of SETTINGS_SPEC) {
+        const value = resolved.values[row.key];
+        if (value === undefined || explicit.has(row.key))
+            continue;
+        // Boolean switches can only be turned on by a setting; flags never default to true.
+        if (row.kind === 'boolean' && value !== true)
+            continue;
+        target[row.key] = value;
+    }
+    return resolved;
+}
+/** Merges flags over environment over agent.json. */
+export function resolveSettings(fromFlags, env = process.env) {
+    const file = settingsPath(env);
+    if (brandEnv(env, 'SUBLET_CONFIG')?.trim()) {
+        try {
+            readFileSync(file, 'utf8');
+        }
+        catch {
+            throw new Error(`Cannot read the settings file selected by SUBLET_CONFIG: ${file}`);
+        }
+    }
+    const layers = [['file', readSettingsFile(file)], ['env', readSettingsEnv(env)], ['flag', fromFlags]];
+    const values = {};
+    const sources = {};
+    for (const [source, layer] of layers) {
+        for (const [key, value] of Object.entries(layer)) {
+            if (value === undefined)
+                continue;
+            values[key] = value;
+            sources[key] = source;
+        }
+    }
+    for (const row of SETTINGS_SPEC) {
+        if (values[row.key] !== undefined)
+            values[row.key] = coerce(row.kind, values[row.key], row.env);
+    }
+    for (const key of ['context', 'slots']) {
+        const n = values[key];
+        if (typeof n === 'number' && !Number.isSafeInteger(n))
+            throw new Error(`${key} must be a safe whole number`);
+    }
+    if (typeof values.context === 'number' && values.context < 256)
+        throw new Error('context must be at least 256 tokens');
+    if (typeof values.slots === 'number' && (values.slots < 1 || values.slots > 16))
+        throw new Error('slots must be between 1 and 16');
+    if (typeof values.drainTimeoutMs === 'number' && values.drainTimeoutMs > 300_000)
+        throw new Error('drainTimeoutMs must be between 0 and 300000');
+    if (typeof values.priceHour === 'number' && values.priceHour > 50)
+        throw new Error('priceHour must be between 0 and 50 USD');
+    return { values: values, sources, file };
+}
+//# sourceMappingURL=settings.js.map

package/dist/state.d.ts

@@ -0,0 +1,52 @@
+export type PersistedModel = {
+    url: string;
+    path: string;
+    file: string;
+    modelId: string;
+    label: string;
+    repo: string;
+    quant: string;
+    paramB: number | null;
+    layers: number | null;
+    contextTrain: number | null;
+    sha256: string | null;
+    verified: boolean;
+    needsMb: number | null;
+    size: number;
+    architecture: string | null;
+};
+export type PersistedBooking = {
+    requestId: string;
+    model: PersistedModel;
+    context: number;
+    slots: number;
+    timerStartedAt: number | null;
+    timerEndsAt: number | null;
+    hours: number | null;
+    pricePerHourNanos: number | null;
+    minTokS: number | null;
+    guaranteedNanos: number | null;
+    /** A speed seat that shares the GPU; absent in files written before seats existed. */
+    shared?: boolean;
+    /** The reserved speed of a seat; null or absent means the full GPU. */
+    tokS?: number | null;
+    savedAt: number;
+};
+export type PersistedState = {
+    version: 1;
+    /**
+     * One booking, for older agents and scripts that read only this field: the server's `activeRequest`
+     * when the agent knows it (an older agent drops the booking unless it is that one), else the newest.
+     */
+    booking: PersistedBooking;
+    /** Every active booking, newest first. Files from older agents only have `booking`. */
+    bookings?: PersistedBooking[];
+    updatedAt: number;
+};
+export declare function statePath(env?: NodeJS.ProcessEnv): string;
+/** Reads state.json. The result always has `bookings`; a file with only the legacy `booking` field becomes a list of one. */
+export declare function readAgentState(env?: NodeJS.ProcessEnv): Promise<(PersistedState & {
+    bookings: PersistedBooking[];
+}) | null>;
+export declare function saveAgentState(state: PersistedState, env?: NodeJS.ProcessEnv): Promise<void>;
+export declare function clearAgentState(env?: NodeJS.ProcessEnv): Promise<void>;

package/dist/state.js

@@ -0,0 +1,71 @@
+import { readFile, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { subletHome } from './config.js';
+import { atomicWrite } from './util/fs.js';
+import { finiteNumber, isRequestId, validTime } from './types.js';
+/**
+ * A saved booking with every number checked (a hand-edited or damaged file can hold strings, NaN or
+ * nonsense), or null when it has no valid request id, model or end time.
+ */
+function readBooking(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const raw = value;
+    if (!isRequestId(raw.requestId) || !raw.model || typeof raw.model !== 'object')
+        return null;
+    const timerEndsAt = validTime(raw.timerEndsAt);
+    if (timerEndsAt == null)
+        return null;
+    const booking = {
+        ...raw,
+        context: finiteNumber(raw.context) ?? 0,
+        slots: finiteNumber(raw.slots) ?? 1,
+        timerStartedAt: validTime(raw.timerStartedAt),
+        timerEndsAt,
+        hours: finiteNumber(raw.hours),
+        pricePerHourNanos: finiteNumber(raw.pricePerHourNanos),
+        minTokS: finiteNumber(raw.minTokS),
+        guaranteedNanos: finiteNumber(raw.guaranteedNanos),
+        savedAt: finiteNumber(raw.savedAt) ?? 0,
+    };
+    if (raw.tokS !== undefined)
+        booking.tokS = finiteNumber(raw.tokS);
+    if (raw.shared !== undefined)
+        booking.shared = raw.shared === true;
+    return booking;
+}
+export function statePath(env = process.env) {
+    return join(subletHome(env), 'state.json');
+}
+/** Reads state.json. The result always has `bookings`; a file with only the legacy `booking` field becomes a list of one. */
+export async function readAgentState(env = process.env) {
+    try {
+        const raw = await readFile(statePath(env), 'utf8');
+        const data = JSON.parse(raw);
+        if (!data || data.version !== 1)
+            return null;
+        const bookings = [];
+        const seen = new Set();
+        // New files repeat one of the bookings in `booking`; the requestId check drops the copy.
+        for (const entry of [...(Array.isArray(data.bookings) ? data.bookings : []), data.booking]) {
+            const booking = readBooking(entry);
+            if (!booking || seen.has(booking.requestId))
+                continue;
+            seen.add(booking.requestId);
+            bookings.push(booking);
+        }
+        if (!bookings.length)
+            return null;
+        return { version: 1, booking: bookings[0], bookings, updatedAt: Number(data.updatedAt) || 0 };
+    }
+    catch {
+        return null;
+    }
+}
+export async function saveAgentState(state, env = process.env) {
+    await atomicWrite(statePath(env), `${JSON.stringify(state, null, 2)}\n`);
+}
+export async function clearAgentState(env = process.env) {
+    await rm(statePath(env), { force: true });
+}
+//# sourceMappingURL=state.js.map

package/dist/storageCommand.d.ts

@@ -0,0 +1,22 @@
+/** Maintenance is deliberately serialized against serving. Only regular stale
+ * partial files in the managed model root are eligible, never complete models. */
+export declare function storageReport(prune: boolean, apply: boolean, env?: NodeJS.ProcessEnv): Promise<{
+    schemaVersion: number;
+    home: string;
+    policy: {
+        modelCacheBytes: number;
+        reserveBytes: number;
+    };
+    freeBytes: number | null;
+    usage: Record<string, number>;
+    prune: boolean;
+    dryRun: boolean;
+    candidates: {
+        path: string;
+        bytes: number;
+    }[];
+}>;
+export declare function storageAction(positionals: string[], force: boolean): {
+    prune: boolean;
+    apply: boolean;
+};