@moxt-ai/mobius 0.0.7 → 0.0.8

package/dist/cli.js

@@ -22338,7 +22338,7 @@ var AcpActivity = class _AcpActivity {
   toolKind;
   content;
   detail;
-  constructor(activityId, activityType, input2, locations, name, output2, sequence, status, title, toolKind, content = [], detail = captureActivityDetail(
+  constructor(activityId, activityType, input2, locations, name, output2, sequence, status, title2, toolKind, content = [], detail = captureActivityDetail(
     content,
     input2,
     output2
@@ -22351,7 +22351,7 @@ var AcpActivity = class _AcpActivity {
     this.output = output2;
     this.sequence = sequence;
     this.status = status;
-    this.title = title;
+    this.title = title2;
     this.toolKind = toolKind;
     this.content = content;
     this.detail = detail;
@@ -22567,8 +22567,8 @@ function normalizeToolStatus(status, fallback) {
   }
   return fallback;
 }
-function normalizeTitle(title, fallback) {
-  const normalized = title.trim();
+function normalizeTitle(title2, fallback) {
+  const normalized = title2.trim();
   return truncate(normalized.length === 0 ? fallback : normalized, 500);
 }
 function formatPlanEntries(entries) {
@@ -22814,12 +22814,13 @@ var AcpActivityTracker = class {
 
 // src/acp/native-session.ts
 var path = external_exports.string().min(1).max(2048).refine((value) => !value.includes("\0"));
+var title = external_exports.string().transform((value) => value.slice(0, 500));
 var nativeSessionIdSchema = external_exports.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,255}$/);
 var nativeSessionInfoSchema = external_exports.object({
   sessionId: nativeSessionIdSchema,
   cwd: path,
   additionalDirectories: external_exports.array(path).max(16).default([]).readonly(),
-  title: external_exports.string().max(500).nullish(),
+  title: title.nullish(),
   updatedAt: external_exports.iso.datetime({ offset: true }).nullish()
 }).readonly();
 var nativeSessionPageSchema = external_exports.object({
@@ -23142,6 +23143,12 @@ var AcpExecutionError = class extends Error {
     this.name = "AcpExecutionError";
   }
 };
+var RetryableAcpInitializationError = class extends AcpExecutionError {
+  constructor(cause) {
+    super("ACP agent initialization failed", { cause });
+    this.name = "RetryableAcpInitializationError";
+  }
+};
 function readableWebStream(input2) {
   let streamOpen = true;
   return new ReadableStream({
@@ -23771,42 +23778,63 @@ var AcpProcessSession = class _AcpProcessSession {
     );
     this.#connection = createAcpClient(this).connect(stream);
   }
-  static start = async (options, getObserver, store) => {
-    options.signal.throwIfAborted();
-    const [adapterUnchanged, agentUnchanged] = await Promise.all([
-      revalidateExecutable(options.agent.adapterIdentity),
-      revalidateExecutable(options.agent.agentIdentity)
-    ]);
-    options.signal.throwIfAborted();
-    if (!adapterUnchanged || !agentUnchanged) {
-      throw new AcpExecutionError(
-        "The local Agent runtime changed; restart Mobius before starting a new conversation",
-        {},
-        "agent_runtime_changed"
-      );
-    }
-    const runtime = new _AcpProcessSession(
-      options.agent,
-      options.cwd,
-      options.additionalDirectories,
-      options.sessionId,
-      getObserver,
-      store
-    );
-    try {
-      await runtime.initialize(options.signal, options.origin);
-      return runtime;
-    } catch (error61) {
-      await runtime.closeProcess();
+  static async #start(options, getObserver, store, initialize) {
+    for (let attempt = 1; attempt <= 2; attempt += 1) {
       options.signal.throwIfAborted();
-      if (error61 instanceof AcpExecutionError) {
-        throw error61;
+      const [adapterUnchanged, agentUnchanged] = await Promise.all([
+        revalidateExecutable(options.agent.adapterIdentity),
+        revalidateExecutable(options.agent.agentIdentity)
+      ]);
+      options.signal.throwIfAborted();
+      if (!adapterUnchanged || !agentUnchanged) {
+        throw new AcpExecutionError(
+          "The local Agent runtime changed; restart Mobius before starting a new conversation",
+          {},
+          "agent_runtime_changed"
+        );
+      }
+      const runtime = new _AcpProcessSession(
+        options.agent,
+        options.cwd,
+        options.additionalDirectories,
+        options.sessionId,
+        getObserver,
+        store
+      );
+      try {
+        await initialize(runtime);
+        return runtime;
+      } catch (error61) {
+        await runtime.closeProcess();
+        options.signal.throwIfAborted();
+        if (error61 instanceof RetryableAcpInitializationError && attempt === 1) {
+          console.warn(
+            `[${options.agent.id}-acp] ACP agent initialization failed; retrying once`
+          );
+          continue;
+        }
+        if (error61 instanceof AcpExecutionError) {
+          throw error61;
+        }
+        throw new AcpExecutionError("ACP agent initialization failed", {
+          cause: error61
+        });
       }
-      throw new AcpExecutionError("ACP agent initialization failed", {
-        cause: error61
-      });
     }
-  };
+    throw new AcpExecutionError("ACP agent initialization failed");
+  }
+  static start = async (options, getObserver, store) => await _AcpProcessSession.#start(
+    options,
+    getObserver,
+    store,
+    async (runtime) => await runtime.initialize(options.signal, options.origin)
+  );
+  static startNativeSessionBrowser = async (options, getObserver, store) => await _AcpProcessSession.#start(
+    options,
+    getObserver,
+    store,
+    async (runtime) => await runtime.#initializeAgent(options.signal)
+  );
   belongsTo = (agentId, cwd, additionalDirectories) => this.#agentId === agentId && this.#cwd === cwd && arraysEqual(this.#additionalDirectories, additionalDirectories);
   canRebind = () => !this.#prompted && !this.#turn.running;
   prepared = () => new AcpPreparedSession(
@@ -23843,7 +23871,7 @@ var AcpProcessSession = class _AcpProcessSession {
       this.#replay = { kind: "idle" };
     }
   };
-  initialize = async (signal, origin) => {
+  async #initializeAgent(signal) {
     const initialized = await this.race(
       this.#connection.agent.request(
         methods3.agent.initialize,
@@ -23860,7 +23888,10 @@ var AcpProcessSession = class _AcpProcessSession {
       ),
       "ACP agent exited during initialization",
       signal
-    );
+    ).catch((cause) => {
+      signal.throwIfAborted();
+      throw new RetryableAcpInitializationError(cause);
+    });
     if (initialized.protocolVersion !== PROTOCOL_VERSION2) {
       throw new AcpExecutionError(
         "ACP agent selected an unsupported protocol version",
@@ -23875,6 +23906,9 @@ var AcpProcessSession = class _AcpProcessSession {
       255
     );
     this.#agentVersion = truncate2(initialized.agentInfo?.version ?? "", 128);
+  }
+  initialize = async (signal, origin) => {
+    await this.#initializeAgent(signal);
     const stored = origin?.kind === "import" ? new FoundAcpStoredSession(
       new AcpStoredSession(
         this.#mobiusSessionId,
@@ -24699,6 +24733,10 @@ var AcpProcessSession = class _AcpProcessSession {
 };
 var AcpSessionManager = class {
   #nativeOperations = /* @__PURE__ */ new Set();
+  #nativeBrowserObserver = new NullAcpSessionObserver();
+  #nativeBrowserPreparing = /* @__PURE__ */ new Map();
+  #nativeBrowserSessions = /* @__PURE__ */ new Map();
+  #nativeBrowserStore = new MemoryAcpSessionStore();
   #activeSessionIds = /* @__PURE__ */ new Set();
   #cancellationRequests = /* @__PURE__ */ new Set();
   #preparing = /* @__PURE__ */ new Map();
@@ -24712,6 +24750,43 @@ var AcpSessionManager = class {
   setObserver = (observer) => {
     this.#observer = observer;
   };
+  async #startNativeBrowserPreparation(options) {
+    const operation = (async () => {
+      try {
+        const runtime = await AcpProcessSession.startNativeSessionBrowser(
+          options,
+          () => this.#nativeBrowserObserver,
+          this.#nativeBrowserStore
+        );
+        this.#nativeBrowserSessions.set(options.sessionId, runtime);
+        return runtime;
+      } finally {
+        this.#nativeBrowserPreparing.delete(options.sessionId);
+      }
+    })();
+    this.#nativeBrowserPreparing.set(options.sessionId, operation);
+    return await operation;
+  }
+  async #replaceNativeBrowserPreparation(existing, options) {
+    const operation = (async () => {
+      try {
+        this.#nativeBrowserSessions.delete(options.sessionId);
+        await existing.close();
+        this.#nativeBrowserStore.remove(options.sessionId);
+        const runtime = await AcpProcessSession.startNativeSessionBrowser(
+          options,
+          () => this.#nativeBrowserObserver,
+          this.#nativeBrowserStore
+        );
+        this.#nativeBrowserSessions.set(options.sessionId, runtime);
+        return runtime;
+      } finally {
+        this.#nativeBrowserPreparing.delete(options.sessionId);
+      }
+    })();
+    this.#nativeBrowserPreparing.set(options.sessionId, operation);
+    return await operation;
+  }
   async #startPreparation(options) {
     const operation = (async () => {
       try {
@@ -24799,6 +24874,44 @@ var AcpSessionManager = class {
     const runtime = await this.#startPreparation(options);
     return runtime.prepared();
   };
+  prepareNativeSessionBrowser = async (options) => {
+    const pending = this.#nativeBrowserPreparing.get(options.sessionId);
+    if (pending !== void 0) {
+      const runtime2 = await pending;
+      if (runtime2.belongsTo(
+        options.agent.id,
+        options.cwd,
+        options.additionalDirectories
+      )) {
+        return runtime2.prepared();
+      }
+      return await this.prepareNativeSessionBrowser(options);
+    }
+    const existing = this.#nativeBrowserSessions.get(options.sessionId);
+    if (existing !== void 0) {
+      if (existing.belongsTo(
+        options.agent.id,
+        options.cwd,
+        options.additionalDirectories
+      )) {
+        return existing.prepared();
+      }
+      if (!existing.canRebind()) {
+        throw new AcpExecutionError(
+          "The agent or workspace cannot change after a conversation has started",
+          {},
+          "session_identity_mismatch"
+        );
+      }
+      const runtime2 = await this.#replaceNativeBrowserPreparation(
+        existing,
+        options
+      );
+      return runtime2.prepared();
+    }
+    const runtime = await this.#startNativeBrowserPreparation(options);
+    return runtime.prepared();
+  };
   configureSession = async (options) => {
     const runtime = await this.ensureSession(options);
     return await runtime.configure(options);
@@ -24887,8 +25000,14 @@ var AcpSessionManager = class {
   };
   close = async () => {
     const sessions = [...this.#sessions.values()];
+    const nativeBrowserSessions = [...this.#nativeBrowserSessions.values()];
     this.#sessions.clear();
-    await Promise.all(sessions.map(async (session) => await session.close()));
+    this.#nativeBrowserSessions.clear();
+    await Promise.all(
+      [...sessions, ...nativeBrowserSessions].map(
+        async (session) => await session.close()
+      )
+    );
   };
   ensureSession = async (options) => {
     const existing = this.#sessions.get(options.sessionId);
@@ -24913,7 +25032,30 @@ var AcpSessionManager = class {
     }
     return started;
   };
-  listNativeSessions = async (options, cursor) => await (await this.ensureSession(options)).listNativeSessions(
+  async #ensureNativeSessionBrowser(options) {
+    const existing = this.#nativeBrowserSessions.get(options.sessionId);
+    if (existing !== void 0) {
+      if (!existing.belongsTo(
+        options.agent.id,
+        options.cwd,
+        options.additionalDirectories
+      )) {
+        throw new AcpExecutionError(
+          "The agent or workspace cannot change after a conversation has started",
+          {},
+          "session_identity_mismatch"
+        );
+      }
+      return existing;
+    }
+    await this.prepareNativeSessionBrowser(options);
+    const started = this.#nativeBrowserSessions.get(options.sessionId);
+    if (started === void 0) {
+      throw new AcpExecutionError("ACP native session browser did not start");
+    }
+    return started;
+  }
+  listNativeSessions = async (options, cursor) => await (await this.#ensureNativeSessionBrowser(options)).listNativeSessions(
     cursor,
     options.signal
   );
@@ -24996,7 +25138,7 @@ var AcpSessionManager = class {
     }
   };
   deleteNativeSession = async (options, nativeSessionId) => {
-    const runtime = await this.ensureSession(options);
+    const runtime = await this.#ensureNativeSessionBrowser(options);
     const key = `${options.agent.id}:${nativeSessionId}`;
     const linked = this.#store.findNative(options.agent.id, nativeSessionId);
     if (this.#nativeOperations.has(key) || linked.some(
@@ -25023,7 +25165,8 @@ var AcpSessionManager = class {
         nativeSessionId
       );
       if (runtime.nativeSessionId() === nativeSessionId) {
-        this.#sessions.delete(options.sessionId);
+        this.#nativeBrowserSessions.delete(options.sessionId);
+        this.#nativeBrowserStore.remove(options.sessionId);
         await runtime.close();
       }
       return deleted;
@@ -26712,7 +26855,7 @@ var NativeSessionService = class {
       sessionId: command.sessionId,
       signal
     };
-    const prepared = await this.#sessions.prepareSession(options);
+    const prepared = await this.#sessions.prepareNativeSessionBrowser(options);
     if (!prepared.capabilities.listSessions)
       throw new AcpExecutionError(
         "This Agent does not support native session listing",
@@ -27774,6 +27917,15 @@ async function executeSessionPrepare(outbox, socket, command, config2, directori
       })
     );
   } catch (error61) {
+    audit.record({
+      commandId: command.requestId,
+      details: {
+        agentId: command.agentId,
+        code: operationErrorCode(error61)
+      },
+      event: "session_prepare_failed",
+      sessionId: command.sessionId
+    });
     reportOperationFailure(socket, command.requestId, command.sessionId, error61);
   }
 }