@gorlitzer-labs/apiary 1.14.0 → 1.15.0

package/dist/{chunk-LNSDH2V5.js → chunk-74XU7HHN.js}

@@ -6,7 +6,7 @@ import {
   roomEmoji,
   saveConfig,
   saveRoomSession
-} from "./chunk-LOONM4G3.js";
+} from "./chunk-3UQBSELW.js";
 import {
   extractToken,
   tmuxCapturePane,
@@ -2018,4 +2018,4 @@ export {
   HEADLESS_READY,
   join
 };
-//# sourceMappingURL=chunk-LNSDH2V5.js.map
+//# sourceMappingURL=chunk-74XU7HHN.js.map

package/dist/{chunk-36WX2UAF.js → chunk-OEAHTZCA.js}

@@ -1,7 +1,8 @@
 import {
   RemoteRoomDataSource,
+  RoomConnectionError,
   buildCatchUpLines
-} from "./chunk-WJD5EKO6.js";
+} from "./chunk-Z4J6TRJY.js";
 import {
   extractToken,
   tmuxCapturePane,
@@ -437,28 +438,349 @@ function describeOutcome(participant, until, outcome) {
   }
 }
 
+// src/cli/rejoin.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function readLocalRoomSession(roomName) {
+  if (!/^[A-Za-z0-9._-]+$/.test(roomName) || roomName.includes("..")) return null;
+  const path = join(homedir(), ".apiary", "sessions", `room_${roomName}.json`);
+  if (!existsSync(path)) return null;
+  try {
+    const data = JSON.parse(readFileSync(path, "utf-8"));
+    const str = (v) => typeof v === "string" && v ? v : void 0;
+    return {
+      serverUrl: str(data.serverUrl),
+      publicUrl: str(data.publicUrl),
+      adminToken: str(data.adminToken),
+      memberToken: str(data.memberToken)
+    };
+  } catch {
+    return null;
+  }
+}
+function isLoopbackUrl(url) {
+  try {
+    const host = new URL(url).hostname;
+    return host === "127.0.0.1" || host === "localhost";
+  } catch {
+    return false;
+  }
+}
+function sameOrigin(a, b) {
+  try {
+    return new URL(a).origin === new URL(b).origin;
+  } catch {
+    return a === b;
+  }
+}
+function localTierOf(shareToken, session) {
+  if (!shareToken || !session) return void 0;
+  if (session.adminToken === shareToken) return "admin";
+  if (session.memberToken === shareToken) return "member";
+  return void 0;
+}
+var RoomRejoiner = class {
+  constructor(room, deps) {
+    this.room = room;
+    this.deps = deps;
+    this.fetchFn = deps.fetch ?? ((...args) => fetch(...args));
+    this.now = deps.now ?? Date.now;
+    this.sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    this.readSession = deps.readRoomSession ?? readLocalRoomSession;
+  }
+  inflight = null;
+  lost = null;
+  failures = 0;
+  cooldownUntil = 0;
+  lastRejoinAt = Number.NEGATIVE_INFINITY;
+  lastProbeAt = Number.NEGATIVE_INFINITY;
+  fetchFn;
+  now;
+  sleep;
+  readSession;
+  /** Why the room is lost for good, if it is. */
+  get lostError() {
+    return this.lost;
+  }
+  // ── SessionRecovery (RemoteRoomDataSource) ─────────────────────────────
+  async sessionInvalid(usedToken) {
+    if (usedToken !== void 0 && usedToken !== this.room.sessionToken) return;
+    await this.rejoin("session token rejected (401)");
+  }
+  async unreachable() {
+    if (this.lost || this.room.removedBy) return false;
+    const now = this.now();
+    if (now - this.lastProbeAt < (this.deps.probeIntervalMs ?? 5e3)) return false;
+    this.lastProbeAt = now;
+    const local = this.readSession(this.room.rejoin.serverRoomName)?.serverUrl;
+    if (!local || !isLoopbackUrl(local) || sameOrigin(local, this.room.serverUrl)) return false;
+    const base = local.replace(/\/$/, "");
+    let res;
+    try {
+      res = await this.fetchFn(`${base}/participants`, {
+        headers: { Authorization: `Bearer ${this.room.sessionToken}` },
+        signal: AbortSignal.timeout(5e3)
+      });
+    } catch {
+      return false;
+    }
+    await res.body?.cancel().catch(() => {
+    });
+    if (res.ok) {
+      const from = this.room.serverUrl;
+      this.swapSession(base, this.room.sessionToken);
+      this.log(`room "${this.room.roomName}": ${from} unreachable, moved to ${base} (same session)`);
+      return true;
+    }
+    if (res.status === 401) {
+      try {
+        await this.rejoin(`${this.room.serverUrl} unreachable`);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  }
+  // ── SseRecoveryHandler (per room) ──────────────────────────────────────
+  async authRejected(status, usedToken) {
+    if (usedToken !== void 0 && usedToken !== this.room.sessionToken) return true;
+    try {
+      await this.rejoin(`event stream rejected (${status})`);
+      return true;
+    } catch (err) {
+      if (err instanceof RoomConnectionError && err.permanent) throw err;
+      return false;
+    }
+  }
+  // ── Re-join ────────────────────────────────────────────────────────────
+  /**
+   * Join the room again and swap the new session in everywhere. Concurrent
+   * callers share one attempt. Throws RoomConnectionError: `permanent` when
+   * retrying cannot help, otherwise after bounded retries.
+   */
+  rejoin(reason) {
+    if (this.lost) return Promise.reject(this.lost);
+    const roomLabel = `"${this.room.roomName}"`;
+    if (this.room.removedBy) return Promise.reject(this.removed());
+    if (this.inflight) return this.inflight;
+    const now = this.now();
+    if (now - this.lastRejoinAt < (this.deps.replacedWindowMs ?? 3e4)) {
+      return Promise.reject(this.loseFor(
+        `Your seat in room ${roomLabel} was taken over again right after apiary re-joined it \u2014 another session is probably using the name "${this.room.rejoin.name}". Not re-joining automatically, so the two do not keep evicting each other. Call join_room to take the seat back.`
+      ));
+    }
+    if (now < this.cooldownUntil) {
+      const secs = Math.ceil((this.cooldownUntil - now) / 1e3);
+      return Promise.reject(new RoomConnectionError(
+        `Lost the session in room ${roomLabel} and the last re-join failed; apiary retries in ${secs}s. If this persists, call join_room again with the room's share URL.`,
+        false
+      ));
+    }
+    this.inflight = this.runRejoin(reason).finally(() => {
+      this.inflight = null;
+    });
+    return this.inflight;
+  }
+  async runRejoin(reason) {
+    const roomLabel = `"${this.room.roomName}"`;
+    this.log(`room ${roomLabel}: ${reason}; re-joining as "${this.room.rejoin.name}"`);
+    const delays = [0, ...this.deps.retryDelaysMs ?? [500, 1500]];
+    let lastError = "";
+    for (const delay of delays) {
+      if (delay > 0) await this.sleep(delay);
+      if (this.room.removedBy) break;
+      const outcome = await this.attemptOnce();
+      if (outcome.permanent) {
+        throw this.loseFor(
+          `Room ${roomLabel} no longer accepts the share link this agent joined with (${outcome.error}). The room was recreated or the link revoked \u2014 ask for a new share URL and call join_room with it.`
+        );
+      }
+      if (outcome.done) {
+        this.failures = 0;
+        this.cooldownUntil = 0;
+        this.lastRejoinAt = this.now();
+        return;
+      }
+      lastError = outcome.error;
+    }
+    if (this.room.removedBy) throw this.removed();
+    this.failures += 1;
+    const cooldown = Math.min(1e3 * 2 ** (this.failures - 1), this.deps.maxCooldownMs ?? 3e4);
+    this.cooldownUntil = this.now() + cooldown;
+    this.log(`room ${roomLabel}: re-join failed (${lastError}); next try in ${Math.ceil(cooldown / 1e3)}s`);
+    throw new RoomConnectionError(
+      `Lost the session in room ${roomLabel} (${reason}) and could not re-join yet: ${lastError}. apiary keeps retrying; if this persists, call join_room again with the room's share URL.`,
+      false
+    );
+  }
+  /** One pass over the candidate addresses and tokens. */
+  async attemptOnce() {
+    const info = this.room.rejoin;
+    const candidates = [
+      { url: this.room.serverUrl, shareToken: info.shareToken }
+    ];
+    const session = this.readSession(info.serverRoomName);
+    const local = session?.serverUrl && isLoopbackUrl(session.serverUrl) ? session.serverUrl.replace(/\/$/, "") : void 0;
+    if (local && !sameOrigin(local, this.room.serverUrl)) {
+      candidates.push({ url: local, shareToken: info.shareToken });
+    }
+    const fresh = info.localTier === "admin" ? session?.adminToken : info.localTier === "member" ? session?.memberToken : void 0;
+    if (local && fresh && fresh !== info.shareToken) {
+      candidates.push({ url: local, shareToken: fresh });
+    }
+    let shareRejected = "";
+    let transient = "";
+    let unreachable = "";
+    for (const c of candidates) {
+      const r = await this.joinAt(c.url, c.shareToken);
+      if (r.ok) {
+        this.apply(r.url, r.shareToken, r.data);
+        return { done: true, permanent: false, error: "" };
+      }
+      if (r.kind === "share-rejected") shareRejected = r.error;
+      else if (r.kind === "unreachable") unreachable ||= r.error;
+      else transient ||= r.error;
+    }
+    if (shareRejected && !transient) return { done: false, permanent: true, error: shareRejected };
+    return { done: false, permanent: false, error: transient || unreachable || shareRejected || "no address answered" };
+  }
+  async joinAt(url, shareToken) {
+    const body = { type: this.room.rejoin.type, name: this.room.rejoin.name };
+    if (shareToken) body.token = shareToken;
+    let res;
+    try {
+      res = await this.fetchFn(`${url}/join`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(1e4)
+      });
+    } catch (err) {
+      return { ok: false, kind: "unreachable", error: `${url} unreachable (${err instanceof Error ? err.message : String(err)})` };
+    }
+    if (!res.ok) {
+      const text = (await res.text().catch(() => "")).slice(0, 200);
+      if (res.status === 403 && /invalid share token/i.test(text)) {
+        return { ok: false, kind: "share-rejected", error: `403 Invalid share token at ${url}` };
+      }
+      return { ok: false, kind: "transient", error: `${res.status} from ${url}/join${text ? `: ${text}` : ""}` };
+    }
+    const data = await res.json().catch(() => ({}));
+    if (String(data.roomName ?? "") !== this.room.rejoin.serverRoomName || String(data.roomId ?? "") !== this.room.roomId) {
+      await this.fetchFn(`${url}/disconnect`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${String(data.sessionToken ?? "")}` },
+        body: "{}"
+      }).catch(() => {
+      });
+      return { ok: false, kind: "wrong-room", error: `${url} serves a different room (${String(data.roomName ?? "?")})` };
+    }
+    return { ok: true, url, shareToken, data };
+  }
+  /** Swap the new session into the JoinResult, data source, processor and SSE stream. */
+  apply(url, shareToken, data) {
+    const room = this.room;
+    const oldId = room.participantId;
+    const token = String(data.sessionToken ?? "");
+    const newId = String(data.participantId ?? "");
+    const participants = data.participants ?? [];
+    room.participantId = newId;
+    room.authority = String(data.authority ?? room.authority);
+    room.participants = participants;
+    if (shareToken !== void 0) room.rejoin.shareToken = shareToken;
+    room.dataSource.setParticipants(participants);
+    room.dataSource.setSelf(newId, room.rejoin.name);
+    const { processor } = this.deps;
+    processor.setRoomParticipantId(room.roomId, newId);
+    if (processor.participantId === oldId) processor.participantId = newId;
+    this.swapSession(url, token);
+    this.log(`room "${room.roomName}": re-joined as "${room.rejoin.name}" at ${url}`);
+    const mode = processor.getModeForRoom(room.roomId);
+    if (mode !== "everyone") {
+      this.fetchFn(`${url}/set-mode`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+        body: JSON.stringify({ mode })
+      }).catch(() => {
+      });
+    }
+  }
+  swapSession(url, token) {
+    this.room.serverUrl = url;
+    this.room.sessionToken = token;
+    this.room.dataSource.setSession(url, token);
+    this.deps.sseMux.updateConnection(this.room.roomId, url, token);
+  }
+  removed() {
+    return this.loseFor(
+      `You were removed from room "${this.room.roomName}" by ${this.room.removedBy}, so apiary will not re-join it. Call join_room again only if you are invited back.`
+    );
+  }
+  loseFor(message) {
+    if (!this.lost) {
+      this.lost = new RoomConnectionError(message, true);
+      this.log(`room "${this.room.roomName}": giving up \u2014 ${message}`);
+      try {
+        this.deps.onLost?.(this.room, this.lost);
+      } catch {
+      }
+    }
+    return this.lost;
+  }
+  log(line) {
+    this.deps.log?.(line);
+  }
+};
+
 // src/cli/runtime-handlers.ts
+function trackRoomEvent(jr, event) {
+  if (event.type === "ParticipantJoined") {
+    jr.dataSource.addParticipant(event.participant);
+  } else if (event.type === "ParticipantLeft") {
+    jr.dataSource.removeParticipant(event.participant_id);
+  } else if (event.type === "ParticipantKicked") {
+    if (event.participant_id === jr.participantId) jr.removedBy = safeName(event.kicked_by);
+    jr.dataSource.removeParticipant(event.participant_id);
+  }
+}
+function safeName(name) {
+  return String(name ?? "").replace(/[^A-Za-z0-9 _.-]/g, "").trim().slice(0, 40) || "an admin";
+}
 function buildRuntimeMcpOptions(ctx) {
   const { processor, sseMux, joinResults, agentName, authority, onRoomJoined } = ctx;
-  const adminAction = (build) => async (room, participant) => {
-    const conn = processor.resolve(room);
-    if (!conn) return { success: false, error: `Unknown room "${room}".` };
-    const ds = conn.dataSource;
-    const p = conn.dataSource.listParticipants().find((pp) => pp.name === participant);
-    if (!p) return { success: false, error: `Unknown participant "${participant}".` };
-    const { path, body } = build(p.id);
+  const rejoinerFor = (roomId) => joinResults.find((j) => j.roomId === roomId)?.rejoiner;
+  sseMux.setRecoveryHandler({
+    authRejected: async (roomId, status, usedToken) => {
+      const r = rejoinerFor(roomId);
+      return r ? r.authRejected(status, usedToken) : false;
+    },
+    unreachable: async (roomId) => await rejoinerFor(roomId)?.unreachable() ?? false
+  });
+  const post = async (ds, path, body) => {
     try {
-      const res = await fetch(`${ds.serverUrl}${path}`, {
+      const res = await ds.request(path, {
         method: "POST",
-        headers: { "Content-Type": "application/json", Authorization: `Bearer ${ds.sessionToken}` },
+        headers: { "Content-Type": "application/json" },
         body: JSON.stringify(body)
       });
       if (!res.ok) return { success: false, error: await res.text() };
       return { success: true };
-    } catch {
-      return { success: false, error: "Server unreachable." };
+    } catch (err) {
+      const msg = err instanceof Error && err.name === "RoomConnectionError" ? err.message : "Server unreachable.";
+      return { success: false, error: msg };
     }
   };
+  const adminAction = (build) => async (room, participant) => {
+    const conn = processor.resolve(room);
+    if (!conn) return { success: false, error: `Unknown room "${room}".` };
+    const ds = conn.dataSource;
+    const p = conn.dataSource.listParticipants().find((pp) => pp.name === participant);
+    if (!p) return { success: false, error: `Unknown participant "${participant}".` };
+    const { path, body } = build(p.id);
+    return post(ds, path, body);
+  };
   return {
     resolver: processor,
     toolOptions: {
@@ -472,15 +794,9 @@ function buildRuntimeMcpOptions(ctx) {
       const conn = processor.resolve(room);
       if (!conn) return { success: false, error: `Unknown room "${room}".` };
       processor.setModeForRoom(conn.dataSource.roomId, mode, false);
-      try {
-        const ds = conn.dataSource;
-        const res = await fetch(`${ds.serverUrl}/set-mode`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json", Authorization: `Bearer ${ds.sessionToken}` },
-          body: JSON.stringify({ mode })
-        });
-        if (!res.ok) return { success: false, error: `Server rejected: ${await res.text()}` };
-      } catch {
+      const result = await post(conn.dataSource, "/set-mode", { mode });
+      if (!result.success && result.error !== "Server unreachable.") {
+        return { success: false, error: `Server rejected: ${result.error}` };
       }
       return { success: true };
     },
@@ -500,10 +816,7 @@ function buildRuntimeMcpOptions(ctx) {
       }
       const readState = async () => {
         try {
-          const res = await fetch(`${ds.serverUrl}/participants`, {
-            headers: { Authorization: `Bearer ${ds.sessionToken}` },
-            signal: AbortSignal.timeout(1e4)
-          });
+          const res = await ds.request("/participants", { signal: AbortSignal.timeout(1e4) });
           if (!res.ok) return "unknown";
           const data = await res.json();
           const found = data.participants?.find((pp) => pp.id === target.id);
@@ -526,17 +839,7 @@ function buildRuntimeMcpOptions(ctx) {
       const ds = conn.dataSource;
       const p = conn.dataSource.listParticipants().find((pp) => pp.name === participant);
       if (!p) return { success: false, error: `Unknown participant "${participant}".` };
-      try {
-        const res = await fetch(`${ds.serverUrl}/ping`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json", Authorization: `Bearer ${ds.sessionToken}` },
-          body: JSON.stringify({ participantId: p.id })
-        });
-        if (!res.ok) return { success: false, error: await res.text() };
-        return { success: true };
-      } catch {
-        return { success: false, error: "Server unreachable." };
-      }
+      return post(ds, "/ping", { participantId: p.id });
     },
     onJoinRoom: async (url, alias, nameOverride) => {
       const token = extractToken(url);
@@ -566,6 +869,12 @@ function buildRuntimeMcpOptions(ctx) {
         const roomAuthority = String(data.authority ?? "member");
         const participants = data.participants ?? [];
         const newParticipantId = String(data.participantId ?? "");
+        const existingIdx = joinResults.findIndex((j) => j.roomId === roomId);
+        if (existingIdx >= 0) {
+          sseMux.removeConnection(roomId);
+          processor.disconnectRemoteRoom(roomId);
+          joinResults.splice(existingIdx, 1);
+        }
         const dataSource = new RemoteRoomDataSource(serverUrl, sessionToken, roomId);
         dataSource.setParticipants(participants);
         dataSource.setSelf(newParticipantId, joinName);
@@ -576,6 +885,7 @@ function buildRuntimeMcpOptions(ctx) {
         const mode = processor.getModeForRoom(roomId) ?? "everyone";
         processor.connectRemoteRoom(dataSource, roomName);
         sseMux.addConnection(serverUrl, sessionToken, roomName, roomId);
+        const serverRoomName = String(data.roomName ?? "");
         const jr = {
           serverUrl,
           sessionToken,
@@ -584,8 +894,27 @@ function buildRuntimeMcpOptions(ctx) {
           roomId,
           authority: roomAuthority,
           participants,
-          dataSource
+          dataSource,
+          rejoin: {
+            joinUrl: url,
+            shareToken: token ?? void 0,
+            name: joinName,
+            type: "agent",
+            serverRoomName,
+            localTier: localTierOf(
+              token ?? void 0,
+              (ctx.rejoinOverrides?.readRoomSession ?? readLocalRoomSession)(serverRoomName)
+            )
+          }
         };
+        jr.rejoiner = new RoomRejoiner(jr, {
+          ...ctx.rejoinOverrides,
+          sseMux,
+          processor,
+          log: ctx.log,
+          onLost: ctx.onRoomLost ? (_room, err) => ctx.onRoomLost(jr, err) : void 0
+        });
+        dataSource.setRecovery(jr.rejoiner);
         joinResults.push(jr);
         const conn = processor.resolve(roomName);
         let recentLines = [];
@@ -631,6 +960,7 @@ function buildRuntimeMcpOptions(ctx) {
       const idx = joinResults.findIndex((jr) => jr.roomId === roomId);
       if (idx >= 0) {
         const jr = joinResults[idx];
+        jr.dataSource.setRecovery(null);
         sseMux.removeConnection(roomId);
         processor.disconnectRemoteRoom(roomId);
         try {
@@ -658,6 +988,7 @@ function buildRuntimeMcpOptions(ctx) {
 export {
   composerStillHolds,
   TmuxBridge,
+  trackRoomEvent,
   buildRuntimeMcpOptions
 };
-//# sourceMappingURL=chunk-36WX2UAF.js.map
+//# sourceMappingURL=chunk-OEAHTZCA.js.map