sublera-cli 0.0.0-stage → 1.3.0

package/dist/storageCommand.js

@@ -0,0 +1,81 @@
+import { lstat, readdir, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import { binDir, cacheDir, logsDir, modelsDir, subletHome } from './config.js';
+import { directoryBytes, storagePolicy } from './util/storage.js';
+import { freeDiskBytes } from './util/fs.js';
+import { acquireInstanceLock } from './util/instanceLock.js';
+import { UsageError } from './exitCodes.js';
+/** Maintenance is deliberately serialized against serving. Only regular stale
+ * partial files in the managed model root are eligible, never complete models. */
+export async function storageReport(prune, apply, env = process.env) {
+    const release = await acquireInstanceLock(env);
+    try {
+        const root = modelsDir(env);
+        const candidates = [];
+        if (prune) {
+            // Validate the root before even enumerating candidates: readdir follows
+            // directory symlinks (including Windows junctions), unlike lstat.
+            const checkRoot = async () => {
+                try {
+                    const info = await lstat(root);
+                    if (info.isSymbolicLink() || !info.isDirectory())
+                        throw new Error(`Prune refuses a linked or non-directory model root: ${root}`);
+                    return info;
+                }
+                catch (error) {
+                    if (error.code === 'ENOENT')
+                        return null;
+                    throw error;
+                }
+            };
+            const rootInfo = await checkRoot();
+            let names = [];
+            try {
+                if (rootInfo)
+                    names = await readdir(root);
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+            for (const name of names) {
+                if (!/^[^/\\]+\.gguf\.part(?:\.json)?$/i.test(name))
+                    continue;
+                const path = join(root, name);
+                const info = await lstat(path);
+                if (!info.isFile() || info.isSymbolicLink() || Date.now() - info.mtimeMs < 7 * 24 * 3600_000)
+                    continue;
+                candidates.push({ path, bytes: info.size });
+            }
+            if (apply) {
+                for (const candidate of candidates) {
+                    const currentRoot = await checkRoot();
+                    if (!currentRoot || !rootInfo || currentRoot.dev !== rootInfo.dev || currentRoot.ino !== rootInfo.ino) {
+                        throw new Error('Prune model root changed; retry with all agents stopped');
+                    }
+                    const info = await lstat(candidate.path);
+                    if (!info.isFile() || info.isSymbolicLink() || info.size !== candidate.bytes
+                        || Date.now() - info.mtimeMs < 7 * 24 * 3600_000)
+                        throw new Error('Prune candidate changed; retry with all agents stopped');
+                    await unlink(candidate.path);
+                }
+            }
+        }
+        const usage = {};
+        for (const [name, dir] of Object.entries({ models: root, engines: binDir(env), cache: cacheDir(env), logs: logsDir(env) }))
+            usage[name] = await directoryBytes(dir);
+        return { schemaVersion: 1, home: subletHome(env), policy: storagePolicy(env), freeBytes: await freeDiskBytes(subletHome(env)), usage, prune, dryRun: !apply, candidates };
+    }
+    finally {
+        await release();
+    }
+}
+export function storageAction(positionals, force) {
+    const action = positionals[0] || 'status';
+    if (positionals.length > 1 || !['status', 'prune'].includes(action))
+        throw new UsageError('Usage: sublera storage [status|prune] [--force] [--json]. Prune is dry-run unless --force is supplied.');
+    if (force && action !== 'prune')
+        throw new UsageError('--force is only supported with storage prune');
+    return { prune: action === 'prune', apply: force };
+}
+//# sourceMappingURL=storageCommand.js.map

package/dist/types.d.ts

@@ -0,0 +1,222 @@
+export type ChatRole = 'system' | 'user' | 'assistant' | 'tool';
+export type ChatMessage = {
+    role: ChatRole;
+    content: string;
+    name?: string;
+};
+export type WorkerJob = {
+    type: 'infer';
+    jobId: string;
+    messages: ChatMessage[];
+    maxTokens: number;
+    temperature: number;
+    model?: string;
+};
+/** One generated token with its log probability and the top alternatives, as llama-server reports them. */
+export type TokenPosition = {
+    t: string;
+    l: number;
+    top: Array<[string, number]>;
+};
+export type LoadJob = {
+    type: 'load';
+    requestId: string;
+    url: string;
+    file: string | null;
+    sha256: string | null;
+    layers: number | null;
+    context: number;
+    /** Shared bookings: one llama-server slot for each buyer the host's benchmark allows. */
+    slots?: number;
+};
+/**
+ * The server starts a booking's clock. Several bookings can be active at once on the
+ * loaded model: speed seats (`tokS` set) side by side, or one full-GPU rental.
+ */
+export type BookingFrame = {
+    type: 'booking';
+    requestId: string;
+    timerStartedAt?: number;
+    timerEndsAt?: number;
+    hours?: number;
+    pricePerHourNanos?: number;
+    minTokS?: number;
+    /** True for a speed seat that shares the GPU with other renters and per-token buyers. */
+    shared?: boolean;
+    /** The reserved speed of a seat booking; null or absent means the full GPU. */
+    tokS?: number | null;
+};
+export type ServerMessage = {
+    type: 'welcome';
+    username?: string;
+} | WorkerJob | LoadJob | {
+    type: 'cancel';
+    jobId: string;
+} | {
+    type: 'verified';
+    requestId: string;
+    fingerprint?: string;
+} | BookingFrame | {
+    type: 'reject';
+    requestId: string;
+    reason?: string;
+} | {
+    type: 'error';
+    message?: string;
+} | {
+    type: string;
+    [key: string]: unknown;
+};
+export type CachedModelInfo = {
+    sha256: string;
+    file: string;
+    sizeBytes: number;
+};
+export type HelloPayload = {
+    type: 'hello';
+    agentVersion: string;
+    platform: string;
+    arch: string;
+    gpuName: string;
+    gpuVendor: string;
+    vramMb: number;
+    freeVramMb: number;
+    modelId: string;
+    modelLabel: string;
+    repo: string;
+    file: string;
+    quant: string;
+    paramB: number | null;
+    layers: number | null;
+    context: number;
+    slots: number;
+    sha256: string | null;
+    hashVerified: boolean;
+    tokPerSec: number;
+    ttftMs: number;
+    priceInUsd: number;
+    priceOutUsd: number;
+    /** The host's price per hour for the full GPU; 0 means no hourly rentals. The server derives seat prices from it. */
+    priceHourUsd: number;
+    simulate: boolean;
+    publicMode: boolean;
+    /** Set by `sublera start <code>`: the request this agent wants to serve. */
+    requestId?: string | null;
+    cachedModels?: CachedModelInfo[];
+};
+export type HeartbeatPayload = {
+    type: 'heartbeat';
+    tokPerSec: number;
+    ttftMs: number;
+    llamaUp: boolean;
+    sha256: string | null;
+    file: string;
+    layers: number | null;
+    activeJobId: string | null;
+    wakeLock: boolean;
+    gpuTempC: number | null;
+    gpuPowerW: number | null;
+    gpuUtilPct: number | null;
+    freeVramMb: number;
+    slotsUsed: number;
+};
+export type WalletView = {
+    availableNanos: number;
+    pendingNanos: number;
+    escrowNanos: number;
+    heldNanos?: number;
+    cardFundedNanos?: number;
+    cryptoFundedNanos?: number;
+};
+export type AgentHost = {
+    username: string;
+    status: string;
+    kind: 'simulator' | 'live' | string;
+    gpuName: string;
+    vramMb: number;
+    hardwareVerified: boolean;
+    modelId: string;
+    modelLabel: string;
+    repo: string;
+    file: string;
+    quant: string;
+    paramB: number | null;
+    layers: number | null;
+    context: number;
+    tokPerSec: number;
+    ttftMs: number;
+    slotsUsed: number;
+    slotsTotal: number;
+    priceInNanos: number;
+    priceOutNanos: number;
+    trust: number;
+    uptimePct: number;
+    tokensServed: number;
+    flagReason: string | null;
+    verified: boolean;
+    llamaUp: boolean;
+    lastSeen: number | null;
+    activeRequest?: ActiveRequest | null;
+};
+export type ActiveRequest = {
+    id: string;
+    status: string;
+    modelLabel?: string | null;
+    file?: string | null;
+    hours?: number | null;
+    pricePerHourNanos?: number | null;
+    minTokS?: number | null;
+    timerStartedAt?: number | null;
+    timerEndsAt?: number | null;
+    escrowRemainingNanos?: number;
+    /** Same meaning as in the booking frame, when the server includes them. */
+    shared?: boolean | null;
+    tokS?: number | null;
+};
+export type AgentMe = {
+    user: {
+        id: string;
+        username: string;
+        email?: string;
+        isAdmin?: boolean;
+    };
+    wallet: WalletView;
+    host: AgentHost | null;
+    /** The newest live request of this host. */
+    activeRequest: ActiveRequest | null;
+    /** Every live request of this host, newest first. Older servers do not send it. */
+    activeRequests?: ActiveRequest[];
+    serverNow: number;
+};
+/** The shape of a request id the server issues. Frames and status rows with any other id are ignored. */
+export declare const REQUEST_ID_PATTERN: RegExp;
+export declare function isRequestId(value: unknown): value is string;
+/** A finite number from the server or state.json, or null. Numeric strings count; NaN, Infinity, booleans and objects do not. */
+export declare function finiteNumber(value: unknown): number | null;
+/** A positive time in ms that `Date` can represent, or null. */
+export declare function validTime(value: unknown): number | null;
+/** Every live request in a /api/agent/me answer: `activeRequests`, or the single `activeRequest` from an older server. */
+export declare function activeRequestsOf(me: Pick<AgentMe, 'activeRequest' | 'activeRequests'>): ActiveRequest[];
+export type AgentRequest = {
+    id: string;
+    buyer?: string;
+    buyerId?: string;
+    repo?: string | null;
+    file?: string | null;
+    modelLabel?: string | null;
+    quant?: string | null;
+    paramB?: number | null;
+    layers?: number | null;
+    needsMb?: number | null;
+    hours?: number | null;
+    pricePerHourNanos?: number | null;
+    totalPayoutNanos?: number | null;
+    minContext?: number;
+    minTokS?: number;
+    status: string;
+    createdAt?: number;
+    timerStartedAt?: number | null;
+    timerEndsAt?: number | null;
+    fit?: string | null;
+    cached?: boolean;
+};

package/dist/types.js

@@ -0,0 +1,43 @@
+/** The shape of a request id the server issues. Frames and status rows with any other id are ignored. */
+export const REQUEST_ID_PATTERN = /^[A-Za-z0-9_-]{3,80}$/;
+export function isRequestId(value) {
+    return typeof value === 'string' && REQUEST_ID_PATTERN.test(value);
+}
+/** A finite number from the server or state.json, or null. Numeric strings count; NaN, Infinity, booleans and objects do not. */
+export function finiteNumber(value) {
+    if (typeof value !== 'number' && (typeof value !== 'string' || !value.trim()))
+        return null;
+    const number = Number(value);
+    return Number.isFinite(number) ? number : null;
+}
+/** A positive time in ms that `Date` can represent, or null. */
+export function validTime(value) {
+    const time = finiteNumber(value);
+    return time != null && time > 0 && time <= 8.64e15 ? time : null;
+}
+const ROW_NUMBERS = ['hours', 'pricePerHourNanos', 'minTokS', 'tokS', 'escrowRemainingNanos'];
+const ROW_TIMES = ['timerStartedAt', 'timerEndsAt'];
+/** A status row with checked types. A field the server left out stays undefined; a broken one becomes null. */
+function normalizeRow(raw) {
+    const row = { ...raw, status: typeof raw.status === 'string' ? raw.status : '' };
+    for (const key of ROW_NUMBERS)
+        if (raw[key] !== undefined)
+            row[key] = finiteNumber(raw[key]);
+    for (const key of ROW_TIMES)
+        if (raw[key] !== undefined)
+            row[key] = validTime(raw[key]);
+    for (const key of ['file', 'modelLabel'])
+        if (raw[key] != null && typeof raw[key] !== 'string')
+            row[key] = null;
+    if (raw.shared != null)
+        row.shared = raw.shared === true;
+    return row;
+}
+/** Every live request in a /api/agent/me answer: `activeRequests`, or the single `activeRequest` from an older server. */
+export function activeRequestsOf(me) {
+    const list = Array.isArray(me.activeRequests) ? me.activeRequests : me.activeRequest ? [me.activeRequest] : [];
+    return list
+        .filter((row) => Boolean(row && typeof row === 'object' && isRequestId(row.id)))
+        .map(normalizeRow);
+}
+//# sourceMappingURL=types.js.map

package/dist/ui/progress.d.ts

@@ -0,0 +1,29 @@
+export type ProgressOptions = {
+    label: string;
+    total: number;
+    width?: number;
+    stream?: NodeJS.WriteStream;
+    enabled?: boolean;
+    showEveryMs?: number;
+};
+export declare class ProgressBar {
+    private readonly stream;
+    private readonly enabled;
+    private readonly width;
+    private readonly label;
+    private total;
+    private current;
+    private startedAt;
+    private lastRender;
+    private lastLine;
+    private finished;
+    constructor(options: ProgressOptions);
+    private lastTickMs;
+    setTotal(total: number): void;
+    tick(delta: number, total?: number): void;
+    set(current: number, total?: number): void;
+    line(): string;
+    render(force: boolean): void;
+    done(message?: string): void;
+    fail(message?: string): void;
+}

package/dist/ui/progress.js

@@ -0,0 +1,82 @@
+import { formatBytes, formatBytesPerSec, formatDuration } from '../util/format.js';
+export class ProgressBar {
+    stream;
+    enabled;
+    width;
+    label;
+    total;
+    current = 0;
+    startedAt = Date.now();
+    lastRender = 0;
+    lastLine = '';
+    finished = false;
+    constructor(options) {
+        this.stream = options.stream ?? process.stderr;
+        this.enabled = options.enabled ?? Boolean(this.stream.isTTY);
+        this.width = options.width ?? 24;
+        this.label = options.label;
+        this.total = Math.max(0, options.total);
+        this.lastTickMs = options.showEveryMs ?? 100;
+        this.startedAt = Date.now();
+    }
+    lastTickMs;
+    setTotal(total) {
+        this.total = Math.max(0, total);
+    }
+    tick(delta, total) {
+        if (total != null)
+            this.total = total;
+        this.current += Math.max(0, delta);
+        this.render(false);
+    }
+    set(current, total) {
+        this.current = Math.max(0, current);
+        if (total != null)
+            this.total = Math.max(0, total);
+        this.render(false);
+    }
+    line() {
+        const ratio = this.total > 0 ? Math.min(1, this.current / this.total) : 0;
+        const filled = Math.round(ratio * this.width);
+        const bar = `${'='.repeat(filled)}${' '.repeat(this.width - filled)}`;
+        const elapsed = Math.max(0.001, (Date.now() - this.startedAt) / 1000);
+        const speed = this.current / elapsed;
+        const eta = speed > 0 && this.total > 0 ? Math.max(0, (this.total - this.current) / speed) : null;
+        const percent = this.total > 0 ? ratio * 100 : 0;
+        return `${this.label} ${percent.toFixed(0).padStart(3)}% [${bar}] ${formatBytes(this.current)}${this.total ? ` / ${formatBytes(this.total)}` : ''}  ${formatBytesPerSec(speed)}  ETA ${formatDuration(eta)}`;
+    }
+    render(force) {
+        if (this.finished)
+            return;
+        const now = Date.now();
+        if (!force && now - this.lastRender < this.lastTickMs)
+            return;
+        this.lastRender = now;
+        if (!this.enabled)
+            return;
+        const line = this.line();
+        if (line === this.lastLine)
+            return;
+        this.lastLine = line;
+        this.stream.write(`\r\x1b[2K${line}`);
+    }
+    done(message) {
+        if (this.finished)
+            return;
+        this.finished = true;
+        if (this.enabled) {
+            this.stream.write(`\r\x1b[2K${this.line()}\n`);
+            if (message)
+                this.stream.write(`${message}\n`);
+        }
+    }
+    fail(message) {
+        if (this.finished)
+            return;
+        this.finished = true;
+        if (this.enabled) {
+            this.stream.write(`\r\x1b[2K${this.label} failed${message ? `: ${message}` : ''}\n`);
+        }
+    }
+}
+//# sourceMappingURL=progress.js.map

package/dist/ui/terminalDashboard.d.ts

@@ -0,0 +1,88 @@
+export type DashboardStatus = 'starting' | 'online' | 'working' | 'reconnecting' | 'offline' | 'auth-failed' | 'outdated' | 'paused';
+export type DashboardJob = {
+    kind: 'request' | 'public';
+    id?: string | null;
+    model?: string | null;
+    verified?: boolean;
+    timerStartedAt?: number | null;
+    timerEndsAt?: number | null;
+    minTokS?: number | null;
+    guaranteedNanos?: number | null;
+    hours?: number | null;
+    /** A speed seat that shares the GPU. */
+    shared?: boolean;
+    /** Reserved speed of a seat; null means the full GPU. */
+    tokS?: number | null;
+};
+export type DashboardState = {
+    status: DashboardStatus;
+    username: string | null;
+    endpoint: string | null;
+    server: string;
+    reliability: number | null;
+    held: boolean;
+    gpuName: string | null;
+    totalVramMb: number;
+    freeVramMb: number;
+    gpuTempC: number | null;
+    gpuPowerW: number | null;
+    gpuUtilPct: number | null;
+    wakeLock: boolean;
+    llamaStatus: string;
+    /** The request in focus: the one loading or being checked, else the booking that ends first. */
+    job: DashboardJob | null;
+    /** Every booking on this host, soonest end first. */
+    bookings?: DashboardJob[];
+    liveTokPerSec: number | null;
+    /** Per-token earnings plus the time-proportional share of every booking. */
+    sessionEarnedNanos: number;
+    sessionGuaranteedNanos: number;
+    /** The per-token part of sessionEarnedNanos. */
+    tokenEarnedNanos?: number;
+    publicMode?: boolean;
+    /** Public mode prices, shown on the dashboard. */
+    priceOutUsd?: number | null;
+    priceHourUsd?: number | null;
+    walletNanos: number | null;
+    lastHeartbeatAt: number | null;
+    message: string | null;
+    showLogs?: boolean;
+    logTail?: string[];
+    keyHint?: string | null;
+};
+export declare function initialState(server: string): DashboardState;
+/** "50 tok/s" for a speed seat, "full GPU" for an exclusive rental. */
+export declare function rentalLabel(job: DashboardJob): string;
+/** "2 rentals: 50 tok/s + full GPU"; with more than three, "4 rentals, 150 tok/s reserved". */
+export declare function rentalsSummary(rentals: DashboardJob[]): string;
+export declare function renderFrame(state: DashboardState, options?: {
+    width?: number;
+    color?: boolean;
+    unicode?: boolean;
+}): string;
+export declare class TerminalDashboard {
+    private state;
+    private readonly stream;
+    private readonly color;
+    private readonly unicode;
+    private readonly intervalMs;
+    private readonly enabled;
+    private timer;
+    private started;
+    private lastFrame;
+    private lastStatus;
+    constructor(state: DashboardState, options?: {
+        stream?: NodeJS.WriteStream;
+        color?: boolean;
+        unicode?: boolean;
+        intervalMs?: number;
+        enabled?: boolean;
+    });
+    get current(): DashboardState;
+    start(): void;
+    update(partial: Partial<DashboardState>): void;
+    setJob(job: DashboardJob | null): void;
+    private printOnce;
+    private rerender;
+    stop(): void;
+}