sublera-cli 0.0.0-stage → 1.3.0

package/dist/util/fs.js

@@ -0,0 +1,140 @@
+import { appendFile, mkdir, open, readFile, rename, rm, stat, statfs } from 'node:fs/promises';
+import { dirname, resolve, sep } from 'node:path';
+import { createReadStream } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
+import { configPath } from '../config.js';
+export async function ensureDir(path, mode = 0o700) {
+    await mkdir(path, { recursive: true, mode });
+}
+export async function pathExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function fileSize(path) {
+    try {
+        return (await stat(path)).size;
+    }
+    catch {
+        return 0;
+    }
+}
+export async function removeIfExists(path) {
+    await rm(path, { force: true, recursive: true });
+}
+/** Bytes available to this user on the disk that holds `dir`, or null when the OS cannot tell. */
+export async function freeDiskBytes(dir) {
+    try {
+        const info = await statfs(dir);
+        return info.bavail * info.bsize;
+    }
+    catch {
+        return null;
+    }
+}
+const pendingWrites = new Map();
+/** Serialize same-process writers; each replacement still uses a distinct, synced temporary file. */
+export async function atomicWrite(path, data, mode = 0o600) {
+    const key = process.platform === 'win32' ? resolve(path).toLowerCase() : resolve(path);
+    const previous = pendingWrites.get(key) ?? Promise.resolve();
+    const write = previous.catch(() => undefined).then(() => atomicReplace(path, data, mode));
+    pendingWrites.set(key, write);
+    try {
+        await write;
+    }
+    finally {
+        if (pendingWrites.get(key) === write)
+            pendingWrites.delete(key);
+    }
+}
+async function atomicReplace(path, data, mode) {
+    await ensureDir(dirname(path));
+    const tmp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    const handle = await open(tmp, 'wx', mode);
+    try {
+        await handle.writeFile(data, 'utf8');
+        await handle.sync();
+        await handle.close();
+        await rename(tmp, path);
+    }
+    finally {
+        await handle.close().catch(() => undefined);
+        await rm(tmp, { force: true }).catch(() => undefined);
+    }
+}
+export async function readConfigFile(path = configPath()) {
+    try {
+        const raw = await readFile(path, 'utf8');
+        const data = JSON.parse(raw);
+        if (!data || typeof data.server !== 'string' || typeof data.token !== 'string')
+            return null;
+        return {
+            server: data.server,
+            token: data.token,
+            wsPath: typeof data.wsPath === 'string' && data.wsPath ? data.wsPath : '/tunnel',
+            updatedAt: typeof data.updatedAt === 'number' ? data.updatedAt : 0,
+            tokenLabel: typeof data.tokenLabel === 'string' ? data.tokenLabel : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeConfigFile(config, path = configPath()) {
+    await atomicWrite(path, `${JSON.stringify(config, null, 2)}\n`);
+}
+export async function logLine(file, line) {
+    await ensureDir(dirname(file));
+    await appendFile(file, `${new Date().toISOString()} ${line}\n`, 'utf8');
+}
+export function sha256Hex(input) {
+    return createHash('sha256').update(input).digest('hex');
+}
+export async function sha256File(path, onProgress) {
+    const total = await fileSize(path);
+    const hash = createHash('sha256');
+    let read = 0;
+    await new Promise((resolvePromise, reject) => {
+        const stream = createReadStream(path);
+        stream.on('data', (chunk) => {
+            hash.update(chunk);
+            read += chunk.length;
+            onProgress?.(read, total);
+        });
+        stream.on('end', () => resolvePromise());
+        stream.on('error', reject);
+    });
+    return hash.digest('hex');
+}
+export async function readFirstBytes(path, length) {
+    const handle = await import('node:fs/promises').then((fs) => fs.open(path, 'r'));
+    try {
+        const buf = Buffer.alloc(length);
+        const { bytesRead } = await handle.read(buf, 0, buf.length, 0);
+        return buf.subarray(0, bytesRead);
+    }
+    finally {
+        await handle.close();
+    }
+}
+/** Refuse paths that escape a directory, e.g. from a malicious archive. */
+export function safeJoin(root, candidate) {
+    const full = resolve(root, candidate);
+    const rootWithSep = resolve(root) + sep;
+    if (full !== resolve(root) && !full.startsWith(rootWithSep)) {
+        throw new Error(`Archive entry escapes the install directory: ${candidate}`);
+    }
+    return full;
+}
+export function shortPath(path, max = 52) {
+    if (path.length <= max)
+        return path;
+    const head = Math.max(8, Math.floor(max * 0.35));
+    const tail = max - head - 1;
+    return `${path.slice(0, head)}…${path.slice(-tail)}`;
+}
+//# sourceMappingURL=fs.js.map

package/dist/util/http.d.ts

@@ -0,0 +1,28 @@
+export type FetchJsonOptions = {
+    timeoutMs?: number;
+    headers?: Record<string, string>;
+    method?: string;
+    body?: string;
+    token?: string;
+};
+export declare class HttpError extends Error {
+    readonly status: number;
+    readonly body: string;
+    constructor(status: number, body: string, message?: string);
+}
+export declare function fetchJson<T>(url: string, options?: FetchJsonOptions): Promise<T>;
+export declare function fetchText(url: string, options?: FetchJsonOptions): Promise<string>;
+export declare function joinUrl(base: string, path: string): string;
+/** Latest agent package on the npm registry, or null when it cannot be checked. */
+export declare function latestPublishedVersion(timeoutMs?: number): Promise<string | null>;
+export type SpeedSample = {
+    bytes: number;
+    ms: number;
+    bytesPerSec: number;
+};
+/** Downloads at most maxBytes for at most maxMs and returns the throughput after the response headers. */
+export declare function measureDownloadSpeed(url: string, options?: {
+    maxBytes?: number;
+    maxMs?: number;
+    headerTimeoutMs?: number;
+}): Promise<SpeedSample>;

package/dist/util/http.js

@@ -0,0 +1,128 @@
+import { toError } from './exec.js';
+import { AGENT_NAME, USER_AGENT, outdatedMessage } from '../version.js';
+export class HttpError extends Error {
+    status;
+    body;
+    constructor(status, body, message) {
+        super(message || `HTTP ${status}${body ? `: ${body.slice(0, 200)}` : ''}`);
+        this.status = status;
+        this.body = body;
+    }
+}
+export async function fetchJson(url, options = {}) {
+    const headers = {
+        accept: 'application/json',
+        'user-agent': USER_AGENT,
+        ...options.headers,
+    };
+    if (options.token)
+        headers.authorization = `Bearer ${options.token}`;
+    if (options.body != null)
+        headers['content-type'] = 'application/json';
+    let response;
+    try {
+        response = await fetch(url, {
+            method: options.method || (options.body ? 'POST' : 'GET'),
+            headers,
+            body: options.body,
+            signal: AbortSignal.timeout(options.timeoutMs ?? 15_000),
+        });
+    }
+    catch (error) {
+        throw new Error(`Could not reach ${url}: ${toError(error).message}`);
+    }
+    const text = await response.text();
+    if (!response.ok) {
+        let message = text.slice(0, 300);
+        let minVersion;
+        try {
+            const parsed = JSON.parse(text);
+            message = typeof parsed.error === 'string' ? parsed.error : parsed.error?.message || parsed.message || message;
+            minVersion = typeof parsed.minVersion === 'string' ? parsed.minVersion : undefined;
+        }
+        catch {
+            /* raw text */
+        }
+        if (response.status === 426)
+            message = outdatedMessage(minVersion);
+        throw new HttpError(response.status, text, message);
+    }
+    if (!text)
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new Error(`Expected JSON from ${url}`);
+    }
+}
+export async function fetchText(url, options = {}) {
+    const response = await fetch(url, {
+        headers: {
+            'user-agent': USER_AGENT,
+            ...options.headers,
+            ...(options.token ? { authorization: `Bearer ${options.token}` } : {}),
+        },
+        signal: AbortSignal.timeout(options.timeoutMs ?? 20_000),
+    });
+    const text = await response.text();
+    if (!response.ok)
+        throw new HttpError(response.status, text);
+    return text;
+}
+export function joinUrl(base, path) {
+    return `${base.replace(/\/+$/, '')}${path.startsWith('/') ? path : `/${path}`}`;
+}
+/** Latest agent package on the npm registry, or null when it cannot be checked. */
+export async function latestPublishedVersion(timeoutMs = 5_000) {
+    const registry = (process.env.npm_config_registry || 'https://registry.npmjs.org/').replace(/\/+$/, '');
+    try {
+        const body = await fetchJson(`${registry}/${AGENT_NAME}/latest`, { timeoutMs });
+        return typeof body.version === 'string' ? body.version : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Downloads at most maxBytes for at most maxMs and returns the throughput after the response headers. */
+export async function measureDownloadSpeed(url, options = {}) {
+    const maxBytes = options.maxBytes ?? 32 * 1024 * 1024;
+    const maxMs = options.maxMs ?? 5_000;
+    const controller = new AbortController();
+    const headerTimer = setTimeout(() => controller.abort(), options.headerTimeoutMs ?? 10_000);
+    let response;
+    try {
+        response = await fetch(url, {
+            headers: { 'user-agent': USER_AGENT, range: `bytes=0-${maxBytes - 1}` },
+            redirect: 'follow',
+            signal: controller.signal,
+        });
+    }
+    catch (error) {
+        throw new Error(`Could not reach ${new URL(url).host}: ${toError(error).message}`);
+    }
+    finally {
+        clearTimeout(headerTimer);
+    }
+    if (!response.ok || !response.body)
+        throw new HttpError(response.status, '');
+    const reader = response.body.getReader();
+    const started = performance.now();
+    const deadline = setTimeout(() => { void reader.cancel().catch(() => undefined); }, maxMs);
+    let bytes = 0;
+    try {
+        while (bytes < maxBytes) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            bytes += value.byteLength;
+        }
+    }
+    finally {
+        clearTimeout(deadline);
+        await reader.cancel().catch(() => undefined);
+    }
+    const ms = Math.max(1, performance.now() - started);
+    return { bytes, ms, bytesPerSec: bytes / (ms / 1000) };
+}
+//# sourceMappingURL=http.js.map

package/dist/util/instanceLock.d.ts

@@ -0,0 +1,3 @@
+export declare function instanceLockPath(env?: NodeJS.ProcessEnv): string;
+/** Exclusive ownership of SUBLET_HOME. A lock left by a process that is gone is taken over; any other lock is refused. */
+export declare function acquireInstanceLock(env?: NodeJS.ProcessEnv): Promise<() => Promise<void>>;

package/dist/util/instanceLock.js

@@ -0,0 +1,108 @@
+import { randomUUID } from 'node:crypto';
+import { lstat, open, readFile, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import { subletHome } from '../config.js';
+import { ensureDir } from './fs.js';
+export function instanceLockPath(env = process.env) {
+    return join(subletHome(env), 'agent.lock');
+}
+/** Creates the file only if it does not exist yet; null when it already does. */
+async function createExclusive(path) {
+    try {
+        return await open(path, 'wx', 0o600);
+    }
+    catch (error) {
+        if (error.code === 'EEXIST')
+            return null;
+        throw error;
+    }
+}
+async function readOwner(path) {
+    try {
+        const owner = JSON.parse(await readFile(path, 'utf8'));
+        return owner && typeof owner === 'object' ? owner : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** True unless the PID is certainly gone. An unknown PID counts as alive, so an unreadable lock fails closed. EPERM means the process exists but belongs to another user. */
+function processAlive(pid) {
+    if (typeof pid !== 'number' || !Number.isInteger(pid) || pid <= 0)
+        return true;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== 'ESRCH';
+    }
+}
+function lockedError(path, detail) {
+    return new Error(`SUBLET_HOME is locked: ${path}. ${detail} Do not delete state.json.`);
+}
+/**
+ * Removes a lock whose process is gone, after a crash, so an agent restarted by a service manager restores its
+ * booking. A live or unknown owner keeps the lock (PID reuse only ever makes it look alive, which fails closed).
+ * `agent.lock.reclaim` lets one process at a time check and remove a stale lock, so two reclaimers cannot both
+ * remove it, and a fresh lock (another id) is never removed. Ownership is still decided only by the exclusive create.
+ */
+async function reclaimStale(path) {
+    const owner = await readOwner(path);
+    if (!owner || typeof owner.id !== 'string')
+        throw lockedError(path, 'Its owner cannot be read. If no agent or maintenance task uses this directory, remove only agent.lock.');
+    if (processAlive(owner.pid))
+        throw lockedError(path, `Another agent or maintenance task is running (process ${String(owner.pid)}).`);
+    const guardPath = `${path}.reclaim`;
+    const guard = await createExclusive(guardPath);
+    if (!guard)
+        throw lockedError(path, `Another process is taking over a stale lock. If none is, remove ${guardPath}.`);
+    await guard.close();
+    try {
+        if ((await readOwner(path))?.id === owner.id) {
+            await unlink(path).catch((error) => {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            });
+        }
+    }
+    finally {
+        await unlink(guardPath).catch(() => undefined);
+    }
+}
+/** Exclusive ownership of SUBLET_HOME. A lock left by a process that is gone is taken over; any other lock is refused. */
+export async function acquireInstanceLock(env = process.env) {
+    await ensureDir(subletHome(env));
+    const path = instanceLockPath(env);
+    const id = randomUUID();
+    let handle = await createExclusive(path);
+    if (!handle) {
+        await reclaimStale(path);
+        handle = await createExclusive(path);
+        if (!handle)
+            throw lockedError(path, 'Another agent or maintenance task started at the same time.');
+    }
+    try {
+        await handle.writeFile(JSON.stringify({ version: 1, pid: process.pid, id, createdAt: Date.now() }));
+        await handle.sync();
+    }
+    catch (error) {
+        await handle.close();
+        await unlink(path).catch(() => undefined);
+        throw error;
+    }
+    await handle.close();
+    let releasePromise;
+    // Publish one promise synchronously: overlapping calls must not both unlink,
+    // and neither successful nor failed releases may later touch a new owner's lock.
+    return () => releasePromise ??= (async () => {
+        const info = await lstat(path);
+        if (!info.isFile() || info.isSymbolicLink())
+            throw new Error('Instance lock changed; refusing to remove it');
+        const owner = JSON.parse(await readFile(path, 'utf8'));
+        if (owner.id !== id)
+            throw new Error('Instance lock ownership changed; refusing to remove it');
+        await unlink(path);
+    })();
+}
+//# sourceMappingURL=instanceLock.js.map

package/dist/util/open.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The link to hand to the browser, or null when it is not a plain web link. A link that came from the server is
+ * opened only on the server's own origin (`sameOriginAs`), so a server cannot make this machine open a program,
+ * a file share or another site. Without `sameOriginAs`, only https and this machine's http are allowed.
+ */
+export declare function browserUrl(raw: string, sameOriginAs?: string): string | null;
+/**
+ * Opens a web link in the default browser. Returns false when the link is refused or no browser could start.
+ * On Windows it goes through rundll32 by its full path, not `cmd /c start`, so characters like `&` in the link are
+ * never read as commands and a program named `cmd` in the current folder is never run.
+ */
+export declare function openUrl(raw: string, sameOriginAs?: string): boolean;
+/** Text from the server, safe to print: control characters (terminal escape sequences) are removed. */
+export declare function printable(text: string): string;
+/** A browser on this machine helps only in a local desktop session, not over SSH or on a headless server. */
+export declare function canOpenBrowser(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): boolean;

package/dist/util/open.js

@@ -0,0 +1,65 @@
+import { spawn } from 'node:child_process';
+import { join } from 'node:path';
+import { isLoopbackHost } from '../config.js';
+/**
+ * The link to hand to the browser, or null when it is not a plain web link. A link that came from the server is
+ * opened only on the server's own origin (`sameOriginAs`), so a server cannot make this machine open a program,
+ * a file share or another site. Without `sameOriginAs`, only https and this machine's http are allowed.
+ */
+export function browserUrl(raw, sameOriginAs) {
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        return null;
+    }
+    if (url.protocol !== 'https:' && url.protocol !== 'http:')
+        return null;
+    if (url.username || url.password)
+        return null;
+    if (sameOriginAs !== undefined) {
+        try {
+            return new URL(sameOriginAs).origin === url.origin ? url.href : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    return url.protocol === 'https:' || isLoopbackHost(url.hostname) ? url.href : null;
+}
+/**
+ * Opens a web link in the default browser. Returns false when the link is refused or no browser could start.
+ * On Windows it goes through rundll32 by its full path, not `cmd /c start`, so characters like `&` in the link are
+ * never read as commands and a program named `cmd` in the current folder is never run.
+ */
+export function openUrl(raw, sameOriginAs) {
+    const url = browserUrl(raw, sameOriginAs);
+    if (!url)
+        return false;
+    try {
+        const child = process.platform === 'win32'
+            ? spawn(join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'rundll32.exe'), ['url.dll,FileProtocolHandler', url], { detached: true, stdio: 'ignore', windowsHide: true })
+            : spawn(process.platform === 'darwin' ? 'open' : 'xdg-open', [url], { detached: true, stdio: 'ignore' });
+        // A missing opener (no xdg-open) is reported as an 'error' event, which would crash the process without a listener.
+        child.on('error', () => undefined);
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Text from the server, safe to print: control characters (terminal escape sequences) are removed. */
+export function printable(text) {
+    return text.replace(/[\u0000-\u001f\u007f-\u009f]/g, '');
+}
+/** A browser on this machine helps only in a local desktop session, not over SSH or on a headless server. */
+export function canOpenBrowser(env = process.env, platform = process.platform) {
+    if (env.SSH_CONNECTION || env.SSH_TTY)
+        return false;
+    if (platform === 'linux' && !env.DISPLAY && !env.WAYLAND_DISPLAY)
+        return false;
+    return true;
+}
+//# sourceMappingURL=open.js.map

package/dist/util/storage.d.ts

@@ -0,0 +1,10 @@
+export declare function storagePolicy(env?: NodeJS.ProcessEnv): {
+    modelCacheBytes: number;
+    reserveBytes: number;
+};
+/** Count all regular files, including partial downloads. Never follow directory links. */
+export declare function directoryBytes(root: string): Promise<number>;
+export declare function availableWriteBytes(free: number, reserve: number): number;
+export declare function diskWriteAllowance(path: string, reserve: number): Promise<number>;
+export declare function storageLimitError(): Error;
+export declare function requireDiskSpace(path: string, bytes: number, reserve: number): Promise<void>;

package/dist/util/storage.js

@@ -0,0 +1,69 @@
+import { lstat, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { freeDiskBytes } from './fs.js';
+import { formatBytes } from './format.js';
+import { brandEnv } from './env.js';
+const GIB = 1024 ** 3;
+function gibSetting(env, key, fallback) {
+    const raw = brandEnv(env, key);
+    const value = raw == null ? fallback : Number(raw);
+    if ((raw != null && !raw.trim()) || !Number.isFinite(value) || value <= 0 || value > 1024 * 1024) {
+        throw new Error(`${key} must be a positive number of GiB (at most 1048576)`);
+    }
+    const bytes = Math.floor(value * GIB);
+    if (bytes < 1)
+        throw new Error(`${key} must represent at least one byte`);
+    return bytes;
+}
+export function storagePolicy(env = process.env) {
+    return {
+        modelCacheBytes: gibSetting(env, 'SUBLET_MODEL_CACHE_GB', 20),
+        reserveBytes: gibSetting(env, 'SUBLET_MIN_FREE_DISK_GB', 5),
+    };
+}
+/** Count all regular files, including partial downloads. Never follow directory links. */
+export async function directoryBytes(root) {
+    let bytes = 0;
+    const pending = [root];
+    while (pending.length) {
+        const path = pending.pop();
+        let info;
+        try {
+            info = await lstat(path);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                continue;
+            throw error;
+        }
+        if (info.isSymbolicLink())
+            throw new Error(`Storage accounting refuses symbolic links: ${path}`);
+        if (info.isFile())
+            bytes += info.size;
+        else if (info.isDirectory()) {
+            for (const name of await readdir(path))
+                pending.push(join(path, name));
+        }
+        else
+            throw new Error(`Storage accounting requires regular files: ${path}`);
+    }
+    return bytes;
+}
+export function availableWriteBytes(free, reserve) {
+    return Math.max(0, free - reserve);
+}
+export async function diskWriteAllowance(path, reserve) {
+    const free = await freeDiskBytes(path);
+    if (free == null)
+        throw new Error('Cannot determine free disk space; refusing an unbounded download');
+    return availableWriteBytes(free, reserve);
+}
+export function storageLimitError() {
+    return new Error('Download stopped by the storage budget. Free disk space or move SUBLET_HOME to a larger drive. Adjust SUBLET_MODEL_CACHE_GB / SUBLET_MIN_FREE_DISK_GB if appropriate; no existing models were automatically deleted.');
+}
+export async function requireDiskSpace(path, bytes, reserve) {
+    const allowance = await diskWriteAllowance(path, reserve);
+    if (bytes > allowance)
+        throw new Error(`Not enough disk space: ${formatBytes(bytes)} needed while retaining ${formatBytes(reserve)} free. ${storageLimitError().message}`);
+}
+//# sourceMappingURL=storage.js.map

package/dist/version.d.ts

@@ -0,0 +1,15 @@
+export declare const BRAND = "Sublera";
+export declare const VERSION = "1.3.0";
+/** Lowest supported Node.js; matches "engines" in package.json (undici, used for proxies, needs 20.18.1). */
+export declare const MIN_NODE = "20.18.1";
+export declare const AGENT_NAME = "sublera-cli";
+export declare const USER_AGENT = "sublera-cli/1.3.0";
+export declare const DEFAULT_SERVER: string;
+export declare const DEFAULT_WS_PATH: string;
+export declare const HEARTBEAT_MS = 5000;
+export declare const RECONNECT_DELAYS_MS: number[];
+/** WebSocket close code a server sends to refuse an agent that is too old (mirrors HTTP 426). */
+export declare const UPGRADE_REQUIRED_CLOSE = 4426;
+/** Compares dotted numeric versions. Pre-release tags are ignored. */
+export declare function compareVersions(a: string, b: string): number;
+export declare function outdatedMessage(minVersion?: string | null): string;

package/dist/version.js

@@ -0,0 +1,29 @@
+import { brandEnv } from './util/env.js';
+export const BRAND = 'Sublera';
+export const VERSION = '1.3.0';
+/** Lowest supported Node.js; matches "engines" in package.json (undici, used for proxies, needs 20.18.1). */
+export const MIN_NODE = '20.18.1';
+export const AGENT_NAME = 'sublera-cli';
+export const USER_AGENT = `${AGENT_NAME}/${VERSION}`;
+export const DEFAULT_SERVER = brandEnv(process.env, 'SUBLET_SERVER') || 'https://sublera.com';
+export const DEFAULT_WS_PATH = brandEnv(process.env, 'SUBLET_WS_PATH') || '/tunnel';
+export const HEARTBEAT_MS = 5_000;
+export const RECONNECT_DELAYS_MS = [1_000, 2_000, 5_000, 10_000, 15_000, 30_000];
+/** WebSocket close code a server sends to refuse an agent that is too old (mirrors HTTP 426). */
+export const UPGRADE_REQUIRED_CLOSE = 4426;
+/** Compares dotted numeric versions. Pre-release tags are ignored. */
+export function compareVersions(a, b) {
+    const parts = (v) => v.replace(/^v/, '').split(/[.+-]/).slice(0, 3).map((n) => Number.parseInt(n, 10) || 0);
+    const [pa, pb] = [parts(a), parts(b)];
+    for (let i = 0; i < 3; i++) {
+        const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (diff)
+            return Math.sign(diff);
+    }
+    return 0;
+}
+export function outdatedMessage(minVersion) {
+    const needs = minVersion ? ` (needs v${minVersion} or newer)` : '';
+    return `${AGENT_NAME} v${VERSION} is too old for this server${needs}. Update with: npx ${AGENT_NAME}@latest`;
+}
+//# sourceMappingURL=version.js.map