@cryptiklemur/lattice 4.0.2 → 5.0.1

package/dist/server/project/terminal.js

@@ -0,0 +1,87 @@
+import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+var __dirname_local = dirname(fileURLToPath(import.meta.url));
+var terminals = new Map();
+var WORKER_PATH = join(__dirname_local, "pty-worker.cjs");
+var NODE_MODULES_PATH = (function () {
+    try {
+        var resolved = require.resolve("node-pty");
+        var parts = resolved.split("/node_modules/");
+        parts.pop();
+        return parts.join("/node_modules/") + "/node_modules";
+    }
+    catch {
+        return join(__dirname_local, "..", "..", "..", "node_modules");
+    }
+})();
+export function createTerminal(cwd, onData, onExit) {
+    var termId = randomUUID();
+    var child = spawn("node", [WORKER_PATH], {
+        stdio: ["pipe", "pipe", "ignore"],
+        cwd: cwd,
+        env: { ...process.env, NODE_PATH: NODE_MODULES_PATH },
+    });
+    var buffer = "";
+    child.stdout.setEncoding("utf-8");
+    child.stdout.on("data", function (chunk) {
+        buffer += chunk;
+        var lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (var i = 0; i < lines.length; i++) {
+            if (!lines[i].trim())
+                continue;
+            try {
+                var msg = JSON.parse(lines[i]);
+                if (msg.type === "data") {
+                    onData(msg.data);
+                }
+                else if (msg.type === "exit") {
+                    terminals.delete(termId);
+                    onExit(msg.code ?? 0);
+                }
+            }
+            catch {
+                // ignore parse errors
+            }
+        }
+    });
+    child.on("exit", function () {
+        if (terminals.has(termId)) {
+            terminals.delete(termId);
+            onExit(0);
+        }
+    });
+    function sendMsg(msg) {
+        if (child.stdin && !child.stdin.destroyed) {
+            child.stdin.write(JSON.stringify(msg) + "\n");
+        }
+    }
+    terminals.set(termId, { process: child, send: sendMsg });
+    // Tell the worker to create the PTY
+    sendMsg({ type: "create", cwd: cwd, cols: 80, rows: 24 });
+    return termId;
+}
+export function writeToTerminal(termId, data) {
+    var worker = terminals.get(termId);
+    if (worker) {
+        worker.send({ type: "input", data: data });
+    }
+}
+export function resizeTerminal(termId, cols, rows) {
+    var worker = terminals.get(termId);
+    if (worker) {
+        worker.send({ type: "resize", cols: cols, rows: rows });
+    }
+}
+export function destroyTerminal(termId) {
+    var worker = terminals.get(termId);
+    if (worker) {
+        worker.send({ type: "kill" });
+        terminals.delete(termId);
+    }
+}
+export function getTerminal(termId) {
+    return terminals.get(termId);
+}

package/dist/server/project/warmup.js

@@ -0,0 +1,242 @@
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import { broadcast } from "../ws/broadcast.js";
+import { log } from "../logger.js";
+import { loadConfig } from "../config.js";
+import { listSessions, loadSessionHistory } from "./session.js";
+import { execSync } from "node:child_process";
+import { existsSync, unlinkSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+var claudeExePath = null;
+function getClaudeExecutablePath() {
+    if (claudeExePath)
+        return claudeExePath;
+    try {
+        claudeExePath = execSync("which claude", { encoding: "utf-8" }).trim();
+    }
+    catch {
+        claudeExePath = "claude";
+    }
+    return claudeExePath;
+}
+var KNOWN_MODELS = [
+    { value: "default", displayName: "Default" },
+    { value: "opus", displayName: "Opus" },
+    { value: "sonnet", displayName: "Sonnet" },
+    { value: "haiku", displayName: "Haiku" },
+];
+var warmupModels = [];
+var warmupSlashCommands = [];
+var warmupAccountInfo = null;
+var warmupComplete = false;
+var warmupRateLimits = new Map();
+function ensureKnownModels(sdkModels) {
+    var seen = new Set();
+    for (var i = 0; i < sdkModels.length; i++) {
+        seen.add(sdkModels[i].value);
+    }
+    var result = sdkModels.slice();
+    for (var j = 0; j < KNOWN_MODELS.length; j++) {
+        if (!seen.has(KNOWN_MODELS[j].value)) {
+            result.push(KNOWN_MODELS[j]);
+        }
+    }
+    return result;
+}
+function deleteWarmupSession(cwd, sessionId) {
+    if (!sessionId)
+        return;
+    try {
+        var hash = cwd.replace(/\//g, "-");
+        var projectDir = join(homedir(), ".claude", "projects", hash);
+        var jsonlPath = join(projectDir, sessionId + ".jsonl");
+        var dirPath = join(projectDir, sessionId);
+        if (existsSync(jsonlPath)) {
+            unlinkSync(jsonlPath);
+            log.server("Deleted warmup session file: %s", sessionId);
+        }
+        if (existsSync(dirPath)) {
+            rmSync(dirPath, { recursive: true, force: true });
+        }
+    }
+    catch (err) {
+        log.server("Failed to delete warmup session: %O", err);
+    }
+}
+export async function runWarmup(cwd) {
+    log.server("SDK warmup starting (cwd: %s)...", cwd);
+    try {
+        var ac = new AbortController();
+        var ended = false;
+        var WARMUP_SESSION_ID = "lattice-warmup";
+        var mq = {
+            [Symbol.asyncIterator]: function () {
+                return {
+                    next: function () {
+                        if (ended)
+                            return Promise.resolve({ value: undefined, done: true });
+                        ended = true;
+                        return Promise.resolve({
+                            value: {
+                                type: "user",
+                                message: { role: "user", content: [{ type: "text", text: "hi" }] },
+                                parent_tool_use_id: null,
+                                session_id: WARMUP_SESSION_ID,
+                            },
+                            done: false,
+                        });
+                    },
+                };
+            },
+        };
+        var stream = query({
+            prompt: mq,
+            options: {
+                cwd,
+                sessionId: WARMUP_SESSION_ID,
+                settingSources: ["user", "project", "local"],
+                abortController: ac,
+                permissionMode: "plan",
+                pathToClaudeCodeExecutable: getClaudeExecutablePath(),
+                stderr: function (data) {
+                    log.server("Warmup stderr: %s", data.trim());
+                },
+            },
+        });
+        for await (var msg of stream) {
+            if (msg.type === "system") {
+                var sysMsg = msg;
+                if (sysMsg.subtype === "init") {
+                    if (sysMsg.slash_commands) {
+                        warmupSlashCommands = sysMsg.slash_commands;
+                    }
+                    try {
+                        var models = await stream.supportedModels();
+                        warmupModels = ensureKnownModels((models || []));
+                    }
+                    catch {
+                        warmupModels = KNOWN_MODELS.slice();
+                    }
+                    try {
+                        warmupAccountInfo = await stream.accountInfo();
+                    }
+                    catch { }
+                    ac.abort();
+                    break;
+                }
+            }
+            if (msg.type === "rate_limit_event") {
+                var rlMsg = msg;
+                var rli = rlMsg.rate_limit_info;
+                var cacheKey = rli.rateLimitType || "default";
+                warmupRateLimits.set(cacheKey, {
+                    status: rli.status,
+                    utilization: rli.utilization,
+                    resetsAt: rli.resetsAt,
+                    rateLimitType: rli.rateLimitType,
+                    overageStatus: rli.overageStatus,
+                    overageResetsAt: rli.overageResetsAt,
+                    isUsingOverage: rli.isUsingOverage,
+                });
+                broadcast({
+                    type: "chat:rate_limit",
+                    status: rli.status,
+                    utilization: rli.utilization,
+                    resetsAt: rli.resetsAt,
+                    rateLimitType: rli.rateLimitType,
+                    overageStatus: rli.overageStatus,
+                    overageResetsAt: rli.overageResetsAt,
+                    isUsingOverage: rli.isUsingOverage,
+                });
+            }
+        }
+        warmupComplete = true;
+        deleteWarmupSession(cwd, WARMUP_SESSION_ID);
+        log.server("SDK warmup complete: %d models, %d commands, auth=%s", warmupModels.length, warmupSlashCommands.length, warmupAccountInfo?.apiKeySource || "unknown");
+        if (warmupAccountInfo) {
+            log.server("Account: email=%s org=%s subscription=%s provider=%s source=%s", warmupAccountInfo.email || "none", warmupAccountInfo.organization || "none", warmupAccountInfo.subscriptionType || "none", warmupAccountInfo.apiProvider || "none", warmupAccountInfo.apiKeySource || "none");
+        }
+        broadcast({
+            type: "warmup:models",
+            models: warmupModels,
+        });
+        if (warmupAccountInfo) {
+            broadcast({
+                type: "warmup:account",
+                email: warmupAccountInfo.email,
+                organization: warmupAccountInfo.organization,
+                subscriptionType: warmupAccountInfo.subscriptionType,
+                apiKeySource: warmupAccountInfo.apiKeySource,
+                apiProvider: warmupAccountInfo.apiProvider,
+            });
+        }
+        void warmupProjectData();
+    }
+    catch (err) {
+        if (err && err.name !== "AbortError" && !(err instanceof Error && err.message.includes("aborted"))) {
+            log.server("SDK warmup failed: %O", err);
+        }
+        warmupModels = KNOWN_MODELS.slice();
+        warmupComplete = true;
+        void warmupProjectData();
+    }
+}
+async function warmupProjectData() {
+    var t0 = Date.now();
+    var config = loadConfig();
+    var projects = config.projects;
+    if (projects.length === 0)
+        return;
+    log.server("Data warmup: pre-caching %d project(s)...", projects.length);
+    var totalSessions = 0;
+    var recentSessionIds = [];
+    for (var i = 0; i < projects.length; i++) {
+        try {
+            var result = await listSessions(projects[i].slug, { limit: 40 });
+            totalSessions += result.sessions.length;
+            broadcast({
+                type: "session:list",
+                projectSlug: projects[i].slug,
+                sessions: result.sessions,
+                totalCount: result.totalCount,
+            });
+            var preWarmCount = Math.min(5, result.sessions.length);
+            for (var k = 0; k < preWarmCount; k++) {
+                recentSessionIds.push({
+                    projectSlug: projects[i].slug,
+                    sessionId: result.sessions[k].id,
+                });
+            }
+        }
+        catch { }
+    }
+    log.server("Data warmup: cached %d sessions across %d projects (%dms)", totalSessions, projects.length, Date.now() - t0);
+    for (var j = 0; j < recentSessionIds.length; j++) {
+        try {
+            await loadSessionHistory(recentSessionIds[j].projectSlug, recentSessionIds[j].sessionId);
+        }
+        catch { }
+    }
+    if (recentSessionIds.length > 0) {
+        log.server("Data warmup: pre-cached history for %d recent sessions (%dms)", recentSessionIds.length, Date.now() - t0);
+    }
+}
+export function getWarmupModels() {
+    return warmupModels.length > 0 ? warmupModels : KNOWN_MODELS.slice();
+}
+export function getWarmupSlashCommands() {
+    return warmupSlashCommands;
+}
+export function getWarmupAccountInfo() {
+    return warmupAccountInfo;
+}
+export function getWarmupRateLimits() {
+    return Array.from(warmupRateLimits.values());
+}
+export function cacheRateLimitEntry(entry) {
+    var key = entry.rateLimitType || "default";
+    warmupRateLimits.set(key, entry);
+}
+export function isWarmupComplete() {
+    return warmupComplete;
+}

package/dist/server/push.js

@@ -0,0 +1,87 @@
+import webpush from "web-push";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { getLatticeHome } from "./config.js";
+import { log } from "./logger.js";
+var vapidKeys = null;
+var subscriptions = new Map();
+function getVapidPath() {
+    return join(getLatticeHome(), "vapid.json");
+}
+function getSubscriptionsPath() {
+    return join(getLatticeHome(), "push-subs.json");
+}
+function ensureVapidKeys() {
+    if (vapidKeys)
+        return vapidKeys;
+    var vapidPath = getVapidPath();
+    if (existsSync(vapidPath)) {
+        try {
+            vapidKeys = JSON.parse(readFileSync(vapidPath, "utf-8"));
+            if (vapidKeys)
+                return vapidKeys;
+        }
+        catch { }
+    }
+    var generated = webpush.generateVAPIDKeys();
+    vapidKeys = {
+        publicKey: generated.publicKey,
+        privateKey: generated.privateKey,
+    };
+    var dir = getLatticeHome();
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(vapidPath, JSON.stringify(vapidKeys, null, 2), "utf-8");
+    log.server("Generated VAPID keys for push notifications");
+    return vapidKeys;
+}
+function loadSubscriptions() {
+    var subsPath = getSubscriptionsPath();
+    if (!existsSync(subsPath))
+        return;
+    try {
+        var data = JSON.parse(readFileSync(subsPath, "utf-8"));
+        for (var i = 0; i < data.length; i++) {
+            subscriptions.set(data[i].endpoint, data[i]);
+        }
+    }
+    catch { }
+}
+function saveSubscriptions() {
+    var arr = [];
+    subscriptions.forEach(function (sub) {
+        arr.push(sub);
+    });
+    writeFileSync(getSubscriptionsPath(), JSON.stringify(arr), "utf-8");
+}
+export function initPush() {
+    var keys = ensureVapidKeys();
+    webpush.setVapidDetails("mailto:lattice@localhost", keys.publicKey, keys.privateKey);
+    loadSubscriptions();
+    log.server("Push notifications ready (%d subscription(s))", subscriptions.size);
+}
+export function getVapidPublicKey() {
+    return ensureVapidKeys().publicKey;
+}
+export function addPushSubscription(sub) {
+    subscriptions.set(sub.endpoint, sub);
+    saveSubscriptions();
+}
+export function removePushSubscription(endpoint) {
+    subscriptions.delete(endpoint);
+    saveSubscriptions();
+}
+export function sendPush(payload) {
+    if (subscriptions.size === 0)
+        return;
+    var json = JSON.stringify(payload);
+    subscriptions.forEach(function (sub, endpoint) {
+        webpush.sendNotification(sub, json).catch(function (err) {
+            if (err.statusCode === 410 || err.statusCode === 404 || err.statusCode === 403) {
+                subscriptions.delete(endpoint);
+                saveSubscriptions();
+            }
+        });
+    });
+}

package/dist/server/tls.js

@@ -0,0 +1,50 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { getLatticeHome } from "./config.js";
+export function getCertsDir() {
+    var certsDir = join(getLatticeHome(), "certs");
+    if (!existsSync(certsDir)) {
+        mkdirSync(certsDir, { recursive: true });
+    }
+    return certsDir;
+}
+function isCertExpiringSoon(certPath) {
+    try {
+        var result = spawnSync("openssl", ["x509", "-enddate", "-noout", "-in", certPath], { encoding: "utf-8" });
+        if (result.status !== 0)
+            return true;
+        var match = result.stdout.match(/notAfter=(.+)/);
+        if (!match)
+            return true;
+        var expiryDate = new Date(match[1]);
+        var daysLeft = (expiryDate.getTime() - Date.now()) / (1000 * 60 * 60 * 24);
+        return daysLeft < 30;
+    }
+    catch {
+        return true;
+    }
+}
+export function ensureCerts() {
+    var certsDir = getCertsDir();
+    var certPath = join(certsDir, "cert.pem");
+    var keyPath = join(certsDir, "key.pem");
+    if (existsSync(certPath) && existsSync(keyPath) && !isCertExpiringSoon(certPath)) {
+        return { cert: certPath, key: keyPath };
+    }
+    console.log("[lattice] Generating self-signed TLS certificate...");
+    var result = spawnSync("openssl", [
+        "req", "-x509",
+        "-newkey", "rsa:2048",
+        "-keyout", keyPath,
+        "-out", certPath,
+        "-days", "365",
+        "-nodes",
+        "-subj", "/CN=lattice",
+    ], { encoding: "utf-8" });
+    if (result.status !== 0) {
+        throw new Error("[lattice] Failed to generate TLS certificates: " + (result.stderr || result.error?.message || "unknown error"));
+    }
+    console.log("[lattice] TLS certificates generated at " + certsDir);
+    return { cert: certPath, key: keyPath };
+}

package/dist/server/tui.js

@@ -0,0 +1,83 @@
+import * as p from "@clack/prompts";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { getLatticeHome, loadConfig, saveConfig } from "./config.js";
+import { DEFAULT_PORT } from "#shared";
+var BANNER = `
+  \x1b[36m██╗\x1b[0m      \x1b[36m█████╗\x1b[0m \x1b[36m████████╗████████╗██╗\x1b[0m \x1b[36m██████╗\x1b[0m \x1b[36m███████╗\x1b[0m
+  \x1b[36m██║\x1b[0m     \x1b[36m██╔══██╗\x1b[0m\x1b[2m╚══\x1b[0m\x1b[36m██\x1b[0m\x1b[2m╔══╝╚══\x1b[0m\x1b[36m██\x1b[0m\x1b[2m╔══╝\x1b[0m\x1b[36m██║\x1b[0m\x1b[36m██╔════╝\x1b[0m\x1b[36m██╔════╝\x1b[0m
+  \x1b[36m██║\x1b[0m     \x1b[36m███████║\x1b[0m   \x1b[36m██║\x1b[0m      \x1b[36m██║\x1b[0m   \x1b[36m██║██║\x1b[0m     \x1b[36m█████╗\x1b[0m
+  \x1b[36m██║\x1b[0m     \x1b[36m██╔══██║\x1b[0m   \x1b[36m██║\x1b[0m      \x1b[36m██║\x1b[0m   \x1b[36m██║██║\x1b[0m     \x1b[36m██╔══╝\x1b[0m
+  \x1b[36m███████╗██║  ██║\x1b[0m   \x1b[36m██║\x1b[0m      \x1b[36m██║\x1b[0m   \x1b[36m██║\x1b[0m\x1b[2m╚\x1b[0m\x1b[36m██████╗███████╗\x1b[0m
+  \x1b[2m╚══════╝╚═╝  ╚═╝   ╚═╝      ╚═╝   ╚═╝ ╚═════╝╚══════╝\x1b[0m
+`;
+export function printBanner() {
+    console.log(BANNER);
+}
+export function printStatus(config, version, projectCount, sessionCount) {
+    var protocol = config.tls ? "https" : "http";
+    var url = protocol + "://localhost:" + config.port;
+    console.log("");
+    p.note("lattice v" + version + " — " + url + "\n" +
+        projectCount + " project" + (projectCount !== 1 ? "s" : "") +
+        " · " + sessionCount + " session" + (sessionCount !== 1 ? "s" : "") + "\n" +
+        "Press Ctrl+C to stop", "Running");
+    console.log("");
+}
+export async function printQrCode(url) {
+    try {
+        var qrcode = await import("qrcode");
+        var qr = await qrcode.toString(url, {
+            type: "terminal",
+            small: true,
+        });
+        console.log(qr);
+        console.log("  \x1b[2m" + url + "\x1b[0m");
+        console.log("");
+    }
+    catch {
+        console.log("  " + url);
+        console.log("");
+    }
+}
+export async function runOnboarding() {
+    var configPath = join(getLatticeHome(), "config.json");
+    var isFirstRun = !existsSync(configPath);
+    if (!isFirstRun) {
+        var config = loadConfig();
+        return { port: config.port, passphrase: null };
+    }
+    printBanner();
+    p.intro("Welcome to Lattice");
+    p.note("Anyone with the URL gets full Claude Code access to this machine.\n" +
+        "Use a private network (Tailscale, VPN) or set a passphrase.", "Security");
+    var portResult = await p.text({
+        message: "Port",
+        placeholder: String(DEFAULT_PORT),
+        defaultValue: String(DEFAULT_PORT),
+        validate: function (val) {
+            var n = parseInt(val || "", 10);
+            if (isNaN(n) || n < 1 || n > 65535)
+                return "Enter a valid port (1-65535)";
+            return undefined;
+        },
+    });
+    if (p.isCancel(portResult)) {
+        p.cancel("Setup cancelled");
+        process.exit(0);
+    }
+    var port = parseInt(portResult, 10);
+    var passphraseResult = await p.password({
+        message: "Passphrase (optional, press Enter to skip)",
+    });
+    if (p.isCancel(passphraseResult)) {
+        p.cancel("Setup cancelled");
+        process.exit(0);
+    }
+    var passphrase = passphraseResult || null;
+    p.outro("Setup complete");
+    var config = loadConfig();
+    config.port = port;
+    saveConfig(config);
+    return { port, passphrase };
+}

package/dist/server/update-checker.js

@@ -0,0 +1,119 @@
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { log } from "./logger.js";
+var __dirname_local = dirname(fileURLToPath(import.meta.url));
+var PKG_NAME = "@cryptiklemur/lattice";
+var GITHUB_REPO = "cryptiklemur/lattice";
+var CHECK_INTERVAL_MS = 3600000;
+var cached = null;
+var checking = false;
+function getCurrentVersion() {
+    if (process.env.LATTICE_VERSION)
+        return process.env.LATTICE_VERSION;
+    try {
+        var pkg = JSON.parse(readFileSync(join(__dirname_local, "../../package.json"), "utf-8"));
+        return pkg.version || "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+function compareVersions(a, b) {
+    if (!a || !b || typeof a !== "string" || typeof b !== "string")
+        return 0;
+    var pa = a.replace(/^v/, "").split(".").map(Number);
+    var pb = b.replace(/^v/, "").split(".").map(Number);
+    for (var i = 0; i < 3; i++) {
+        var va = pa[i] || 0;
+        var vb = pb[i] || 0;
+        if (va !== vb)
+            return va - vb;
+    }
+    return 0;
+}
+export function getInstallMode() {
+    return "npm";
+}
+async function checkGitHub(currentVersion) {
+    var res = await fetch("https://api.github.com/repos/" + GITHUB_REPO + "/releases/latest", {
+        headers: { "Accept": "application/vnd.github.v3+json" },
+        signal: AbortSignal.timeout(10000),
+    });
+    if (!res.ok) {
+        console.error("[lattice] GitHub update check failed: HTTP " + res.status);
+        return { currentVersion, latestVersion: null, updateAvailable: false, lastCheckedAt: Date.now(), releaseUrl: null, installMode: "binary" };
+    }
+    var data = await res.json();
+    var latestVersion = data.tag_name ? data.tag_name.replace(/^v/, "") : null;
+    var updateAvailable = latestVersion !== null && compareVersions(latestVersion, currentVersion) > 0;
+    return {
+        currentVersion,
+        latestVersion,
+        updateAvailable,
+        lastCheckedAt: Date.now(),
+        releaseUrl: updateAvailable ? (data.html_url ?? null) : null,
+        installMode: "binary",
+    };
+}
+async function checkNpm(currentVersion) {
+    var res = await fetch("https://registry.npmjs.org/" + PKG_NAME + "/latest", {
+        headers: { "Accept": "application/json" },
+        signal: AbortSignal.timeout(10000),
+    });
+    if (!res.ok) {
+        console.error("[lattice] npm update check failed: HTTP " + res.status);
+        return { currentVersion, latestVersion: null, updateAvailable: false, lastCheckedAt: Date.now(), releaseUrl: null, installMode: "npm" };
+    }
+    var data = await res.json();
+    var latestVersion = data.version ?? null;
+    var updateAvailable = latestVersion !== null && compareVersions(latestVersion, currentVersion) > 0;
+    return {
+        currentVersion,
+        latestVersion,
+        updateAvailable,
+        lastCheckedAt: Date.now(),
+        releaseUrl: updateAvailable ? "https://github.com/" + GITHUB_REPO + "/releases/tag/v" + latestVersion : null,
+        installMode: "npm",
+    };
+}
+export async function checkForUpdate(force = false) {
+    var currentVersion = getCurrentVersion();
+    if (!force && cached && Date.now() - cached.lastCheckedAt < CHECK_INTERVAL_MS) {
+        return cached;
+    }
+    if (checking) {
+        return cached ?? { currentVersion, latestVersion: null, updateAvailable: false, lastCheckedAt: 0, releaseUrl: null, installMode: getInstallMode() };
+    }
+    checking = true;
+    try {
+        cached = await checkNpm(currentVersion);
+        if (cached.updateAvailable) {
+            log.server("Update available: %s -> %s (%s)", currentVersion, cached.latestVersion, cached.installMode);
+        }
+        return cached;
+    }
+    catch (err) {
+        console.error("[lattice] Update check error: " + (err instanceof Error ? err.message : String(err)));
+        cached = { currentVersion, latestVersion: null, updateAvailable: false, lastCheckedAt: Date.now(), releaseUrl: null, installMode: getInstallMode() };
+        return cached;
+    }
+    finally {
+        checking = false;
+    }
+}
+export function getCachedUpdateInfo() {
+    return cached;
+}
+export function getPackageName() {
+    return PKG_NAME;
+}
+export function getGitHubRepo() {
+    return GITHUB_REPO;
+}
+export function startPeriodicUpdateCheck() {
+    void checkForUpdate();
+    setInterval(function () {
+        void checkForUpdate();
+    }, CHECK_INTERVAL_MS);
+}