gnosys 5.11.4 → 5.12.2

package/dist/lib/syncIngestLaunchd.js

@@ -0,0 +1,93 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { execSync } from "child_process";
+const LABEL = "com.gnosys.sync-ingest";
+function plistPath() {
+    return path.join(os.homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
+}
+function logPath() {
+    return path.join(os.tmpdir(), "gnosys-sync-ingest.log");
+}
+function xmlEscape(value) {
+    return value
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+/** Build launchd plist XML (testable without writing to disk). */
+export function buildSyncIngestLaunchAgentPlist(intervalMinutes) {
+    const nodePath = process.execPath;
+    const cliPath = process.argv[1] || "gnosys";
+    const intervalSec = Math.max(1, intervalMinutes) * 60;
+    const pathEnv = `${path.dirname(nodePath)}:/usr/local/bin:/usr/bin:/bin`;
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${xmlEscape(nodePath)}</string>
+    <string>${xmlEscape(cliPath)}</string>
+    <string>setup</string>
+    <string>remote</string>
+    <string>doctor</string>
+    <string>--ingest</string>
+    <string>--quiet</string>
+  </array>
+  <key>StartInterval</key>
+  <integer>${intervalSec}</integer>
+  <key>StandardOutPath</key>
+  <string>${xmlEscape(logPath())}</string>
+  <key>StandardErrorPath</key>
+  <string>${xmlEscape(logPath())}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>HOME</key>
+    <string>${xmlEscape(os.homedir())}</string>
+    <key>PATH</key>
+    <string>${xmlEscape(pathEnv)}</string>
+  </dict>
+</dict>
+</plist>
+`;
+}
+export function installSyncIngestLaunchAgent(intervalMinutes = 15) {
+    if (process.platform !== "darwin")
+        return null;
+    const file = plistPath();
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, buildSyncIngestLaunchAgentPlist(intervalMinutes), "utf8");
+    try {
+        execSync(`launchctl load -w "${file}"`, { stdio: "ignore" });
+    }
+    catch (err) {
+        throw new Error(`Failed to load launch agent: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return file;
+}
+export function uninstallSyncIngestLaunchAgent() {
+    if (process.platform !== "darwin")
+        return null;
+    const file = plistPath();
+    try {
+        execSync(`launchctl unload "${file}"`, { stdio: "ignore" });
+    }
+    catch {
+        // Already unloaded or missing.
+    }
+    try {
+        fs.unlinkSync(file);
+    }
+    catch {
+        // Missing is already uninstalled.
+    }
+    return file;
+}
+export function getSyncIngestLaunchAgentStatus() {
+    const file = plistPath();
+    return { installed: fs.existsSync(file), path: file };
+}

package/dist/lib/syncIngestStartup.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Run one ingest sweep on MCP server startup (master role only).
+ * Non-blocking — callers should fire-and-forget.
+ */
+export declare function maybeRunStartupIngestSweep(): Promise<void>;

package/dist/lib/syncIngestStartup.js

@@ -0,0 +1,29 @@
+import { GnosysDB } from "./db.js";
+import { readMachineConfig } from "./machineConfig.js";
+import { getConfiguredRemotePath } from "./remote.js";
+import { runMasterIngestSweepAndPublish } from "./syncIngest.js";
+/**
+ * Run one ingest sweep on MCP server startup (master role only).
+ * Non-blocking — callers should fire-and-forget.
+ */
+export async function maybeRunStartupIngestSweep() {
+    const mc = readMachineConfig();
+    if (!mc?.remote.enabled || mc.remote.role !== "master")
+        return;
+    const db = GnosysDB.openLocal();
+    let masterPath = null;
+    try {
+        if (!db.isAvailable())
+            return;
+        masterPath = getConfiguredRemotePath(db);
+    }
+    finally {
+        db.close();
+    }
+    if (!masterPath)
+        return;
+    const result = await runMasterIngestSweepAndPublish(masterPath, { quiet: true });
+    if (result.errors.length > 0) {
+        console.error(`[sync] Startup ingest sweep: ${result.ingested} ingested, ${result.errors.length} error(s)`);
+    }
+}

package/dist/lib/syncIngestSystemd.d.ts

@@ -0,0 +1,10 @@
+/** Build systemd service unit (testable without writing to disk). */
+export declare function buildSyncIngestSystemdService(): string;
+/** Build systemd timer unit (testable without writing to disk). */
+export declare function buildSyncIngestSystemdTimer(intervalMinutes: number): string;
+export declare function installSyncIngestSystemdTimer(intervalMinutes?: number): string | null;
+export declare function uninstallSyncIngestSystemdTimer(): string | null;
+export declare function getSyncIngestSystemdTimerStatus(): {
+    installed: boolean;
+    path: string;
+};

package/dist/lib/syncIngestSystemd.js

@@ -0,0 +1,97 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { execSync } from "child_process";
+const SERVICE_NAME = "gnosys-sync-ingest";
+function systemdUserDir() {
+    return path.join(os.homedir(), ".config", "systemd", "user");
+}
+function serviceFilePath() {
+    return path.join(systemdUserDir(), `${SERVICE_NAME}.service`);
+}
+function timerFilePath() {
+    return path.join(systemdUserDir(), `${SERVICE_NAME}.timer`);
+}
+function execLine() {
+    const nodePath = process.execPath;
+    const cliPath = process.argv[1] || "gnosys";
+    return `${nodePath} ${cliPath} setup remote doctor --ingest --quiet`;
+}
+/** Build systemd service unit (testable without writing to disk). */
+export function buildSyncIngestSystemdService() {
+    return `[Unit]
+Description=Gnosys sync ingest sweep
+
+[Service]
+Type=oneshot
+ExecStart=${execLine()}
+Environment=HOME=${os.homedir()}
+`;
+}
+/** Build systemd timer unit (testable without writing to disk). */
+export function buildSyncIngestSystemdTimer(intervalMinutes) {
+    const intervalSec = Math.max(1, intervalMinutes) * 60;
+    return `[Unit]
+Description=Gnosys sync ingest timer
+
+[Timer]
+OnBootSec=5min
+OnUnitActiveSec=${intervalSec}s
+
+[Install]
+WantedBy=timers.target
+`;
+}
+export function installSyncIngestSystemdTimer(intervalMinutes = 15) {
+    if (process.platform !== "linux")
+        return null;
+    const dir = systemdUserDir();
+    fs.mkdirSync(dir, { recursive: true });
+    const servicePath = serviceFilePath();
+    const timerPath = timerFilePath();
+    fs.writeFileSync(servicePath, buildSyncIngestSystemdService(), "utf8");
+    fs.writeFileSync(timerPath, buildSyncIngestSystemdTimer(intervalMinutes), "utf8");
+    try {
+        execSync("systemctl --user daemon-reload", { stdio: "ignore" });
+        execSync(`systemctl --user enable --now ${SERVICE_NAME}.timer`, { stdio: "ignore" });
+    }
+    catch (err) {
+        throw new Error(`Failed to enable systemd timer: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return timerPath;
+}
+export function uninstallSyncIngestSystemdTimer() {
+    if (process.platform !== "linux")
+        return null;
+    const servicePath = serviceFilePath();
+    const timerPath = timerFilePath();
+    try {
+        execSync(`systemctl --user disable --now ${SERVICE_NAME}.timer`, { stdio: "ignore" });
+    }
+    catch {
+        // Timer may already be removed.
+    }
+    for (const file of [timerPath, servicePath]) {
+        try {
+            fs.unlinkSync(file);
+        }
+        catch {
+            // Missing is already uninstalled.
+        }
+    }
+    try {
+        execSync("systemctl --user daemon-reload", { stdio: "ignore" });
+    }
+    catch {
+        // Best effort.
+    }
+    return timerPath;
+}
+export function getSyncIngestSystemdTimerStatus() {
+    const timerPath = timerFilePath();
+    const servicePath = serviceFilePath();
+    return {
+        installed: fs.existsSync(timerPath) && fs.existsSync(servicePath),
+        path: timerPath,
+    };
+}

package/dist/lib/syncIngestTimer.d.ts

@@ -0,0 +1,8 @@
+export interface SyncIngestTimerStatus {
+    installed: boolean;
+    path: string;
+    platform: "darwin" | "linux" | "unsupported";
+}
+export declare function getSyncIngestTimerStatus(): SyncIngestTimerStatus;
+export declare function installSyncIngestTimer(intervalMinutes?: number): string | null;
+export declare function uninstallSyncIngestTimer(): string | null;

package/dist/lib/syncIngestTimer.js

@@ -0,0 +1,27 @@
+import { getSyncIngestLaunchAgentStatus, installSyncIngestLaunchAgent, uninstallSyncIngestLaunchAgent, } from "./syncIngestLaunchd.js";
+import { getSyncIngestSystemdTimerStatus, installSyncIngestSystemdTimer, uninstallSyncIngestSystemdTimer, } from "./syncIngestSystemd.js";
+export function getSyncIngestTimerStatus() {
+    if (process.platform === "darwin") {
+        const status = getSyncIngestLaunchAgentStatus();
+        return { ...status, platform: "darwin" };
+    }
+    if (process.platform === "linux") {
+        const status = getSyncIngestSystemdTimerStatus();
+        return { ...status, platform: "linux" };
+    }
+    return { installed: false, path: "", platform: "unsupported" };
+}
+export function installSyncIngestTimer(intervalMinutes = 15) {
+    if (process.platform === "darwin")
+        return installSyncIngestLaunchAgent(intervalMinutes);
+    if (process.platform === "linux")
+        return installSyncIngestSystemdTimer(intervalMinutes);
+    return null;
+}
+export function uninstallSyncIngestTimer() {
+    if (process.platform === "darwin")
+        return uninstallSyncIngestLaunchAgent();
+    if (process.platform === "linux")
+        return uninstallSyncIngestSystemdTimer();
+    return null;
+}

package/dist/lib/syncIngestTimerCommand.d.ts

@@ -0,0 +1,7 @@
+export declare function runSyncIngestTimerCommand(opts: {
+    install?: boolean;
+    uninstall?: boolean;
+    status?: boolean;
+    interval?: string;
+    json?: boolean;
+}): Promise<void>;

package/dist/lib/syncIngestTimerCommand.js

@@ -0,0 +1,83 @@
+import { printStatus } from "./setup/ui/status.js";
+import { getSyncIngestTimerStatus, installSyncIngestTimer, uninstallSyncIngestTimer, } from "./syncIngestTimer.js";
+export async function runSyncIngestTimerCommand(opts) {
+    const intervalMinutes = Math.max(1, parseInt(opts.interval ?? "15", 10) || 15);
+    const timerStatus = getSyncIngestTimerStatus();
+    if (opts.json) {
+        if (opts.install) {
+            try {
+                const path = installSyncIngestTimer(intervalMinutes);
+                console.log(JSON.stringify({
+                    action: "install",
+                    installed: true,
+                    path,
+                    intervalMinutes,
+                    platform: timerStatus.platform,
+                }));
+            }
+            catch (err) {
+                process.exitCode = 1;
+                console.log(JSON.stringify({
+                    action: "install",
+                    installed: false,
+                    error: err instanceof Error ? err.message : String(err),
+                    platform: timerStatus.platform,
+                }));
+            }
+            return;
+        }
+        if (opts.uninstall) {
+            try {
+                const path = uninstallSyncIngestTimer();
+                console.log(JSON.stringify({ action: "uninstall", installed: false, path }));
+            }
+            catch (err) {
+                process.exitCode = 1;
+                console.log(JSON.stringify({
+                    action: "uninstall",
+                    error: err instanceof Error ? err.message : String(err),
+                }));
+            }
+            return;
+        }
+        console.log(JSON.stringify({ ...getSyncIngestTimerStatus(), intervalMinutes }));
+        return;
+    }
+    if (timerStatus.platform === "unsupported") {
+        console.log("OS-level ingest timer is not supported on this platform.");
+        console.log("Windows: use Task Scheduler manually or run `gnosys setup remote doctor --ingest`.");
+        if (opts.install || opts.uninstall)
+            process.exitCode = 1;
+        return;
+    }
+    if (opts.install) {
+        try {
+            const installedPath = installSyncIngestTimer(intervalMinutes);
+            printStatus("ok", `Ingest timer installed (${installedPath}, every ${intervalMinutes} min)`);
+        }
+        catch (err) {
+            printStatus("fail", err instanceof Error ? err.message : String(err));
+            process.exitCode = 1;
+        }
+        return;
+    }
+    if (opts.uninstall) {
+        try {
+            const removedPath = uninstallSyncIngestTimer();
+            printStatus("ok", `Ingest timer uninstalled (${removedPath})`);
+        }
+        catch (err) {
+            printStatus("fail", err instanceof Error ? err.message : String(err));
+            process.exitCode = 1;
+        }
+        return;
+    }
+    const current = getSyncIngestTimerStatus();
+    if (current.installed) {
+        console.log(`Ingest timer: installed (${current.path})`);
+    }
+    else {
+        console.log("Ingest timer: not installed");
+        console.log("Install with: gnosys setup remote timer --install");
+    }
+}

package/dist/lib/syncLock.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Sync advisory lock on the master's **local** ~/.gnosys (never on network share).
+ */
+/** Synchronous ingest lock for master sweep (same directory as lock file). */
+export declare function acquireWriteLockSync(lockPath: string, operation: string): () => void;
+export declare function releaseWriteLockSync(lockPath: string): void;

package/dist/lib/syncLock.js

@@ -0,0 +1,74 @@
+/**
+ * Sync advisory lock on the master's **local** ~/.gnosys (never on network share).
+ */
+import fs from "fs";
+import path from "path";
+const LOCK_STALE_MS = 120_000;
+function readLock(lockPath) {
+    try {
+        const raw = fs.readFileSync(lockPath, "utf-8");
+        const o = JSON.parse(raw);
+        if (typeof o.pid === "number" && typeof o.timestamp === "number")
+            return o;
+    }
+    catch {
+        // no lock
+    }
+    return null;
+}
+function isStale(lock) {
+    if (Date.now() - lock.timestamp > LOCK_STALE_MS)
+        return true;
+    try {
+        process.kill(lock.pid, 0);
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+/** Synchronous ingest lock for master sweep (same directory as lock file). */
+export function acquireWriteLockSync(lockPath, operation) {
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+    const start = Date.now();
+    while (true) {
+        const existing = readLock(lockPath);
+        if (existing && !isStale(existing)) {
+            if (Date.now() - start > 30_000) {
+                throw new Error(`ingest lock timeout (held by pid ${existing.pid})`);
+            }
+            // busy-wait briefly
+            const waitUntil = Date.now() + 50;
+            while (Date.now() < waitUntil) {
+                /* spin */
+            }
+            continue;
+        }
+        if (existing) {
+            try {
+                fs.unlinkSync(lockPath);
+            }
+            catch {
+                // race
+            }
+        }
+        try {
+            fs.writeFileSync(lockPath, JSON.stringify({ pid: process.pid, timestamp: Date.now(), operation }));
+            return () => releaseWriteLockSync(lockPath);
+        }
+        catch {
+            if (Date.now() - start > 30_000)
+                throw new Error("failed to acquire ingest lock");
+        }
+    }
+}
+export function releaseWriteLockSync(lockPath) {
+    try {
+        const existing = readLock(lockPath);
+        if (existing?.pid === process.pid)
+            fs.unlinkSync(lockPath);
+    }
+    catch {
+        // ignore
+    }
+}

package/dist/lib/syncSnapshot.d.ts

@@ -0,0 +1,32 @@
+/**
+ * v13 snapshot publication — immutable DB copies + manifest with epoch fencing.
+ */
+export interface SnapshotManifestFile {
+    epoch: number;
+    seq: number;
+    snapshotFile: string;
+    publishedAt: string;
+    checksum: string;
+    sizeBytes: number;
+}
+export declare function masterSnapshotsDir(masterPath: string): string;
+export declare function clientSnapshotStore(masterPath: string): string;
+/** Read the master's currently published snapshot manifest (null if none). */
+export declare function getMasterManifest(masterPath: string): SnapshotManifestFile | null;
+/** Publish a new immutable snapshot on the master (re-validates lease epoch first). */
+export declare function publishMasterSnapshot(masterPath: string): Promise<SnapshotManifestFile | null>;
+export declare function compareSnapshotVersion(accepted: {
+    epoch: number;
+    seq: number;
+} | null, incoming: {
+    epoch: number;
+    seq: number;
+}): boolean;
+/** Copy master snapshot to local client store atomically. */
+export declare function acceptClientSnapshot(masterPath: string, manifest: SnapshotManifestFile): {
+    ok: boolean;
+    localPath?: string;
+    reason?: string;
+};
+export declare function getClientAcceptedManifest(masterPath: string): SnapshotManifestFile | null;
+export declare function formatSnapshotAge(publishedAt: string): string;

package/dist/lib/syncSnapshot.js

@@ -0,0 +1,188 @@
+/**
+ * v13 snapshot publication — immutable DB copies + manifest with epoch fencing.
+ */
+import { createHash } from "crypto";
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, unlinkSync, } from "fs";
+import path from "path";
+import { GnosysDB } from "./db.js";
+import { getGnosysHome } from "./paths.js";
+import { atomicWriteFileSync } from "./atomicWrite.js";
+import { assertMasterLeaseHeld, readMasterMarker, touchMasterMarkerHeartbeat, validateLeaseEpochBeforeWrite, } from "./masterLease.js";
+import { ensureMachineConfig } from "./machineConfig.js";
+import { acquireWriteLockSync } from "./syncLock.js";
+const SNAPSHOT_RETENTION = 2;
+const MANIFEST_FILENAME = "snapshot-manifest.json";
+export function masterSnapshotsDir(masterPath) {
+    return path.join(masterPath, "snapshots");
+}
+export function clientSnapshotStore(masterPath) {
+    const key = createHash("sha256").update(path.resolve(masterPath)).digest("hex").slice(0, 16);
+    return path.join(getGnosysHome(), "client-snapshots", key);
+}
+function sha256File(filePath) {
+    const buf = readFileSync(filePath);
+    return createHash("sha256").update(buf).digest("hex");
+}
+function readManifestFile(masterPath) {
+    const p = path.join(masterSnapshotsDir(masterPath), MANIFEST_FILENAME);
+    if (!existsSync(p))
+        return null;
+    try {
+        return JSON.parse(readFileSync(p, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+/** Read the master's currently published snapshot manifest (null if none). */
+export function getMasterManifest(masterPath) {
+    return readManifestFile(masterPath);
+}
+function writeManifestFile(masterPath, manifest) {
+    const dir = masterSnapshotsDir(masterPath);
+    mkdirSync(dir, { recursive: true });
+    atomicWriteFileSync(path.join(dir, MANIFEST_FILENAME), JSON.stringify(manifest, null, 2) + "\n");
+}
+function gcOldSnapshots(masterPath, keepFiles) {
+    const dir = masterSnapshotsDir(masterPath);
+    if (!existsSync(dir))
+        return;
+    for (const name of readdirSync(dir)) {
+        if (!name.endsWith(".db"))
+            continue;
+        if (keepFiles.has(name))
+            continue;
+        try {
+            unlinkSync(path.join(dir, name));
+        }
+        catch {
+            // ignore
+        }
+    }
+}
+/** Publish a new immutable snapshot on the master (re-validates lease epoch first). */
+export async function publishMasterSnapshot(masterPath) {
+    const { config: mc } = ensureMachineConfig();
+    const lockPath = path.join(getGnosysHome(), "master-ingest.lock");
+    const release = acquireWriteLockSync(lockPath, "snapshot-publish");
+    try {
+        touchMasterMarkerHeartbeat(masterPath);
+        assertMasterLeaseHeld(masterPath, mc.machineId);
+        const marker = readMasterMarker(masterPath);
+        if (!marker)
+            return null;
+        validateLeaseEpochBeforeWrite(masterPath, marker.epoch, mc.machineId);
+        const masterDb = new GnosysDB(masterPath);
+        if (!masterDb.isAvailable()) {
+            masterDb.close();
+            return null;
+        }
+        const prevDb = masterDb.getSnapshotManifest();
+        const prevFile = readManifestFile(masterPath);
+        const prevSeq = Math.max(prevDb?.seq ?? 0, prevFile?.seq ?? 0);
+        const nextSeq = prevSeq + 1;
+        const snapDir = masterSnapshotsDir(masterPath);
+        mkdirSync(snapDir, { recursive: true });
+        const snapName = `snap-${marker.epoch}-${nextSeq}.db`;
+        const finalPath = path.join(snapDir, snapName);
+        const tmpPath = path.join(snapDir, `.${snapName}.tmp`);
+        await masterDb.backup(path.dirname(tmpPath));
+        const created = readdirSync(snapDir).find((n) => n.startsWith("gnosys-backup-") && n.endsWith(".db"));
+        if (created) {
+            renameSync(path.join(snapDir, created), tmpPath);
+        }
+        if (existsSync(tmpPath)) {
+            renameSync(tmpPath, finalPath);
+        }
+        const checksum = sha256File(finalPath);
+        const sizeBytes = statSync(finalPath).size;
+        const publishedAt = new Date().toISOString();
+        const fileManifest = {
+            epoch: marker.epoch,
+            seq: nextSeq,
+            snapshotFile: snapName,
+            publishedAt,
+            checksum,
+            sizeBytes,
+        };
+        writeManifestFile(masterPath, fileManifest);
+        masterDb.publishSnapshotManifest({
+            epoch: marker.epoch,
+            seq: nextSeq,
+            snapshotPath: finalPath,
+            publishedAt,
+            checksum,
+            sizeBytes,
+            heartbeatAt: publishedAt,
+        });
+        const keep = new Set(readdirSync(snapDir)
+            .filter((n) => n.endsWith(".db"))
+            .sort()
+            .slice(-SNAPSHOT_RETENTION));
+        gcOldSnapshots(masterPath, keep);
+        masterDb.close();
+        return fileManifest;
+    }
+    finally {
+        release();
+    }
+}
+export function compareSnapshotVersion(accepted, incoming) {
+    if (!accepted)
+        return true;
+    if (incoming.epoch > accepted.epoch)
+        return true;
+    if (incoming.epoch === accepted.epoch && incoming.seq > accepted.seq)
+        return true;
+    return false;
+}
+/** Copy master snapshot to local client store atomically. */
+export function acceptClientSnapshot(masterPath, manifest) {
+    const src = path.join(masterSnapshotsDir(masterPath), manifest.snapshotFile);
+    if (!existsSync(src)) {
+        return { ok: false, reason: "snapshot file missing on master" };
+    }
+    const localChecksum = sha256File(src);
+    if (localChecksum !== manifest.checksum) {
+        return { ok: false, reason: "snapshot checksum mismatch" };
+    }
+    const store = clientSnapshotStore(masterPath);
+    mkdirSync(store, { recursive: true });
+    const tmp = path.join(store, ".gnosys.db.tmp");
+    const current = path.join(store, "gnosys.db");
+    copyFileSync(src, tmp);
+    const roundTrip = sha256File(tmp);
+    if (roundTrip !== manifest.checksum) {
+        try {
+            unlinkSync(tmp);
+        }
+        catch {
+            // ignore
+        }
+        return { ok: false, reason: "local copy verification failed" };
+    }
+    renameSync(tmp, current);
+    const metaPath = path.join(store, "accepted-manifest.json");
+    atomicWriteFileSync(metaPath, JSON.stringify(manifest, null, 2) + "\n");
+    return { ok: true, localPath: current };
+}
+export function getClientAcceptedManifest(masterPath) {
+    const metaPath = path.join(clientSnapshotStore(masterPath), "accepted-manifest.json");
+    if (!existsSync(metaPath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(metaPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function formatSnapshotAge(publishedAt) {
+    const ms = Date.now() - new Date(publishedAt).getTime();
+    const minutes = Math.max(0, Math.floor(ms / 60_000));
+    if (minutes < 1)
+        return "just now";
+    if (minutes === 1)
+        return "1 minute ago";
+    return `${minutes} minutes ago`;
+}