ollanet 0.6.23 → 0.7.0

package/dist/serve-store.d.ts

@@ -0,0 +1,52 @@
+export interface ServeToken {
+    name: string;
+    /** Hex SHA-256 of the token. */
+    sha256: string;
+    created_at: string;
+    expires_at: string | null;
+    /** Last successful auth by `ollanet serve` (ISO), written at most once a minute. */
+    last_used?: string | null;
+}
+export interface ServeStore {
+    tokens: ServeToken[];
+    /** Opaque catalog label per machine (key: hostname, MagicDNS name, or IP). */
+    labels: Record<string, string>;
+}
+export declare function serveStorePath(): string;
+/** Token names and labels: 1–40 of letters, digits, `.`, `_`, `-`. */
+export declare function isValidServeName(name: string): boolean;
+export declare function loadServeStore(): Promise<ServeStore>;
+export declare function saveServeStore(store: ServeStore): Promise<string>;
+export declare function hashToken(token: string): string;
+export declare function newToken(): string;
+/**
+ * `30d`, `12h`, `10m`, `45s`, `500ms`; a bare number is seconds.
+ * Returns milliseconds, or undefined when the text is not a duration.
+ */
+export declare function parseDuration(raw: string): number | undefined;
+export declare function addToken(name: string, expiresInMs?: number): Promise<{
+    token: string;
+    record: ServeToken;
+    file: string;
+}>;
+export declare function removeToken(name: string): Promise<boolean>;
+/** Remove several tokens in one write. Returns the names actually removed. */
+export declare function removeTokens(names: string[]): Promise<string[]>;
+/**
+ * Merge last-used times into serve.json. Re-reads the file first and touches
+ * only `last_used` on tokens matched by hash, so token add/rm from the CLI in
+ * the meantime is kept (a removed token simply is not written back). Never
+ * moves a time backwards. Atomic via temp file + rename.
+ */
+export declare function recordLastUsed(usedBySha: Map<string, string>): Promise<void>;
+/** Last use, else creation: the clock for `token prune --unused-days`. */
+export declare function lastActivity(token: ServeToken): number;
+export declare function setLabel(machine: string, label: string): Promise<void>;
+export declare function removeLabel(machine: string): Promise<boolean>;
+export declare function isExpired(token: ServeToken, now?: number): boolean;
+/**
+ * Find the token matching `presented`. Compares the SHA-256 digest against
+ * every stored hash with timingSafeEqual (no early exit). Expired tokens never
+ * match.
+ */
+export declare function matchToken(tokens: ServeToken[], presented: string, now?: number): ServeToken | undefined;

package/dist/serve-store.js

@@ -0,0 +1,215 @@
+/**
+ * Token + label store for `ollanet serve`.
+ *
+ * Lives in `~/.ollanet/serve.json` (override with OLLANET_SERVE_FILE), never in
+ * a checkout. Only SHA-256 hashes of tokens are stored; the token itself is
+ * printed once by `ollanet serve token add`.
+ */
+import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+import { mkdir, open, readFile, rename, stat, unlink, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { USER_DIR } from "./paths.js";
+const NAME_RE = /^[a-z0-9][a-z0-9_.-]{0,39}$/i;
+const TOKEN_PREFIX = "olns_";
+export function serveStorePath() {
+    return process.env.OLLANET_SERVE_FILE ?? path.join(USER_DIR, "serve.json");
+}
+/** Token names and labels: 1–40 of letters, digits, `.`, `_`, `-`. */
+export function isValidServeName(name) {
+    return NAME_RE.test(name);
+}
+export async function loadServeStore() {
+    const file = serveStorePath();
+    let text;
+    try {
+        text = await readFile(file, "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return { tokens: [], labels: {} };
+        throw err;
+    }
+    const parsed = JSON.parse(text);
+    const tokens = Array.isArray(parsed.tokens)
+        ? parsed.tokens.filter((t) => !!t && typeof t.name === "string" && typeof t.sha256 === "string" && /^[0-9a-f]{64}$/.test(t.sha256))
+        : [];
+    const labels = {};
+    if (parsed.labels && typeof parsed.labels === "object") {
+        for (const [k, v] of Object.entries(parsed.labels)) {
+            if (typeof v === "string" && isValidServeName(v))
+                labels[k.toLowerCase()] = v;
+        }
+    }
+    return { tokens, labels };
+}
+export async function saveServeStore(store) {
+    const file = serveStorePath();
+    await mkdir(path.dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+    await writeFile(tmp, `${JSON.stringify(store, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+    await rename(tmp, file);
+    return file;
+}
+/**
+ * Serialize read-modify-write of serve.json across processes (a running
+ * `serve` recording last use, and CLI token add/rm/prune). A plain lock file
+ * created with O_EXCL; a lock older than 10s is treated as stale.
+ */
+async function withStoreLock(fn) {
+    const file = serveStorePath();
+    await mkdir(path.dirname(file), { recursive: true });
+    const lock = `${file}.lock`;
+    const deadline = Date.now() + 5000;
+    for (;;) {
+        try {
+            const handle = await open(lock, "wx");
+            try {
+                return await fn();
+            }
+            finally {
+                await handle.close();
+                await unlink(lock).catch(() => { });
+            }
+        }
+        catch (err) {
+            if (err.code !== "EEXIST")
+                throw err;
+            const age = await stat(lock).then((st) => Date.now() - st.mtimeMs, () => 0);
+            if (age > 10_000) {
+                await unlink(lock).catch(() => { });
+                continue;
+            }
+            if (Date.now() > deadline)
+                throw new Error(`serve.json is locked (${lock}). Try again.`);
+            await new Promise((r) => setTimeout(r, 25));
+        }
+    }
+}
+export function hashToken(token) {
+    return createHash("sha256").update(token, "utf8").digest("hex");
+}
+export function newToken() {
+    return `${TOKEN_PREFIX}${randomBytes(32).toString("base64url")}`;
+}
+/**
+ * `30d`, `12h`, `10m`, `45s`, `500ms`; a bare number is seconds.
+ * Returns milliseconds, or undefined when the text is not a duration.
+ */
+export function parseDuration(raw) {
+    const m = /^(\d+(?:\.\d+)?)(ms|s|m|h|d)?$/i.exec(raw.trim());
+    if (!m)
+        return undefined;
+    const n = Number(m[1]);
+    const unit = (m[2] ?? "s").toLowerCase();
+    const scale = { ms: 1, s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 };
+    const ms = n * (scale[unit] ?? 1000);
+    return Number.isFinite(ms) ? Math.round(ms) : undefined;
+}
+export async function addToken(name, expiresInMs) {
+    if (!isValidServeName(name)) {
+        throw new Error(`Invalid token name "${name}" (1–40 of letters, digits, ".", "_", "-").`);
+    }
+    return withStoreLock(async () => {
+        const store = await loadServeStore();
+        if (store.tokens.some((t) => t.name.toLowerCase() === name.toLowerCase())) {
+            throw new Error(`A token named "${name}" already exists. Remove it first: ollanet serve token rm ${name}`);
+        }
+        const token = newToken();
+        const now = Date.now();
+        const record = {
+            name,
+            sha256: hashToken(token),
+            created_at: new Date(now).toISOString(),
+            expires_at: expiresInMs ? new Date(now + expiresInMs).toISOString() : null,
+        };
+        store.tokens.push(record);
+        const file = await saveServeStore(store);
+        return { token, record, file };
+    });
+}
+export async function removeToken(name) {
+    return (await removeTokens([name])).length > 0;
+}
+/** Remove several tokens in one write. Returns the names actually removed. */
+export async function removeTokens(names) {
+    const wanted = new Set(names.map((n) => n.toLowerCase()));
+    return withStoreLock(async () => {
+        const store = await loadServeStore();
+        const removed = store.tokens.filter((t) => wanted.has(t.name.toLowerCase())).map((t) => t.name);
+        if (removed.length === 0)
+            return [];
+        store.tokens = store.tokens.filter((t) => !wanted.has(t.name.toLowerCase()));
+        await saveServeStore(store);
+        return removed;
+    });
+}
+/**
+ * Merge last-used times into serve.json. Re-reads the file first and touches
+ * only `last_used` on tokens matched by hash, so token add/rm from the CLI in
+ * the meantime is kept (a removed token simply is not written back). Never
+ * moves a time backwards. Atomic via temp file + rename.
+ */
+export async function recordLastUsed(usedBySha) {
+    if (usedBySha.size === 0)
+        return;
+    await withStoreLock(async () => {
+        const store = await loadServeStore();
+        let changed = false;
+        for (const t of store.tokens) {
+            const used = usedBySha.get(t.sha256);
+            if (!used)
+                continue;
+            if (!t.last_used || Date.parse(used) > Date.parse(t.last_used)) {
+                t.last_used = used;
+                changed = true;
+            }
+        }
+        if (changed)
+            await saveServeStore(store);
+    });
+}
+/** Last use, else creation: the clock for `token prune --unused-days`. */
+export function lastActivity(token) {
+    return Date.parse(token.last_used ?? token.created_at);
+}
+export async function setLabel(machine, label) {
+    if (!isValidServeName(label)) {
+        throw new Error(`Invalid label "${label}" (1–40 of letters, digits, ".", "_", "-").`);
+    }
+    await withStoreLock(async () => {
+        const store = await loadServeStore();
+        store.labels[machine.trim().toLowerCase()] = label;
+        await saveServeStore(store);
+    });
+}
+export async function removeLabel(machine) {
+    const key = machine.trim().toLowerCase();
+    return withStoreLock(async () => {
+        const store = await loadServeStore();
+        if (!(key in store.labels))
+            return false;
+        delete store.labels[key];
+        await saveServeStore(store);
+        return true;
+    });
+}
+export function isExpired(token, now = Date.now()) {
+    return token.expires_at != null && Date.parse(token.expires_at) <= now;
+}
+/**
+ * Find the token matching `presented`. Compares the SHA-256 digest against
+ * every stored hash with timingSafeEqual (no early exit). Expired tokens never
+ * match.
+ */
+export function matchToken(tokens, presented, now = Date.now()) {
+    const digest = createHash("sha256").update(presented, "utf8").digest();
+    let hit;
+    for (const t of tokens) {
+        const stored = Buffer.from(t.sha256, "hex");
+        if (stored.length !== digest.length)
+            continue;
+        if (timingSafeEqual(stored, digest) && !hit)
+            hit = t;
+    }
+    return hit && !isExpired(hit, now) ? hit : undefined;
+}

package/dist/serve.d.ts

@@ -0,0 +1,108 @@
+import { type ModelAlias } from "./config.js";
+import { type ScannedServer } from "./scan.js";
+import { type ServeToken } from "./serve-store.js";
+export declare function helpText(): string;
+export interface CatalogModel {
+    name: string;
+    size?: number;
+    parameter_size?: string;
+    quantization_level?: string;
+    family?: string;
+    capabilities?: string[];
+    tuned: boolean;
+}
+export interface CatalogHost {
+    label: string;
+    models: CatalogModel[];
+}
+export interface CatalogAlias {
+    name: string;
+    /** Host label the alias points at, or null if that machine was not in the scan. */
+    host: string | null;
+    model: string;
+}
+export interface Catalog {
+    generated_at: string;
+    scanned_at: string | null;
+    hosts: CatalogHost[];
+    aliases: CatalogAlias[];
+}
+/** Capabilities cache key (internal only; never serialized). */
+export declare function capsKey(server: ScannedServer, model: string): string;
+/**
+ * Pick an opaque label per server: serve label, else the first alias name
+ * (sorted) pointing at it, else host-N. Labels are unique.
+ */
+export declare function hostLabels(servers: ScannedServer[], aliases: Record<string, ModelAlias>, labels: Record<string, string>): string[];
+/**
+ * Build the sanitized catalog. Only allow-listed fields are copied, so new
+ * scan fields cannot leak by accident.
+ */
+export declare function buildCatalog(input: {
+    servers: ScannedServer[];
+    scannedAt: string | null;
+    aliases: Record<string, ModelAlias>;
+    labels: Record<string, string>;
+    capabilities?: Map<string, string[]>;
+}): Catalog;
+export declare function isLoopbackHost(host: string): boolean;
+export declare function parseListen(raw: string): {
+    host: string;
+    port: number;
+};
+export interface ServeOptions {
+    host: string;
+    port: number;
+    /** Re-scan interval; 0 = never (serve the last scan only). */
+    refreshMs: number;
+    /** Requests per minute per token. */
+    rate: number;
+    log?: (line: string) => void;
+    /** Minimum gap between serve.json writes of a token's last use (default 60s). */
+    lastUsedFlushMs?: number;
+}
+export interface ServeHandle {
+    url: string;
+    port: number;
+    catalog(): Catalog;
+    refresh(rescan: boolean): Promise<void>;
+    close(): Promise<void>;
+}
+export declare function startServe(opts: ServeOptions): Promise<ServeHandle>;
+export interface ServeState {
+    pid: number;
+    url: string;
+    funnel_url: string | null;
+    started_at: string;
+}
+export declare function serveStatePath(): string;
+/** "never", "just now", "5m ago", "3h ago", "12d ago". */
+export declare function relativeTime(iso: string | null | undefined, now?: number): string;
+/** Aligned token table: NAME, CREATED, EXPIRES, LAST USED (optionally numbered). */
+export declare function tokenTable(tokens: ServeToken[], opts?: {
+    numbered?: boolean;
+    now?: number;
+}): string;
+/**
+ * Parse a pick like "1,3", "2-4", "1 3", or "all" against a list of `count`.
+ * Returns 0-based indices ([] for an empty answer = cancel), or an error string.
+ */
+export declare function parseSelection(input: string, count: number): number[] | string;
+type Ask = (question: string) => Promise<string>;
+/**
+ * Numbered pick + y/N confirm. Returns the names to remove ([] = nothing).
+ * Throws on an invalid pick. `ask` and `write` are injectable for tests.
+ */
+export declare function chooseTokensToRemove(tokens: ServeToken[], ask: Ask, write: (text: string) => void): Promise<string[]>;
+/** `token prune` with no flags removes expired tokens and these. */
+export declare const DEFAULT_PRUNE_UNUSED_DAYS = 30;
+/** Tokens `prune` would remove, with a reason each. */
+export declare function pruneCandidates(tokens: ServeToken[], opts: {
+    expired: boolean;
+    unusedDays?: number;
+}, now?: number): Array<{
+    token: ServeToken;
+    reason: string;
+}>;
+export declare function main(): Promise<void>;
+export {};