@moxt-ai/mobius 0.0.294 → 0.0.296

package/dist/cli.js

@@ -5398,7 +5398,7 @@ var program = new Command();
 // package.json
 var package_default = {
   name: "@moxt-ai/mobius",
-  version: "0.0.294",
+  version: "0.0.296",
   description: "Mobius CLI for pairing and running local AI agent services.",
   type: "module",
   bin: {
@@ -5547,6 +5547,7 @@ import { mkdir as CL, readdir as snt, readFile as sne, rm as int, writeFile as i
 import { createRequire as ant } from "module";
 import { homedir as kL, tmpdir as cnt } from "os";
 import { dirname as RL, isAbsolute as ane, join as vn, relative as cne, resolve as Vh, sep as IL } from "path";
+import { createInterface as lnt } from "readline";
 import { fileURLToPath as unt } from "url";
 import { setMaxListeners as bae } from "events";
 import { spawn as BFe } from "child_process";
@@ -37000,6 +37001,78 @@ function mZ(e, t, n, r) {
   if (!p) p = `${r() || "Forked session"} (fork)`;
   return u.push({ type: "custom-title", sessionId: c, customTitle: p, uuid: zS(), timestamp: l }), { entries: u, forkedSessionId: c };
 }
+function BS(e) {
+  return ["subagents", ...e.agentRelPath ?? [], e.kind === "agent" ? `agent-${e.agentId}` : "journal"].join("/");
+}
+async function KP(e, t, n, r, o, s = PKe) {
+  let i = [], a = 0, c, l = false;
+  for (let u = 0; u < s; u++) {
+    let p = await e.readRecords(t, { order: "forward", maxBytes: OKe, ...c !== void 0 && { fromSeq: c } });
+    if (!p.ok) throw new Ze(`importSessionToStore: transcript read failed (${p.error.code})`, "importSessionToStore: transcript read failed");
+    for (let f of p.value.items) {
+      let m = Buffer.from(f.data.buffer, f.data.byteOffset, f.data.byteLength).toString("utf8").replace(/\r?\n$/, "");
+      if (!m) continue;
+      try {
+        i.push(lt(m));
+      } catch (h) {
+        ce(`importSessionToStore: skipping unparseable record ${f.seq}: ${h}`);
+        continue;
+      }
+      if (a += m.length, i.length >= o || a >= Ou) await r.append(n, i), i = [], a = 0;
+    }
+    if (c = p.value.nextSeq, c === void 0) {
+      l = true;
+      break;
+    }
+  }
+  if (!l) throw new Ze("importSessionToStore: transcript read did not end (page cap reached)", "importSessionToStore: transcript read did not end");
+  if (i.length > 0) await r.append(n, i);
+}
+var OKe = 67108864;
+var PKe = 1e5;
+var IKe = 1e4;
+async function AZ(e, t, n, r = IKe) {
+  let o = [], s = [{ namespace: "transcript", projectKey: t, sessionId: n }], i = /* @__PURE__ */ new Set([""]), a = /* @__PURE__ */ new Set(), c = 0;
+  while (s.length > 0) {
+    if (++c > r) throw Error("importSessionToStore: subagent listing did not end (scope cap reached)");
+    let l = s.shift(), u = [];
+    if ((await Ao((f) => e.listEntries(l, { skipKeyStats: true, skipScopeStats: true, ...f !== void 0 && { cursor: f } }), (f) => {
+      for (let m of f) if (m.kind === "key" && m.key.namespace === "transcript") {
+        let h = m.key.agentRelPath;
+        if (h !== void 0 && !sr(h)) continue;
+        let y = m.key.agentId !== void 0 ? pn(m.key.agentId) ? { kind: "agent", agentId: m.key.agentId, ...h && { agentRelPath: h } } : void 0 : m.key.journal === true && h !== void 0 ? { kind: "journal", agentRelPath: h } : void 0, _ = y && BS(y);
+        if (y && _ !== void 0 && !a.has(_)) a.add(_), o.push(y);
+      } else if (m.kind === "scope" && m.scope.namespace === "transcript" && m.scope.agentRelPath !== void 0 && sr(m.scope.agentRelPath) && !i.has(m.scope.agentRelPath.join("/"))) i.add(m.scope.agentRelPath.join("/")), u.push({ namespace: "transcript", projectKey: t, sessionId: n, agentRelPath: m.scope.agentRelPath });
+    })).status !== "done") throw Error("importSessionToStore: subagent listing failed");
+    s.unshift(...u);
+  }
+  return o;
+}
+function DKe(e, t, n) {
+  return tn.sidecar(e, t, ["subagents", ...n.agentRelPath ?? [], n.kind === "agent" ? `agent-${n.agentId}.meta.json` : "journal.meta.json"]);
+}
+async function TZ(e, t, n, r) {
+  let o = r.map((a) => ({ subpath: BS(a), key: DKe(t, n, a) })).filter(({ key: a }) => Ms(a) === void 0), s = /* @__PURE__ */ new Map();
+  if (o.length === 0) return s;
+  let i = await e.readText(o.map(({ key: a }) => a));
+  if (i.ok) return i.value.items.forEach((a, c) => {
+    if (a.found) s.set(o[c].subpath, a.value);
+  }), s;
+  if (!vZ(i.error)) throw wZ(i.error.code);
+  for (let { subpath: a, key: c } of o) {
+    let l = await e.readText([c]);
+    if (l.ok) {
+      if (l.value.items[0].found) s.set(a, l.value.items[0].value);
+    } else if (!vZ(l.error)) throw wZ(l.error.code);
+  }
+  return s;
+}
+function vZ(e) {
+  return e.code === "Failed" && (e.telemetryCode === "ELOOP" || e.telemetryCode === "ENXIO");
+}
+function wZ(e) {
+  return new Ze(`importSessionToStore: sidecar read failed (${e})`, "importSessionToStore: sidecar read failed");
+}
 function OZ(e) {
   return { globalConfig: GP(e || CZ(), ".claude.json"), userSettings: GP(e || GP(CZ(), ".claude"), "settings.json") };
 }
@@ -41640,6 +41713,75 @@ async function KZt(e, t) {
   if (t?.sessionStore) return Tnt(t.sessionStore, e, t);
   return pZ(e, t);
 }
+async function GZt(e, t, n, r) {
+  if (!Je(e)) throw new Ze(`Invalid sessionId: ${e}`, "importSessionToStore: invalid sessionId (must be a UUID)");
+  let o = ye(), s = o ? r : void 0, i = await Ni(e, n?.dir, ir(s), o);
+  if (!i) throw Error(`Session ${e} not found`);
+  let a = no(n?.dir), c = n?.batchSize && n.batchSize > 0 ? n.batchSize : Wy, l = s === void 0 ? void 0 : ac(RL(i.filePath), pn), u = s !== void 0 && l !== void 0 ? { backend: s, projectKey: l } : void 0;
+  if (u !== void 0) await KP(u.backend, tn.transcript(u.projectKey, e), { projectKey: a, sessionId: e }, t, c);
+  else await rne(i.filePath, { projectKey: a, sessionId: e }, t, c);
+  if (n?.includeSubagents === false) return;
+  if (u !== void 0) {
+    let m = await AZ(u.backend, u.projectKey, e), h = await TZ(u.backend, u.projectKey, e, m);
+    for (let y of m) {
+      let _ = { projectKey: a, sessionId: e, subpath: BS(y) };
+      await KP(u.backend, y.kind === "agent" ? tn.transcript(u.projectKey, e, y.agentId, y.agentRelPath) : tn.journal(u.projectKey, e, y.agentRelPath), _, t, c);
+      let E = h.get(_.subpath), S;
+      if (E !== void 0) try {
+        S = lt(E);
+      } catch (x) {
+        ce(`importSessionToStore: skipping unreadable sidecar for ${_.subpath}: ${x}`);
+      }
+      if (S !== void 0) await t.append(_, [{ type: "agent_metadata", ...S }]);
+    }
+    return;
+  }
+  let p = i.filePath.replace(/\.jsonl$/, ""), f = vn(p, "subagents");
+  for (let m of await ynt(f)) {
+    let h = cne(p, m).split(IL);
+    h[h.length - 1] = h.at(-1).replace(/\.jsonl$/, "");
+    let y = { projectKey: a, sessionId: e, subpath: h.join("/") };
+    await rne(m, y, t, c);
+    let _ = m.replace(/\.jsonl$/, ".meta.json"), E;
+    try {
+      E = lt(await sne(_, "utf8"));
+    } catch (S) {
+      if (!wr(S)) ce(`importSessionToStore: skipping unreadable sidecar ${_}: ${S}`);
+    }
+    if (E !== void 0) await t.append(y, [{ type: "agent_metadata", ...E }]);
+  }
+}
+async function rne(e, t, n, r) {
+  let o = lnt({ input: rnt(e, { encoding: "utf8" }), crlfDelay: 1 / 0 }), s = [], i = 0;
+  for await (let a of o) {
+    if (!a) continue;
+    try {
+      s.push(lt(a));
+    } catch (c) {
+      ce(`importSessionToStore: skipping unparseable line in ${e}: ${c}`);
+      continue;
+    }
+    if (i += a.length, s.length >= r || i >= Ou) await n.append(t, s), s = [], i = 0;
+  }
+  if (s.length > 0) await n.append(t, s);
+}
+async function ynt(e) {
+  let t = [];
+  async function n(r) {
+    let o;
+    try {
+      o = await snt(r, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (let s of o) {
+      let i = vn(r, s.name);
+      if (s.isDirectory()) await n(i);
+      else if (s.isFile() && s.name.endsWith(".jsonl")) t.push(i);
+    }
+  }
+  return await n(e), t;
+}
 function une(e) {
   let t = Vh(e ?? "."), n;
   try {
@@ -42053,7 +42195,26 @@ function listEnvironmentSessions(environment, cwd, signal) {
 // src/acp/harness/claude/upstream/dist/environment-session-messages.js
 var SESSION_MESSAGES_TIMEOUT_MILLISECONDS = 3e4;
 function getEnvironmentSessionMessages(environment, sessionId, signal) {
-  return withEnvironment(environment, () => withDeadline(signal, SESSION_MESSAGES_TIMEOUT_MILLISECONDS, () => FZt(sessionId)));
+  return withEnvironment(environment, () => withDeadline(signal, SESSION_MESSAGES_TIMEOUT_MILLISECONDS, async () => {
+    const messages = await FZt(sessionId);
+    if (!messages.some(({ type, message }) => type === "assistant" && typeof message === "object" && message !== null && "model" in message && message.model === "<synthetic>")) {
+      return messages;
+    }
+    const authenticationFailures = /* @__PURE__ */ new Set();
+    await GZt(sessionId, {
+      append: async (_key, entries) => {
+        signal.throwIfAborted();
+        for (const entry of entries) {
+          if (entry.type === "assistant" && entry["error"] === "authentication_failed" && typeof entry.uuid === "string") {
+            authenticationFailures.add(entry.uuid);
+          }
+        }
+      },
+      load: async () => null
+    }, { includeSubagents: false });
+    signal.throwIfAborted();
+    return messages.filter((message) => !authenticationFailures.has(message.uuid));
+  }));
 }
 
 // src/acp/harness/claude/upstream/dist/session-config-ids.js
@@ -64550,17 +64711,6 @@ function stripLocalCommandMetadata(content) {
   }
   return kept;
 }
-function isSyntheticLoginMessage(apiMessage) {
-  if (!apiMessage || typeof apiMessage !== "object") {
-    return false;
-  }
-  const { model, content } = apiMessage;
-  if (model !== "<synthetic>" || !Array.isArray(content) || content.length !== 1) {
-    return false;
-  }
-  const block = content[0];
-  return !!block && block.type === "text" && typeof block.text === "string" && block.text.includes("Please run /login");
-}
 var ClientConnection = class {
   ctx;
   onSessionUpdate;
@@ -66059,10 +66209,6 @@ ${message.api_refusal_explanation}` : "";
               }
               switch (message.subtype) {
                 case "success": {
-                  if (message.result.includes("Please run /login")) {
-                    failActive(RequestError3.authRequired());
-                    break;
-                  }
                   if (message.stop_reason === "max_tokens") {
                     stopReason = "max_tokens";
                     break;
@@ -66286,8 +66432,8 @@ ${message.api_refusal_explanation}` : "";
             if (message.message.role === "system") {
               break;
             }
-            if (message.type === "assistant" && isSyntheticLoginMessage(message.message)) {
-              failActive(RequestError3.authRequired());
+            if (message.type === "assistant" && message.error === "authentication_failed") {
+              failActive(RequestError3.authRequired(errorKindData(message.error)));
               break;
             }
             let content;
@@ -66670,9 +66816,6 @@ ${message.api_refusal_explanation}` : "";
       if (replaySession && replayMessageId && message.uuid) {
         replaySession.messageIdToUuid.set(replayMessageId, message.uuid);
       }
-      if (message.type === "assistant" && isSyntheticLoginMessage(message.message)) {
-        continue;
-      }
       const parentToolUseId = parentToolUseIdOf(message);
       if (parentToolUseId !== null && !forwardSubagentText) {
         continue;
@@ -96703,37 +96846,44 @@ async function runRelayConnection({
 // src/runtime/relay/session-event-publisher.ts
 import { WebSocket as WebSocket8 } from "undici";
 var MAX_BUFFERED_BYTES = 32 * 1024 * 1024;
+var MAX_PENDING_BYTES2 = 32 * 1024 * 1024;
 var MAX_EVENT_BATCH_BYTES = 1024 * 1024;
 var MAX_FRAME_BYTES = 8 * 1024 * 1024;
 var LOCAL_BACKPRESSURE_CLOSE_CODE = 4009;
 var EMPTY_ENVELOPE_BYTES = Buffer.byteLength(JSON.stringify({ events: [], kind: SESSION_EVENT_KIND }));
 var SESSION_EVENT_BATCH_WINDOW_MILLISECONDS = 100;
 var RuntimeSessionEventPublisher = class {
-  #pendingEvents = [];
-  #pendingBytes = EMPTY_ENVELOPE_BYTES;
+  #pending = [];
+  #pendingBytes = 0;
+  #overflowReported = false;
   #pendingTask = null;
-  #socket = null;
+  #connection = { kind: "disconnected" };
   #timer;
   constructor(timer) {
     this.#timer = timer;
   }
   connect = (socket) => {
-    this.dropPendingEvents();
-    this.#socket = socket;
+    if (this.#connection.kind === "closed") {
+      return;
+    }
+    this.#connection = { kind: "connected", socket };
+    this.flushEvents(socket);
   };
   disconnect = (socket) => {
-    if (this.#socket === socket) {
-      this.#socket = null;
-      this.dropPendingEvents();
+    if (this.#connection.kind === "connected" && this.#connection.socket === socket) {
+      this.#connection = { kind: "disconnected" };
+      this.cancelFlush();
     }
   };
   close = () => {
-    this.#socket = null;
-    this.dropPendingEvents();
+    this.#connection = { kind: "closed" };
+    this.cancelFlush();
+    this.#pending.length = 0;
+    this.#pendingBytes = 0;
   };
   flush = () => {
-    if (this.#socket !== null) {
-      this.flushEvents(this.#socket);
+    if (this.#connection.kind === "connected") {
+      this.flushEvents(this.#connection.socket);
     }
   };
   publishOperationFailure = (sessionId, requestId, code, message) => {
@@ -96743,10 +96893,11 @@ var RuntimeSessionEventPublisher = class {
   publishInfo = (event) => this.#send(event);
   publishClosed = (event) => this.#send(event);
   #send = (message) => {
-    const socket = this.#socket;
-    if (socket === null || socket.readyState !== WebSocket8.OPEN) {
+    const connection = this.#connection;
+    if (connection.kind !== "connected" || connection.socket.readyState !== WebSocket8.OPEN) {
       return;
     }
+    const socket = connection.socket;
     const encoded = encodeDaemonToServiceMessage(message);
     if (socket.bufferedAmount + Buffer.byteLength(encoded, "utf8") > MAX_BUFFERED_BYTES) {
       socket.close(LOCAL_BACKPRESSURE_CLOSE_CODE, "Live event transport overloaded");
@@ -96758,8 +96909,7 @@ var RuntimeSessionEventPublisher = class {
     }
   };
   publish = (event) => {
-    const socket = this.#socket;
-    if (socket === null || socket.readyState !== WebSocket8.OPEN) {
+    if (this.#connection.kind === "closed") {
       return;
     }
     const bytes = Buffer.byteLength(JSON.stringify(event), "utf8") + 1;
@@ -96772,15 +96922,34 @@ var RuntimeSessionEventPublisher = class {
       });
       return;
     }
-    if (this.#pendingEvents.length > 0 && this.#pendingBytes + bytes > MAX_EVENT_BATCH_BYTES) {
-      this.flushEvents(socket);
-      if (socket.readyState !== WebSocket8.OPEN) {
-        return;
+    let batch = this.#pending.at(-1);
+    const newBatch = batch === void 0 || batch.events.length >= SESSION_EVENT_BATCH_MAX_SIZE || batch.bytes + bytes > MAX_EVENT_BATCH_BYTES;
+    const additionalBytes = bytes + (newBatch ? EMPTY_ENVELOPE_BYTES : 0);
+    if (this.#pendingBytes + additionalBytes > MAX_PENDING_BYTES2) {
+      if (!this.#overflowReported) {
+        this.#overflowReported = true;
+        console.warn("Live Session output exceeded the pending buffer limit", {
+          code: "live_event_buffer_full",
+          sessionId: event.sessionId,
+          eventId: event.eventId,
+          maximumBytes: MAX_PENDING_BYTES2
+        });
       }
+      return;
     }
-    this.#pendingEvents.push(event);
-    this.#pendingBytes += bytes;
-    if (this.#pendingEvents.length >= SESSION_EVENT_BATCH_MAX_SIZE || this.#pendingBytes >= MAX_EVENT_BATCH_BYTES) {
+    if (batch === void 0 || newBatch) {
+      batch = { events: [], bytes: EMPTY_ENVELOPE_BYTES };
+      this.#pending.push(batch);
+    }
+    batch.events.push(event);
+    batch.bytes += bytes;
+    this.#pendingBytes += additionalBytes;
+    const connection = this.#connection;
+    if (connection.kind !== "connected" || connection.socket.readyState !== WebSocket8.OPEN) {
+      return;
+    }
+    const socket = connection.socket;
+    if (this.#pending.length > 1 || batch.events.length >= SESSION_EVENT_BATCH_MAX_SIZE || batch.bytes >= MAX_EVENT_BATCH_BYTES) {
       this.flushEvents(socket);
       return;
     }
@@ -96789,29 +96958,35 @@ var RuntimeSessionEventPublisher = class {
       SESSION_EVENT_BATCH_WINDOW_MILLISECONDS
     );
   };
-  dropPendingEvents = () => {
+  cancelFlush = () => {
     this.#pendingTask?.cancel();
     this.#pendingTask = null;
-    this.#pendingEvents = [];
-    this.#pendingBytes = EMPTY_ENVELOPE_BYTES;
   };
   flushEvents = (socket) => {
-    this.#pendingTask?.cancel();
-    this.#pendingTask = null;
-    const events = this.#pendingEvents;
-    this.#pendingEvents = [];
-    this.#pendingBytes = EMPTY_ENVELOPE_BYTES;
-    if (events.length === 0 || this.#socket !== socket || socket.readyState !== WebSocket8.OPEN) {
+    this.cancelFlush();
+    const connection = this.#connection;
+    if (connection.kind !== "connected" || connection.socket !== socket || socket.readyState !== WebSocket8.OPEN) {
       return;
     }
-    const encoded = encodeDaemonToServiceMessage({ events, kind: SESSION_EVENT_KIND });
-    if (socket.bufferedAmount + Buffer.byteLength(encoded, "utf8") > MAX_BUFFERED_BYTES) {
-      socket.close(LOCAL_BACKPRESSURE_CLOSE_CODE, "Live event transport overloaded");
-      return;
+    let attempted = 0;
+    for (const batch of this.#pending) {
+      const encoded = encodeDaemonToServiceMessage({ events: batch.events, kind: SESSION_EVENT_KIND });
+      if (socket.bufferedAmount + Buffer.byteLength(encoded, "utf8") > MAX_BUFFERED_BYTES) {
+        socket.close(LOCAL_BACKPRESSURE_CLOSE_CODE, "Live event transport overloaded");
+        break;
+      }
+      attempted += 1;
+      this.#pendingBytes -= batch.bytes;
+      try {
+        socket.send(encoded);
+      } catch {
+        console.warn("Live Session output could not be sent", { code: "live_event_send_failed" });
+        break;
+      }
     }
-    try {
-      socket.send(encoded);
-    } catch {
+    this.#pending.splice(0, attempted);
+    if (this.#pending.length === 0) {
+      this.#overflowReported = false;
     }
   };
 };