@kybernesis/buzz 0.7.0 → 0.8.0

package/dist/bridge.js

@@ -1,6 +1,7 @@
 import { channelIdentity } from "@kybernesis/enterprise";
 import { fetchMedia, isImage, parseMedia } from "./media.js";
 import { speakerCredentials } from "./credentials.js";
+import { SessionStore } from "./sessions.js";
 import { Client } from "eve/client";
 import { BuzzRelay } from "./relay.js";
 import { loadKey, npubEncode } from "./keys.js";
@@ -48,8 +49,16 @@ export function buzzBridge(options) {
      * previous person's answer. The turn itself runs correctly, as the right
      * person, against the right connections; only the text posted back is
      * somebody else's, which is the most convincing way to look broken.
+     *
+     * Kept on DISK, not in memory. The eve session is durable; the knowledge of
+     * which session belongs to a channel was not, so a restart orphaned every
+     * conversation — the next message opened a new session and the agent said it
+     * had no context, while the old session sat intact holding a reply nobody was
+     * left to read.
      */
-    const sessions = new Map();
+    const sessions = new SessionStore(process.env.BUZZ_SESSIONS_FILE ?? ".buzz-sessions.json");
+    if (sessions.size > 0)
+        log(`resumed ${sessions.size} conversation(s) from the last run`);
     /** Who has already been sent a link, so a room full of strangers is not a room full of spam. */
     const invited = new Map();
     /**
@@ -150,7 +159,7 @@ export function buzzBridge(options) {
         // Built per turn, for the person whose turn it is — and kept current for as
         // long as that turn runs.
         const client = clientFor(pubkey);
-        const existing = sessions.get(channel);
+        const existing = sessions.get(community, channel);
         if (existing) {
             try {
                 const session = client.sessions.attach(existing.id, { streamIndex: existing.streamIndex });
@@ -184,14 +193,14 @@ export function buzzBridge(options) {
                 const response = await session.send(message, { clientContext: { buzzCommunity: community, buzzChannel: channel } });
                 const result = await response.result();
                 // Where this turn left the conversation, so the next one starts after it.
-                sessions.set(channel, { id: existing.id, streamIndex: session.state.streamIndex });
+                sessions.set(community, channel, { id: existing.id, streamIndex: session.state.streamIndex });
                 return result.message ?? "";
             }
             catch (error) {
                 // A session the agent no longer holds cannot be resumed. Starting a new one loses the
                 // thread but keeps the conversation alive, which is the better of the two failures.
                 log(`session for ${channel.slice(0, 8)} could not continue (${error.message}); starting a new one`);
-                sessions.delete(channel);
+                sessions.delete(community, channel);
             }
         }
         const created = await client.sessions.create({
@@ -199,7 +208,7 @@ export function buzzBridge(options) {
             clientContext: { buzzCommunity: community, buzzChannel: channel },
         });
         const reply = (await created.response.result()).message ?? "";
-        sessions.set(channel, {
+        sessions.set(community, channel, {
             id: created.session.state.sessionId,
             streamIndex: created.session.state.streamIndex,
         });

package/dist/sessions.d.ts

@@ -0,0 +1,37 @@
+/** One conversation: which eve session it is, and how far the bridge has read. */
+export interface StoredSession {
+    id: string;
+    streamIndex: number;
+    /** When it was last used, so a store that runs for years does not grow forever. */
+    updated: number;
+}
+/**
+ * Which eve session belongs to which channel, across restarts.
+ *
+ * @remarks
+ * The eve session itself is durable — it lives on the agent's disk and survives
+ * anything. What did NOT survive was the bridge's knowledge of WHICH session
+ * belonged to a channel: that was a Map in memory, so a restart silently
+ * orphaned every conversation. The next message opened a new session and the
+ * agent answered "I have no context", while the old session sat on disk intact,
+ * holding a turn whose reply nobody was left to read.
+ *
+ * Reported from a live deployment after a restart mid-conversation, and the
+ * diagnosis there was exactly right: durable on one side, ephemeral on the
+ * other, and the join between them was the part that could not survive.
+ *
+ * Keyed by community AND channel: channel ids are issued per relay, so an agent
+ * in two workspaces cannot assume they never collide.
+ */
+export declare class SessionStore {
+    #private;
+    constructor(file: string);
+    static key(community: string, channel: string): string;
+    get(community: string, channel: string): StoredSession | undefined;
+    set(community: string, channel: string, session: {
+        id: string;
+        streamIndex: number;
+    }): void;
+    delete(community: string, channel: string): void;
+    get size(): number;
+}

package/dist/sessions.js

@@ -0,0 +1,80 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+/** How long an untouched conversation is kept before it is forgotten. */
+const KEEP_MS = 30 * 24 * 60 * 60 * 1000;
+/**
+ * Which eve session belongs to which channel, across restarts.
+ *
+ * @remarks
+ * The eve session itself is durable — it lives on the agent's disk and survives
+ * anything. What did NOT survive was the bridge's knowledge of WHICH session
+ * belonged to a channel: that was a Map in memory, so a restart silently
+ * orphaned every conversation. The next message opened a new session and the
+ * agent answered "I have no context", while the old session sat on disk intact,
+ * holding a turn whose reply nobody was left to read.
+ *
+ * Reported from a live deployment after a restart mid-conversation, and the
+ * diagnosis there was exactly right: durable on one side, ephemeral on the
+ * other, and the join between them was the part that could not survive.
+ *
+ * Keyed by community AND channel: channel ids are issued per relay, so an agent
+ * in two workspaces cannot assume they never collide.
+ */
+export class SessionStore {
+    #file;
+    #entries = new Map();
+    constructor(file) {
+        this.#file = file;
+        this.#load();
+    }
+    static key(community, channel) {
+        return `${community}|${channel}`;
+    }
+    get(community, channel) {
+        return this.#entries.get(SessionStore.key(community, channel));
+    }
+    set(community, channel, session) {
+        this.#entries.set(SessionStore.key(community, channel), { ...session, updated: Date.now() });
+        this.#save();
+    }
+    delete(community, channel) {
+        this.#entries.delete(SessionStore.key(community, channel));
+        this.#save();
+    }
+    get size() {
+        return this.#entries.size;
+    }
+    #load() {
+        if (!existsSync(this.#file))
+            return;
+        try {
+            const raw = JSON.parse(readFileSync(this.#file, "utf8"));
+            const cutoff = Date.now() - KEEP_MS;
+            for (const [key, value] of Object.entries(raw)) {
+                if (typeof value?.id === "string" && (value.updated ?? 0) > cutoff) {
+                    this.#entries.set(key, value);
+                }
+            }
+        }
+        catch {
+            // A corrupt store is not worth refusing to start over. Losing the mapping
+            // costs conversation history; refusing to start costs the whole agent.
+        }
+    }
+    #save() {
+        try {
+            mkdirSync(dirname(this.#file), { recursive: true });
+            // Written beside the target and renamed, because the failure being
+            // guarded against is a restart — and a restart during a plain write
+            // leaves a truncated file that reads as "no sessions at all", which is
+            // the exact bug this class exists to prevent.
+            const tmp = `${this.#file}.tmp`;
+            writeFileSync(tmp, JSON.stringify(Object.fromEntries(this.#entries)), { mode: 0o600 });
+            renameSync(tmp, this.#file);
+        }
+        catch {
+            // Best effort: an agent that cannot write its store still answers, it
+            // just forgets across restarts — which is where this started.
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kybernesis/buzz",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Put an eve agent in a Buzz workspace as a member: per-speaker verified identity resolved through the control plane, self-service identity linking, presence, typing and seen signals.",
   "license": "Apache-2.0",
   "type": "module",