beehaven 0.8.16

package/dist/agent-sessions.js

@@ -0,0 +1,370 @@
+/**
+ * AgentSessions — the daemon holds one live WebSocket per active AgentIdentity
+ * to the cloud workspace, so `beehaven agent login <id>` (a cloud agent) shows up
+ * as a real `role:'agent'` session in the workspace (visible in my-devices /
+ * Sessions). These are minimal keepalive sockets: the cloud DO does the auth
+ * (the agent token in the handshake → role:'agent') and all session bookkeeping;
+ * the daemon just keeps the socket open until the agent disconnects.
+ *
+ * The token is a CLOUD-signed AgentIdentity (minted by the worker's
+ * `agent-mint-token` RPC), so it verifies against the cloud's AGENT_IDENTITY_SECRET
+ * without any daemon↔cloud secret sync.
+ */
+import { writeFileSync, readFileSync, renameSync, chmodSync, mkdirSync, existsSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const CONFIG_DIR = join(homedir(), '.beehaven');
+function scopedPresenceFile(scope) {
+    const digest = createHash('sha256').update(String(scope || 'local')).digest('hex').slice(0, 24);
+    return join(CONFIG_DIR, `agent-presence-${digest}.json`);
+}
+export class AgentSessions {
+    wsBase;
+    conns = new Map();
+    /** Connection intent survives an unexpected relay close so the socket can be rebuilt. */
+    specs = new Map();
+    lastInteractionAt = new Map();
+    /** One deadline per identity. Presence expiry is scheduled from activity, not swept by polling. */
+    idleTimers = new Map();
+    presenceFile;
+    presenceBroadcast = null;
+    /** A desktop identity is presence, not a permanent login badge. */
+    static IDLE_TIMEOUT_MS = 30 * 60 * 1000;
+    static RECONNECT_MIN_MS = 1_000;
+    static RECONNECT_MAX_MS = 30_000;
+    /** @param wsBase returns the relay ws base, e.g. wss://…/  (no trailing path) */
+    constructor(wsBase, presenceScope = 'local') {
+        this.wsBase = wsBase;
+        // The recovery clock is account + environment scoped. A global file let a reused agent handle
+        // carry a recent lease from one Clearly account (or staging) into another after a daemon restart.
+        this.presenceFile = scopedPresenceFile(presenceScope);
+        // A daemon restart ends every in-memory socket. The active projection is cleared below, but
+        // the interaction clock is durable so a recent agent session can be reattached instead of
+        // falling back to the much older login timestamp.
+        this.loadPersistedInteractions();
+        this.syncActiveSessionsFile();
+    }
+    /** Attach the local IPC fan-out after the daemon server exists. The data itself is sourced from
+     * the authenticated cloud-session sockets; the file below remains only crash/restart recovery
+     * state and is not a UI subscription surface. */
+    setPresenceBroadcast(fn) {
+        this.presenceBroadcast = fn;
+        this.broadcastPresence();
+    }
+    snapshot() {
+        const now = Date.now();
+        // A transport is not activity. Only identities with a real, attributed interaction inside
+        // the lease belong in the live projection; login, reconnect and daemon restore must not wake
+        // an avatar by themselves.
+        const activeAgentIds = [...this.specs.keys()].filter((agentId) => {
+            const at = this.lastInteractionAt.get(agentId) ?? 0;
+            return Number.isFinite(at) && at > 0 && now - at <= AgentSessions.IDLE_TIMEOUT_MS;
+        });
+        return {
+            activeAgentIds,
+            lastInteractionAt: Object.fromEntries(this.lastInteractionAt.entries()),
+            daemonPid: process.pid,
+            updatedAt: now,
+        };
+    }
+    broadcastPresence() {
+        try {
+            this.presenceBroadcast?.(this.snapshot());
+        }
+        catch { /* IPC fan-out is best-effort */ }
+    }
+    loadPersistedInteractions() {
+        try {
+            if (!existsSync(this.presenceFile))
+                return;
+            const raw = JSON.parse(readFileSync(this.presenceFile, 'utf8'));
+            let pruned = false;
+            const now = Date.now();
+            for (const [agentId, value] of Object.entries(raw || {})) {
+                const at = Number(value);
+                if (!agentId || !Number.isFinite(at) || at <= 0) {
+                    pruned = true;
+                    continue;
+                }
+                if (now - at > AgentSessions.IDLE_TIMEOUT_MS) {
+                    pruned = true;
+                    continue;
+                }
+                this.lastInteractionAt.set(agentId, at);
+            }
+            if (pruned)
+                this.syncPersistedInteractions();
+        }
+        catch { /* best-effort; a missing/corrupt clock must not stop the daemon */ }
+    }
+    syncPersistedInteractions() {
+        try {
+            const dir = CONFIG_DIR;
+            if (!existsSync(dir))
+                mkdirSync(dir, { recursive: true });
+            const tmp = `${this.presenceFile}.tmp`;
+            writeFileSync(tmp, JSON.stringify(Object.fromEntries(this.lastInteractionAt.entries()), null, 2), { mode: 0o600 });
+            renameSync(tmp, this.presenceFile);
+            try {
+                chmodSync(this.presenceFile, 0o600);
+            }
+            catch { /* best effort */ }
+        }
+        catch { /* best-effort; presence remains correct in memory */ }
+    }
+    syncActiveSessionsFile() {
+        const snapshot = this.snapshot();
+        this.broadcastPresence();
+        try {
+            const dir = join(homedir(), '.beehaven');
+            if (!existsSync(dir))
+                mkdirSync(dir, { recursive: true });
+            writeFileSync(join(dir, 'active-agent-sessions.json'), JSON.stringify({
+                updatedAt: snapshot.updatedAt,
+                daemonPid: snapshot.daemonPid,
+                // A transport reconnect is not an explicit agent logout. Keep presence projected while
+                // the socket is being rebuilt so the desktop does not remove avatars on a brief relay
+                // drop.
+                activeAgentIds: snapshot.activeAgentIds,
+                lastInteractionAt: snapshot.lastInteractionAt,
+            }, null, 2), 'utf8');
+        }
+        catch {
+            /* best-effort session sync */
+        }
+    }
+    /** Agent ids with a live or reconnecting session. */
+    list() {
+        return [...this.specs.keys()];
+    }
+    /** Reattach a verified identity after the daemon was replaced, without making login the only
+     * event that can restart its local presence session. `connect` sets the spec synchronously. */
+    ensureConnected(agentId, token) {
+        const id = String(agentId || '').trim();
+        const tok = String(token || '').trim();
+        if (!id || !tok || this.specs.has(id))
+            return;
+        void this.connect(id, tok).catch(() => undefined);
+    }
+    /** Touch the matching live identity after a verified interaction. */
+    touch(agentId, at = Date.now()) {
+        const id = String(agentId || '').trim();
+        if (!id || !this.specs.has(id) || !Number.isFinite(at))
+            return;
+        const previous = this.lastInteractionAt.get(id) ?? 0;
+        if (at <= previous)
+            return;
+        this.lastInteractionAt.set(id, at);
+        this.scheduleIdleExpiry(id);
+        this.syncPersistedInteractions();
+        this.syncActiveSessionsFile();
+    }
+    clearIdleExpiry(agentId) {
+        const timer = this.idleTimers.get(agentId);
+        if (timer)
+            clearTimeout(timer);
+        this.idleTimers.delete(agentId);
+    }
+    /** Schedule the exact end of this identity's 30-minute presence lease. A newer touch replaces
+     * the deadline; a stale callback cannot disconnect a session that became active again. */
+    scheduleIdleExpiry(agentId) {
+        this.clearIdleExpiry(agentId);
+        const last = this.lastInteractionAt.get(agentId);
+        if (!last || !this.specs.has(agentId))
+            return;
+        const timer = setTimeout(() => {
+            this.idleTimers.delete(agentId);
+            if (this.lastInteractionAt.get(agentId) !== last) {
+                this.scheduleIdleExpiry(agentId);
+                return;
+            }
+            if (this.specs.has(agentId))
+                this.disconnect(agentId);
+        }, Math.max(0, last + AgentSessions.IDLE_TIMEOUT_MS - Date.now()));
+        timer.unref?.();
+        this.idleTimers.set(agentId, timer);
+    }
+    scheduleReconnect(agentId, spec) {
+        if (this.specs.get(agentId) !== spec || spec.reconnectTimer)
+            return;
+        const delay = spec.reconnectDelay;
+        spec.reconnectDelay = Math.min(spec.reconnectDelay * 2, AgentSessions.RECONNECT_MAX_MS);
+        spec.reconnectTimer = setTimeout(() => {
+            spec.reconnectTimer = null;
+            this.openSocket(agentId, spec);
+        }, delay);
+        spec.reconnectTimer.unref?.();
+    }
+    /** Open one transport. Unexpected relay/network closes retain local presence and reconnect;
+     * explicit logout, idle expiry, clean close, and auth/session rejection remove it. */
+    openSocket(agentId, spec, firstResolve) {
+        const WS = globalThis.WebSocket;
+        if (!WS) {
+            firstResolve?.({ ok: false, error: 'WebSocket unavailable in this runtime' });
+            this.specs.delete(agentId);
+            this.lastInteractionAt.delete(agentId);
+            this.clearIdleExpiry(agentId);
+            this.syncPersistedInteractions();
+            this.syncActiveSessionsFile();
+            return;
+        }
+        const base = this.wsBase().replace(/\/$/, '');
+        const url = `${base}/my/hive/ws?token=${encodeURIComponent(spec.token)}&clientType=agent&client=agent&wsType=workspace&deviceId=agent-${encodeURIComponent(agentId)}`;
+        let ws;
+        let opened = false;
+        let settled = false;
+        let timer = null;
+        const settleFirst = (result) => {
+            if (!firstResolve || settled)
+                return;
+            settled = true;
+            if (timer)
+                clearTimeout(timer);
+            firstResolve(result);
+        };
+        try {
+            ws = new WS(url);
+        }
+        catch (e) {
+            settleFirst({ ok: false, error: e?.message ?? String(e) });
+            this.scheduleReconnect(agentId, spec);
+            return;
+        }
+        if (firstResolve) {
+            timer = setTimeout(() => {
+                settleFirst({ ok: false, error: 'connect timeout' });
+                try {
+                    ws?.close();
+                }
+                catch { /* noop */ }
+            }, 10_000);
+        }
+        ws.onopen = () => {
+            if (this.specs.get(agentId) !== spec) {
+                try {
+                    ws.close();
+                }
+                catch { /* noop */ }
+                return;
+            }
+            opened = true;
+            this.conns.set(agentId, ws);
+            // Reconnecting transport is not agent activity. A new socket stays inactive until a
+            // verified call touches the identity; a persisted interaction keeps its existing clock.
+            this.scheduleIdleExpiry(agentId);
+            spec.reconnectDelay = AgentSessions.RECONNECT_MIN_MS;
+            this.syncPersistedInteractions();
+            this.syncActiveSessionsFile();
+            settleFirst({ ok: true });
+        };
+        ws.onerror = (e) => {
+            if (!opened)
+                settleFirst({ ok: false, error: e?.message ?? e?.error?.message ?? 'ws error' });
+        };
+        ws.onclose = (event) => {
+            if (timer)
+                clearTimeout(timer);
+            if (this.specs.get(agentId) !== spec)
+                return;
+            if (this.conns.get(agentId) === ws)
+                this.conns.delete(agentId);
+            if (!opened) {
+                settleFirst({ ok: false, error: 'connection closed before open' });
+                this.specs.delete(agentId);
+                this.lastInteractionAt.delete(agentId);
+                this.clearIdleExpiry(agentId);
+                this.syncPersistedInteractions();
+                this.syncActiveSessionsFile();
+                return;
+            }
+            const code = Number(event?.code) || 0;
+            // 1006/1011 are transport/workspace failures. A clean close or auth/session close is
+            // authoritative and must not resurrect an explicitly ended session.
+            if (code === 1000 || (code >= 4000 && code < 5000)) {
+                this.specs.delete(agentId);
+                this.lastInteractionAt.delete(agentId);
+                this.clearIdleExpiry(agentId);
+                this.syncPersistedInteractions();
+                this.syncActiveSessionsFile();
+                return;
+            }
+            this.syncActiveSessionsFile();
+            this.scheduleReconnect(agentId, spec);
+        };
+    }
+    /** Open (or replace) the agent's workspace session. Resolves once the initial socket is OPEN
+     * (the DO has created the session) or on initial error/timeout. */
+    async connect(agentId, token, preserveInteractionAt = false) {
+        this.disconnect(agentId, preserveInteractionAt);
+        const spec = {
+            token,
+            reconnectTimer: null,
+            reconnectDelay: AgentSessions.RECONNECT_MIN_MS,
+        };
+        this.specs.set(agentId, spec);
+        return new Promise((resolve) => this.openSocket(agentId, spec, resolve));
+    }
+    /** Rehydrate identities that were intentionally left logged in when the daemon process died or
+     * was replaced. Explicit logout removes `sessionId` from the stored record, so this does not
+     * resurrect an identity the user deliberately signed out of. */
+    async restorePersistedSessions(records) {
+        await Promise.all(records.map(async (record) => {
+            const agentId = String(record.agentId || '').trim();
+            const token = String(record.token || '').trim();
+            if (!agentId || !token || !record.sessionId)
+                return;
+            if (typeof record.expiresAt === 'number' && record.expiresAt <= Date.now())
+                return;
+            // A session id can outlive the daemon by days if an older client crashed. Do not resurrect
+            // those stale handles on every app launch; use the last VERIFIED interaction, not login age,
+            // because an agent can keep working after it first logged in. Thirty minutes matches
+            // the desktop presence lease.
+            const lastInteractionAt = Number(record.lastInteractionAt || this.lastInteractionAt.get(agentId));
+            if (!Number.isFinite(lastInteractionAt)
+                || Date.now() - lastInteractionAt >= AgentSessions.IDLE_TIMEOUT_MS)
+                return;
+            if (this.specs.has(agentId))
+                return;
+            await this.connect(agentId, token, true).catch(() => undefined);
+            if (this.specs.has(agentId) && Number.isFinite(lastInteractionAt) && lastInteractionAt > 0) {
+                // A real call may arrive while the replacement socket is opening. Never let a late
+                // restore callback move that newer interaction backwards to the old login/session time.
+                const current = this.lastInteractionAt.get(agentId) ?? 0;
+                if (current < lastInteractionAt)
+                    this.lastInteractionAt.set(agentId, lastInteractionAt);
+                this.scheduleIdleExpiry(agentId);
+                this.syncPersistedInteractions();
+                this.syncActiveSessionsFile();
+            }
+        }));
+    }
+    /** Close the agent's session (idempotent). */
+    disconnect(agentId, preserveInteractionAt = false) {
+        this.clearIdleExpiry(agentId);
+        const spec = this.specs.get(agentId);
+        if (spec?.reconnectTimer) {
+            clearTimeout(spec.reconnectTimer);
+            spec.reconnectTimer = null;
+        }
+        this.specs.delete(agentId);
+        const ws = this.conns.get(agentId);
+        if (ws) {
+            try {
+                ws.close();
+            }
+            catch { /* noop */ }
+        }
+        this.conns.delete(agentId);
+        if (!preserveInteractionAt) {
+            this.lastInteractionAt.delete(agentId);
+            this.syncPersistedInteractions();
+        }
+        this.syncActiveSessionsFile();
+    }
+    disconnectAll(preserveInteractionAt = false) {
+        for (const id of [...this.specs.keys()])
+            this.disconnect(id, preserveInteractionAt);
+        this.syncActiveSessionsFile();
+    }
+}