@moxt-ai/mobius 0.0.293 → 0.0.295

package/dist/runtime.js

@@ -958,6 +958,16 @@ function normalizeAcpCapabilities(initialized) {
     unstableForkSession: session?.fork != null
   });
 }
+function restrictAcpSessionCapabilities(capabilities, response) {
+  if (!isRecord(response) || !isRecord(response["_meta"])) {
+    return capabilities;
+  }
+  const steering = response["_meta"]["steering"];
+  if (!isRecord(steering) || steering["supported"] !== false) {
+    return capabilities;
+  }
+  return Object.freeze({ ...capabilities, steering: false });
+}
 
 // src/acp/agent/agent-definition.ts
 var AgentDefinition = class {
@@ -22572,7 +22582,7 @@ import { fetch as fetch3 } from "undici";
 // package.json
 var package_default = {
   name: "@moxt-ai/mobius",
-  version: "0.0.293",
+  version: "0.0.295",
   description: "Mobius CLI for pairing and running local AI agent services.",
   type: "module",
   bin: {
@@ -22721,6 +22731,7 @@ import { mkdir as CL, readdir as snt, readFile as sne, rm as int2, writeFile as
 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";
@@ -54174,6 +54185,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") };
 }
@@ -58814,6 +58897,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 {
@@ -59227,7 +59379,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
@@ -62054,17 +62225,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;
@@ -63563,10 +63723,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;
@@ -63790,8 +63946,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;
@@ -64174,9 +64330,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;
@@ -67317,6 +67470,7 @@ var queuePageSchema = external_exports.object({
   nextCursor: external_exports.string().nullish()
 });
 var CodexBorrowedAcpAgent = class {
+  steeringSupported = false;
   #client;
   #threadId;
   #emit;
@@ -67538,7 +67692,7 @@ var CodexBorrowedAcpAgent = class {
   nativeTurnId = () => null;
   steer = async (_params, signal) => {
     signal.throwIfAborted();
-    return { outcome: "promptRequired", reason: "noRunningTurn" };
+    throw new AcpExecutionError("This Codex session only supports queued input", {}, "steering_unsupported");
   };
   // The reader connection cannot receive or control the owner's live turn.
   onNotification = async (_method, _params) => {
@@ -67678,6 +67832,7 @@ function userInputSchema(questions) {
   return { properties, required: required2, type: "object" };
 }
 var CodexOwnedAcpAgent = class {
+  steeringSupported = true;
   #context;
   #appServer;
   #settings;
@@ -68729,7 +68884,10 @@ var CodexAcpAgent = class {
       await this.#resume(context.params.sessionId, context.params.cwd, context.signal);
       await this.#replaySavedHistory(context.signal);
       this.#advertiseCompactCommand();
-      return { configOptions: this.#settings.configOptions() };
+      return {
+        _meta: { steering: { supported: this.#sessionAgent.steeringSupported } },
+        configOptions: this.#settings.configOptions()
+      };
     }).onRequest(methods3.agent.session.fork, async (context) => {
       const forked = threadForkResponseSchema.parse(
         await this.#appServer.request(
@@ -68752,7 +68910,10 @@ var CodexAcpAgent = class {
     }).onRequest(methods3.agent.session.resume, async (context) => {
       await this.#resume(context.params.sessionId, context.params.cwd, context.signal);
       this.#advertiseCompactCommand();
-      return { configOptions: this.#settings.configOptions() };
+      return {
+        _meta: { steering: { supported: this.#sessionAgent.steeringSupported } },
+        configOptions: this.#settings.configOptions()
+      };
     }).onRequest(methods3.agent.session.prompt, async (context) => {
       if (isCompactCommand(context.params.prompt)) {
         return await this.#sessionAgent.compact(context.signal);
@@ -83630,6 +83791,7 @@ async function restoreSession(session, signal, recovery, origin) {
     session.setNativeHistoryOwnership({ kind: "fresh-session" });
     lifecycleResponse2 = created;
   }
+  session.restrictSessionCapabilities(lifecycleResponse2);
   session.setConfigOptions(session.sessionConfigProtocol.normalizeLifecycle(lifecycleResponse2));
   if (stored instanceof FoundStoredSession && session.restored) {
     await session.restoreStoredConfigurations(stored.session, signal);
@@ -83882,6 +84044,9 @@ var AgentSession = class _AgentSession {
       signal
     );
   };
+  restrictSessionCapabilities = (response) => {
+    this.#capabilities = restrictAcpSessionCapabilities(this.#capabilities, response);
+  };
   prepared = () => new PreparedSession(
     this.#agentName,
     this.#agentVersion,
@@ -83955,6 +84120,7 @@ var AgentSession = class _AgentSession {
         );
         await this.#updates.drained();
         signal.throwIfAborted();
+        this.restrictSessionCapabilities(response);
         const loaded = { history, kind: "loaded", response };
         this.#sessionLoad = loaded;
         return loaded;