khala-cli 0.4.8 → 0.4.10

package/dist/{chunk-CJTCU755.mjs → chunk-PJKI7SRI.mjs}

@@ -1,20 +1,32 @@
 import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
-import "./chunk-5GLTKWJ5.mjs";
 import {
-  CHANNEL_EVENT_TYPE,
-  encodeChannelEvent,
-  memberRenameContent
-} from "./chunk-54XFVSEC.mjs";
+  retryUnexpired
+} from "./chunk-C2WEDMAF.mjs";
+import {
+  RESTORE_HISTORY_MAX_PAGES
+} from "./chunk-WUDXHF2Q.mjs";
+import "./chunk-HHEZVPRR.mjs";
 import {
   LISTENING_MODE_COMMAND_TYPE,
   LISTENING_MODE_MEMBER_KEY,
   memberListeningMode
-} from "./chunk-IQJQ4RF5.mjs";
-import "./chunk-NKX3SLS7.mjs";
-import "./chunk-7HBRFY3Z.mjs";
+} from "./chunk-4BP7V3OP.mjs";
+import {
+  CHANNEL_EVENT_TYPE,
+  encodeChannelEvent,
+  memberRenameContent
+} from "./chunk-JKOJQTFT.mjs";
+import {
+  StateError
+} from "./chunk-PN25BUQ4.mjs";
+import {
+  init_define_KHALA_BUNDLE
+} from "./chunk-EVT2DWNZ.mjs";
 
 // src/matrix/session.ts
-import { createClient, ClientEvent, RoomEvent, MatrixEventEvent, SyncState, Direction, Method, EventType } from "matrix-js-sdk";
+init_define_KHALA_BUNDLE();
+import { randomUUID } from "node:crypto";
+import { createClient, ClientEvent, RoomEvent, MatrixEventEvent, SyncState, SetPresence, Direction, Method, EventType } from "matrix-js-sdk";
 function message(event) {
   const type = event.getType();
   const eventId = event.getId();
@@ -36,20 +48,48 @@ function message(event) {
 }
 async function createAgentMatrixSession(creds, opts) {
   const started = Date.now();
+  const rejoinTxnId = `khala.rejoin.${randomUUID()}`;
   const log = (line) => opts?.log?.(line);
-  const client = createClient({ baseUrl: creds.homeserver, userId: creds.userId, accessToken: creds.accessToken, deviceId: creds.deviceId });
+  const persistent = opts?.cryptoStore ? await (await import("./chunk-3E5DH3Y6.mjs")).openCryptoStore(opts.cryptoStore.dir, opts.cryptoStore.root, creds) : void 0;
+  const client = createClient({ ...persistent ? { store: persistent.sync } : {}, baseUrl: creds.homeserver, userId: creds.userId, accessToken: creds.accessToken, deviceId: creds.deviceId });
   const handlers = /* @__PURE__ */ new Set();
   const ended = /* @__PURE__ */ new Set();
   const modeHandlers = /* @__PURE__ */ new Set();
   const inviters = /* @__PURE__ */ new Map();
   const emitted = /* @__PURE__ */ new Set();
   const liveEvents = /* @__PURE__ */ new Set();
+  const undecryptableIds = new Map((persistent?.undecryptableEventIds ?? []).map((entry) => [entry.id, entry]));
+  let retrySave = Promise.resolve();
+  const saveRetries = () => {
+    const entries = [...undecryptableIds.values()];
+    retrySave = retrySave.then(() => persistent?.rememberUndecryptable(entries)).catch(() => log("decryption_retry_save_failed"));
+  };
+  const rememberDecryption = (event) => {
+    const id = event.getId();
+    if (stopped || !persistent || !id) return;
+    const failed = event.getType() === "m.room.encrypted" || event.isDecryptionFailure();
+    if (failed) {
+      if (undecryptableIds.has(id)) return;
+      undecryptableIds.set(id, { id, firstSeen: Date.now() });
+    } else if (!undecryptableIds.delete(id)) return;
+    if (undecryptableIds.size > 100) undecryptableIds.delete(undecryptableIds.keys().next().value);
+    saveRetries();
+  };
   const joinTimes = /* @__PURE__ */ new Map();
   const cancellations = /* @__PURE__ */ new Set();
   let joinedRoom;
   let stopped = false;
+  let presenceTimer;
+  let away;
+  const publishPresence = () => {
+    void client.setSyncPresence(away ? SetPresence.Offline : void 0);
+    void client.setPresence(away ? { presence: "offline", status_msg: away } : { presence: "online", status_msg: "" }).catch(() => log("presence_failed"));
+  };
+  let recovering = persistent?.restored ?? false;
   const deliver = (event) => {
-    if (stopped || !liveEvents.has(event)) return;
+    if (stopped) return;
+    if (liveEvents.has(event)) rememberDecryption(event);
+    if (recovering || !liveEvents.has(event)) return;
     const command = event.getType() === LISTENING_MODE_COMMAND_TYPE && !event.isDecryptionFailure() && event.getId() && event.getRoomId() && event.getSender() ? { eventId: event.getId(), roomId: event.getRoomId(), sender: event.getSender(), ts: event.getTs(), content: event.getContent() } : void 0;
     const m = command ?? message(event);
     if (!m) {
@@ -85,9 +125,12 @@ async function createAgentMatrixSession(creds, opts) {
     }
   };
   const timeline = (event, _room, toStart, _removed, data) => {
-    if (stopped || toStart || data?.liveEvent === false) return;
+    if (stopped || toStart || data?.liveEvent === false && !persistent?.restored) return;
     liveEvents.add(event);
-    void client.decryptEventIfNeeded(event).then(() => deliver(event), () => log("live_decryption_failed"));
+    void client.decryptEventIfNeeded(event).then(() => deliver(event), () => {
+      rememberDecryption(event);
+      log("live_decryption_failed");
+    });
   };
   const decrypted = (event) => deliver(event);
   const syncLog = (state, _previous, data) => {
@@ -152,9 +195,53 @@ async function createAgentMatrixSession(creds, opts) {
       check();
     });
   };
-  const stop = async () => {
+  let stopping;
+  let wipe = false;
+  const stop = () => stopping ??= stopSession();
+  const stopSession = async () => {
     if (stopped) return;
     stopped = true;
+    clearInterval(presenceTimer);
+    if (presenceTimer && !wipe) {
+      await Promise.race([
+        client.setPresence({ presence: "offline", status_msg: "session ended" }).catch(() => log("presence_failed")),
+        new Promise((resolve) => setTimeout(resolve, 3e3).unref())
+      ]);
+    }
+    await retrySave;
+    if (wipe) {
+      try {
+        await client.http.authedRequest(Method.Post, "/logout", void 0, {}, { localTimeoutMs: 5e3 });
+      } catch (error) {
+        if (matrixCode(error) !== "M_UNKNOWN_TOKEN" && !(typeof error === "object" && error !== null && "httpStatus" in error && error.httpStatus === 401)) {
+          log("discarded_device_logout_failed");
+          console.error("khala: discarded_device_logout_failed");
+        }
+      }
+    }
+    if (wipe && persistent?.forgetIdentity) {
+      try {
+        await persistent.forgetIdentity();
+      } catch {
+        log("crypto_cleanup_failed");
+      }
+    }
+    let syncStopped;
+    if (persistent && client.getSyncState() !== null && client.getSyncState() !== SyncState.Stopped) {
+      syncStopped = new Promise((resolve, reject) => {
+        const done = (state) => {
+          if (state === SyncState.Stopped) finish();
+        };
+        const timer = setTimeout(() => finish(new Error("crypto_sync_stop_timeout")), 1e4);
+        const finish = (error) => {
+          clearTimeout(timer);
+          client.removeListener(ClientEvent.Sync, done);
+          if (error) reject(error);
+          else resolve();
+        };
+        client.on(ClientEvent.Sync, done);
+      });
+    }
     client.stopClient();
     client.removeListener(RoomEvent.Timeline, timeline);
     client.removeListener(MatrixEventEvent.Decrypted, decrypted);
@@ -166,6 +253,14 @@ async function createAgentMatrixSession(creds, opts) {
     handlers.clear();
     modeHandlers.clear();
     ended.clear();
+    if (persistent) {
+      try {
+        await syncStopped;
+        if (wipe) await persistent.wipe();
+      } finally {
+        await persistent.close();
+      }
+    }
   };
   const membershipEnded = (room, membership) => {
     if (stopped || room.roomId !== joinedRoom || !["leave", "ban"].includes(membership)) return;
@@ -174,7 +269,11 @@ async function createAgentMatrixSession(creds, opts) {
   const end = (reason) => {
     if (stopped) return;
     const listeners = [...ended];
-    void stop();
+    wipe = true;
+    void stop().catch(() => {
+      log("crypto_cleanup_failed");
+      console.error("khala: crypto_cleanup_failed");
+    });
     for (const handler of listeners) {
       try {
         handler(reason);
@@ -184,7 +283,13 @@ async function createAgentMatrixSession(creds, opts) {
     }
   };
   try {
-    await client.initRustCrypto({ useIndexedDB: false });
+    if (persistent) await persistent.sync.startup();
+    try {
+      await client.initRustCrypto(persistent ? { useIndexedDB: true, cryptoDatabasePrefix: persistent.prefix } : { useIndexedDB: false });
+    } catch (error) {
+      if (!persistent?.restored || error instanceof StateError && error.code === "unsafe_state_dir") throw error;
+      throw new (await import("./chunk-3E5DH3Y6.mjs")).CryptoStoreCorruptError();
+    }
     const crypto = client.getCrypto();
     if (!crypto) throw new Error("crypto_unavailable");
     log(`crypto_version=${crypto.getVersion()}`);
@@ -210,6 +315,9 @@ async function createAgentMatrixSession(creds, opts) {
     }, () => client.getSyncState() === SyncState.Prepared || client.getSyncState() === SyncState.Syncing, 3e4, "sync_timeout");
     await Promise.all([client.startClient({ initialSyncLimit: 30 }), prepared]);
     log(`session_ready_ms=${Date.now() - started}`);
+    publishPresence();
+    presenceTimer = setInterval(publishPresence, 6e4);
+    presenceTimer.unref();
   } catch (error) {
     await stop();
     throw error;
@@ -227,6 +335,8 @@ async function createAgentMatrixSession(creds, opts) {
   }, ready, timeoutMs, error);
   return {
     userId: creds.userId,
+    ...persistent?.recovered ? { cryptoReset: true } : {},
+    ...persistent?.restored ? { recoversOnJoin: true } : {},
     onEnded(handler) {
       if (!stopped) ended.add(handler);
       return () => {
@@ -262,7 +372,6 @@ async function createAgentMatrixSession(creds, opts) {
     async join(roomId) {
       if (stopped) throw new Error("session_stopped");
       if (joinedRoom === roomId) return;
-      const rejoinedAt = Date.now();
       const membership = client.getRoom(roomId)?.getMyMembership();
       if (membership !== "join") {
         if (membership !== "invite") throw new Error("not_invited");
@@ -277,20 +386,96 @@ async function createAgentMatrixSession(creds, opts) {
         const owner = ownJoin.getContent()["com.khala.invited_by"];
         if (typeof owner === "string") inviters.set(roomId, owner);
         const event = encodeChannelEvent({ kind: "member", summary: `${ownJoin.getContent().displayname ?? creds.userId} rejoined`, status: "info", source: { system: "khala-agent" } });
-        if (event.ok) await client.sendEvent(roomId, CHANNEL_EVENT_TYPE, event.value, `khala.rejoin.${creds.deviceId}`);
+        if (event.ok) await client.sendEvent(roomId, CHANNEL_EVENT_TYPE, event.value, rejoinTxnId);
       }
       if (membership !== "join" && inviters.has(roomId)) {
         const content = { ...ownJoin.getContent(), membership: "join", "com.khala.invited_by": inviters.get(roomId) };
         await client.sendStateEvent(roomId, EventType.RoomMember, content, creds.userId);
       }
-      joinTimes.set(roomId, membership === "join" ? rejoinedAt : ownJoin.getTs());
+      const joinedAt = persistent?.joinedAt ?? ownJoin.getTs();
+      await persistent?.rememberJoin(joinedAt);
+      joinTimes.set(roomId, joinedAt);
+      if (persistent?.restored) {
+        let pruned = false;
+        for (const [id, entry] of [...undecryptableIds]) {
+          if (stopped) throw new Error("session_stopped");
+          if (!retryUnexpired(entry)) {
+            undecryptableIds.delete(id);
+            pruned = true;
+            continue;
+          }
+          try {
+            const raw = await client.fetchRoomEvent(roomId, id);
+            const event = client.getEventMapper()({ ...raw, room_id: roomId });
+            if (event.getTs() < joinedAt) {
+              undecryptableIds.delete(id);
+              pruned = true;
+              continue;
+            }
+            liveEvents.add(event);
+            await client.decryptEventIfNeeded(event).catch(() => log("recovery_decryption_failed"));
+            rememberDecryption(event);
+          } catch (error) {
+            const status = typeof error === "object" && error !== null && "httpStatus" in error ? error.httpStatus : void 0;
+            if (matrixCode(error) === "M_NOT_FOUND" || matrixCode(error) === "M_FORBIDDEN" || status === 404 || status === 403) {
+              undecryptableIds.delete(id);
+              pruned = true;
+            }
+            log("recovery_event_retry_failed");
+          }
+        }
+        if (pruned) saveRetries();
+        let token = null;
+        const seenTokens = /* @__PURE__ */ new Set();
+        let pages = 0;
+        let undecryptable = 0;
+        for (; ; ) {
+          if (stopped) throw new Error("session_stopped");
+          const page = await client.createMessagesRequest(roomId, token, 100, Direction.Backward);
+          pages++;
+          let reachedBoundary = false;
+          for (const raw of page.chunk) {
+            const event = client.getEventMapper()({ ...raw, room_id: roomId });
+            if (opts?.restoreStopAtEventId && event.getId() === opts.restoreStopAtEventId || event.getTs() < joinedAt) {
+              reachedBoundary = true;
+              break;
+            }
+            liveEvents.add(event);
+            await client.decryptEventIfNeeded(event).catch(() => log("recovery_decryption_failed"));
+            rememberDecryption(event);
+            if (event.getType() === "m.room.encrypted" || event.isDecryptionFailure()) {
+              undecryptable++;
+              liveEvents.delete(event);
+            }
+          }
+          if (reachedBoundary || page.chunk.length === 0 || !page.end) break;
+          if (pages >= RESTORE_HISTORY_MAX_PAGES) {
+            const count = `restore_catchup_truncated pages=${pages}`;
+            if (opts?.log) log(count);
+            else process.stderr.write(`${count}
+`);
+            break;
+          }
+          if (seenTokens.has(page.end)) throw new Error("recovery_pagination_stalled");
+          seenTokens.add(page.end);
+          token = page.end;
+        }
+        if (undecryptable > 0) {
+          const count = `history_undecryptable=${undecryptable}`;
+          if (opts?.log) log(count);
+          else process.stderr.write(`${count}
+`);
+        }
+      }
+      recovering = false;
       if (!joinedRoom) client.on(RoomEvent.MyMembership, membershipEnded);
       joinedRoom = roomId;
-      for (const event of liveEvents) {
+      for (const event of [...liveEvents].sort((a, b) => a.getTs() - b.getTs())) {
         if (event.getRoomId() === roomId) deliver(event);
       }
     },
-    async history(roomId, limit, before) {
+    joinedAt: (roomId) => joinTimes.get(roomId),
+    async history(roomId, limit, before, options) {
       if (stopped) throw new Error("session_stopped");
       let token = null;
       if (before !== void 0) {
@@ -300,17 +485,27 @@ async function createAgentMatrixSession(creds, opts) {
       const res = await guarded(roomId, () => client.createMessagesRequest(roomId, token, limit, Direction.Backward));
       const messages = [];
       let undecryptable = 0;
+      let oldest;
+      let oldestTs;
+      let reachedBoundary = false;
       for (const raw of res.chunk) {
         const event = client.getEventMapper()({ ...raw, room_id: roomId });
+        oldest = event.getId();
+        oldestTs = Math.min(oldestTs ?? event.getTs(), event.getTs());
+        if (options?.stopAtEventId && oldest === options.stopAtEventId) {
+          reachedBoundary = true;
+          break;
+        }
         try {
           await client.decryptEventIfNeeded(event);
         } catch {
         }
+        rememberDecryption(event);
         if (event.getType() === "m.room.encrypted" || event.isDecryptionFailure()) {
           undecryptable++;
           const eventId = event.getId(), sender = event.getSender();
-          if (eventId && sender && eventId !== before) {
-            const body = "[Encrypted message unavailable: this device does not have its key. Messages from before joining may not have been shared.]";
+          if (options?.includeUnavailable !== false && eventId && sender && eventId !== before) {
+            const body = "[Encrypted message unavailable: this device does not have its key. Keys may not have been shared for messages sent before joining or while this agent was offline.]";
             messages.push({
               eventId,
               roomId,
@@ -326,10 +521,16 @@ async function createAgentMatrixSession(creds, opts) {
         const m = message(event);
         if (m && m.eventId !== before) messages.push(m);
       }
-      log(`history_undecryptable=${undecryptable}`);
+      const count = `history_undecryptable=${undecryptable}`;
+      log(count);
+      if (options?.includeUnavailable === false && undecryptable > 0 && !opts?.log) process.stderr.write(`${count}
+`);
       messages.reverse();
-      const oldest = messages[0];
-      return typeof res.end === "string" && oldest ? { messages, nextBefore: oldest.eventId } : { messages };
+      return {
+        messages,
+        ...typeof res.end === "string" && oldest ? { nextBefore: oldest } : {},
+        ...options?.includeUnavailable === false || options?.stopAtEventId ? { ...oldestTs === void 0 ? {} : { oldestTs }, reachedBoundary } : {}
+      };
     },
     async send(roomId, text) {
       if (stopped) throw new Error("session_stopped");
@@ -348,6 +549,35 @@ async function createAgentMatrixSession(creds, opts) {
       const value = joinedRoom && client.getRoom(joinedRoom)?.currentState.getStateEvents("m.room.member", userId)?.getContent().displayname;
       return typeof value === "string" && value.length > 0 ? value : void 0;
     },
+    members(roomId) {
+      return (client.getRoom(roomId)?.getJoinedMembers() ?? []).filter((member) => member.userId !== creds.userId).map((member) => {
+        const user = client.getUser(member.userId);
+        const event = user?.events.presence;
+        if (!user || !event) return { name: member.name, presence: "unknown" };
+        if (user.presence !== "offline") return { name: member.name, presence: "online" };
+        const reason = event.getContent().status_msg;
+        return {
+          name: member.name,
+          presence: "away",
+          since: new Date(user.lastPresenceTs - (user.lastActiveAgo ?? 0)).toISOString(),
+          ...typeof reason === "string" && reason ? { reason: reason.slice(0, 80) } : {}
+        };
+      });
+    },
+    seenBy(roomId, eventId) {
+      const room = client.getRoom(roomId);
+      if (!room?.findEventById(eventId)) return [];
+      return room.getJoinedMembers().filter((member) => member.userId !== creds.userId && room.hasUserReadEvent(member.userId, eventId)).map((member) => member.name);
+    },
+    setAway(reason) {
+      if (reason === away) return;
+      away = reason;
+      if (presenceTimer && !stopped) publishPresence();
+    },
+    async markRead(roomId, eventId) {
+      if (stopped) throw new Error("session_stopped");
+      await guarded(roomId, () => client.setRoomReadMarkersHttpRequest(roomId, eventId, eventId));
+    },
     stop
   };
 }