@openacp/cli 2026.41.1 → 2026.41.2

package/dist/index.js

@@ -2032,6 +2032,7 @@ async function createApiServer(options) {
           return { port: Number(url.port), host: url.hostname };
         } catch (err) {
           if (err?.code === "EADDRINUSE" && attempt < maxRetries && port < 65535) {
+            console.log(`[api-server] Port ${port} in use, trying ${port + 1}...`);
             port++;
             continue;
           }
@@ -3549,14 +3550,6 @@ ${stderr}`
             };
             break;
           }
-          case "current_mode_update": {
-            const cm = update;
-            event = {
-              type: "current_mode_update",
-              modeId: cm.currentModeId
-            };
-            break;
-          }
           case "config_option_update": {
             const co = update;
             event = {
@@ -3574,10 +3567,10 @@ ${stderr}`
             break;
           }
           // NOTE: model_update is NOT a session update type in the ACP SDK schema.
-          // Model changes are applied via the unstable_setSessionModel() method and
-          // the response is synchronous — the SDK does not push a model_update
-          // notification to the client. Therefore AgentEvent "model_update" cannot
-          // originate from sessionUpdate and must be emitted by callers of setModel()
+          // Model changes are applied via setSessionConfigOption() and the response
+          // is synchronous — the SDK does not push a model_update notification to
+          // the client. Therefore AgentEvent "model_update" cannot originate from
+          // sessionUpdate and must be emitted by callers of setConfigOption()
           // if they need to propagate the change downstream.
           default:
             return;
@@ -3659,9 +3652,6 @@ ${stderr}`
     };
   }
   // ── New ACP methods ──────────────────────────────────────────────────
-  async setMode(modeId) {
-    await this.connection.setSessionMode({ sessionId: this.sessionId, modeId });
-  }
   async setConfigOption(configId, value) {
     return await this.connection.setSessionConfigOption({
       sessionId: this.sessionId,
@@ -3669,12 +3659,6 @@ ${stderr}`
       ...value
     });
   }
-  async setModel(modelId) {
-    await this.connection.unstable_setSessionModel({
-      sessionId: this.sessionId,
-      modelId
-    });
-  }
   async listSessions(cwd, cursor) {
     return await this.connection.listSessions({
       cwd: cwd ?? null,
@@ -3946,12 +3930,8 @@ var Session = class extends TypedEmitter {
   name;
   createdAt = /* @__PURE__ */ new Date();
   voiceMode = "off";
-  dangerousMode = false;
-  currentMode;
-  availableModes = [];
   configOptions = [];
-  currentModel;
-  availableModels = [];
+  clientOverrides = {};
   agentCapabilities;
   archiving = false;
   promptCount = 0;
@@ -4245,34 +4225,28 @@ ${result.text}` : result.text;
     }
   }
   // --- ACP Mode / Config / Model State ---
-  setInitialAcpState(state) {
-    if (state.modes) {
-      this.currentMode = state.modes.currentModeId;
-      this.availableModes = state.modes.availableModes;
-    }
-    if (state.configOptions) {
-      this.configOptions = state.configOptions;
-    }
-    if (state.models) {
-      this.currentModel = state.models.currentModelId;
-      this.availableModels = state.models.availableModels;
-    }
-    if (state.agentCapabilities) {
-      this.agentCapabilities = state.agentCapabilities;
-    }
+  setInitialConfigOptions(options) {
+    this.configOptions = options ?? [];
+  }
+  setAgentCapabilities(caps) {
+    this.agentCapabilities = caps;
+  }
+  getConfigOption(id) {
+    return this.configOptions.find((o) => o.id === id);
+  }
+  getConfigByCategory(category) {
+    return this.configOptions.find((o) => o.category === category);
+  }
+  getConfigValue(id) {
+    const option = this.getConfigOption(id);
+    if (!option) return void 0;
+    return String(option.currentValue);
   }
   /** Set session name explicitly and emit 'named' event */
   setName(name) {
     this.name = name;
     this.emit("named", name);
   }
-  async updateMode(modeId) {
-    if (this.middlewareChain) {
-      const result = await this.middlewareChain.execute("mode:beforeChange", { sessionId: this.id, fromMode: this.currentMode, toMode: modeId }, async (p) => p);
-      if (!result) return;
-    }
-    this.currentMode = modeId;
-  }
   async updateConfigOptions(options) {
     if (this.middlewareChain) {
       const result = await this.middlewareChain.execute("config:beforeChange", { sessionId: this.id, configId: "options", oldValue: this.configOptions, newValue: options }, async (p) => p);
@@ -4280,21 +4254,10 @@ ${result.text}` : result.text;
     }
     this.configOptions = options;
   }
-  async updateModel(modelId) {
-    if (this.middlewareChain) {
-      const result = await this.middlewareChain.execute("model:beforeChange", { sessionId: this.id, fromModel: this.currentModel, toModel: modelId }, async (p) => p);
-      if (!result) return;
-    }
-    this.currentModel = modelId;
-  }
   /** Snapshot of current ACP state for persistence */
   toAcpStateSnapshot() {
     return {
-      currentMode: this.currentMode,
-      availableModes: this.availableModes.length > 0 ? this.availableModes : void 0,
       configOptions: this.configOptions.length > 0 ? this.configOptions : void 0,
-      currentModel: this.currentModel,
-      availableModels: this.availableModels.length > 0 ? this.availableModels : void 0,
       agentCapabilities: this.agentCapabilities
     };
   }
@@ -4344,10 +4307,6 @@ ${result.text}` : result.text;
     this.agentSessionId = newAgent.sessionId;
     this.promptCount = 0;
     this.agentCapabilities = void 0;
-    this.currentMode = void 0;
-    this.availableModes = [];
-    this.currentModel = void 0;
-    this.availableModels = [];
     this.configOptions = [];
     this.log.info({ from: this.agentSwitchHistory.at(-1).agentName, to: agentName }, "Agent switched");
   }
@@ -4608,24 +4567,12 @@ var MessageTransformer = class {
           text: `Session updated: ${event.title ?? ""}`.trim(),
           metadata: { title: event.title, updatedAt: event.updatedAt }
         };
-      case "current_mode_update":
-        return {
-          type: "mode_change",
-          text: `Mode: ${event.modeId}`,
-          metadata: { modeId: event.modeId }
-        };
       case "config_option_update":
         return {
           type: "config_update",
           text: "Config updated",
           metadata: { options: event.options }
         };
-      case "model_update":
-        return {
-          type: "model_update",
-          text: `Model: ${event.modelId}`,
-          metadata: { modelId: event.modelId }
-        };
       case "user_message_chunk":
         return {
           type: "user_replay",
@@ -4774,7 +4721,7 @@ var SessionManager = class {
         createdAt: session.createdAt.toISOString(),
         lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
         name: session.name,
-        dangerousMode: false,
+        clientOverrides: {},
         platform: {}
       });
     }
@@ -4906,6 +4853,15 @@ var SessionManager = class {
 
 // src/core/sessions/session-bridge.ts
 init_log();
+
+// src/core/utils/bypass-detection.ts
+var BYPASS_KEYWORDS = ["bypass", "dangerous", "skip", "dontask", "dont_ask", "auto_accept"];
+function isPermissionBypass(value) {
+  const lower = value.toLowerCase();
+  return BYPASS_KEYWORDS.some((kw) => lower.includes(kw));
+}
+
+// src/core/sessions/session-bridge.ts
 var log6 = createChildLogger({ module: "session-bridge" });
 var SessionBridge = class {
   constructor(session, adapter, deps) {
@@ -5111,24 +5067,12 @@ var SessionBridge = class {
         outgoing = this.deps.messageTransformer.transform(event);
         this.sendMessage(this.session.id, outgoing);
         break;
-      case "current_mode_update":
-        this.session.updateMode(event.modeId);
-        this.persistAcpState();
-        outgoing = this.deps.messageTransformer.transform(event);
-        this.sendMessage(this.session.id, outgoing);
-        break;
       case "config_option_update":
         this.session.updateConfigOptions(event.options);
         this.persistAcpState();
         outgoing = this.deps.messageTransformer.transform(event);
         this.sendMessage(this.session.id, outgoing);
         break;
-      case "model_update":
-        this.session.updateModel(event.modelId);
-        this.persistAcpState();
-        outgoing = this.deps.messageTransformer.transform(event);
-        this.sendMessage(this.session.id, outgoing);
-        break;
       case "user_message_chunk":
         outgoing = this.deps.messageTransformer.transform(event);
         this.sendMessage(this.session.id, outgoing);
@@ -5148,7 +5092,7 @@ var SessionBridge = class {
     });
     return outgoing;
   }
-  /** Persist current ACP state (mode, config, model) to session store as cache */
+  /** Persist current ACP state (configOptions, agentCapabilities) to session store as cache */
   persistAcpState() {
     this.deps.sessionManager.patchRecord(this.session.id, {
       acpState: this.session.toAcpStateSnapshot()
@@ -5203,12 +5147,17 @@ var SessionBridge = class {
           return allowOption.id;
         }
       }
-      if (this.session.dangerousMode) {
+      const modeOption = this.session.getConfigByCategory("mode");
+      const isAgentBypass = modeOption && isPermissionBypass(
+        typeof modeOption.currentValue === "string" ? modeOption.currentValue : ""
+      );
+      const isClientBypass = this.session.clientOverrides.bypassPermissions;
+      if (isAgentBypass || isClientBypass) {
         const allowOption = permReq.options.find((o) => o.isAllow);
         if (allowOption) {
           log6.info(
-            { sessionId: this.session.id, requestId: permReq.id, optionId: allowOption.id },
-            "Dangerous mode: auto-approving permission"
+            { sessionId: this.session.id, requestId: permReq.id, optionId: allowOption.id, agentBypass: !!isAgentBypass, clientBypass: !!isClientBypass },
+            "Bypass mode: auto-approving permission"
           );
           if (mw) {
             mw.execute("permission:afterResolve", {
@@ -5406,16 +5355,14 @@ var SessionFactory = class {
     }
     const resp = agentInstance.initialSessionResponse;
     if (resp) {
-      session.setInitialAcpState({
-        modes: resp.modes ?? null,
-        configOptions: resp.configOptions ?? null,
-        models: resp.models ?? null,
-        agentCapabilities: agentInstance.agentCapabilities ?? null
-      });
+      if (resp.configOptions) {
+        session.setInitialConfigOptions(resp.configOptions);
+      }
+      if (agentInstance.agentCapabilities) {
+        session.setAgentCapabilities(agentInstance.agentCapabilities);
+      }
     } else if (agentInstance.agentCapabilities) {
-      session.setInitialAcpState({
-        agentCapabilities: agentInstance.agentCapabilities
-      });
+      session.setAgentCapabilities(agentInstance.agentCapabilities);
     }
     this.sessionManager.registerSession(session);
     this.eventBus.emit("session:created", {
@@ -5465,18 +5412,21 @@ var SessionFactory = class {
           threadId
         });
         session.activate();
-        session.dangerousMode = record.dangerousMode ?? false;
+        if (record.clientOverrides) {
+          session.clientOverrides = record.clientOverrides;
+        } else if (record.dangerousMode) {
+          session.clientOverrides = { bypassPermissions: true };
+        }
         if (record.firstAgent) session.firstAgent = record.firstAgent;
         if (record.agentSwitchHistory) session.agentSwitchHistory = record.agentSwitchHistory;
         if (record.currentPromptCount != null) session.promptCount = record.currentPromptCount;
         if (record.acpState) {
-          const s = record.acpState;
-          session.setInitialAcpState({
-            modes: s.currentMode && s.availableModes ? { currentModeId: s.currentMode, availableModes: s.availableModes } : null,
-            configOptions: s.configOptions ?? null,
-            models: s.currentModel && s.availableModels ? { currentModelId: s.currentModel, availableModels: s.availableModels } : null,
-            agentCapabilities: s.agentCapabilities ?? null
-          });
+          if (record.acpState.configOptions) {
+            session.setInitialConfigOptions(record.acpState.configOptions);
+          }
+          if (record.acpState.agentCapabilities) {
+            session.setAgentCapabilities(record.acpState.agentCapabilities);
+          }
         }
         log7.info({ sessionId: session.id, threadId }, "Lazy resume successful");
         return session;
@@ -7111,6 +7061,7 @@ var LifecycleManager = class {
       } catch (err) {
         this._failed.add(plugin.name);
         ctx.cleanup();
+        console.error(`[lifecycle] Plugin ${plugin.name} setup() FAILED:`, err);
         this.getPluginLogger(plugin.name).error(`setup() failed: ${err}`);
         this.eventBus?.emit("plugin:failed", { name: plugin.name, error: String(err) });
       }
@@ -7384,6 +7335,13 @@ var OpenACPCore = class {
         { channelId: message.channelId, threadId: message.threadId },
         "No session found for thread (in-memory miss + lazy resume returned null)"
       );
+      const adapter = this.adapters.get(message.channelId);
+      if (adapter) {
+        await adapter.sendMessage(message.threadId, {
+          type: "error",
+          text: "\u26A0\uFE0F No active session in this topic. Use /new to start one."
+        });
+      }
       return;
     }
     this.sessionManager.patchRecord(session.id, {
@@ -11128,8 +11086,12 @@ var SendQueue = class {
       const result = await item.fn();
       item.resolve(result);
     } catch (err) {
-      this.config.onError?.(err instanceof Error ? err : new Error(String(err)));
-      item.reject(err);
+      if (err instanceof Error && "description" in err && typeof err.description === "string" && err.description.includes("message is not modified")) {
+        item.resolve(void 0);
+      } else {
+        this.config.onError?.(err instanceof Error ? err : new Error(String(err)));
+        item.reject(err);
+      }
     } finally {
       const now = Date.now();
       this.lastExec = now;
@@ -12385,14 +12347,15 @@ function setupDangerousModeCallbacks(bot, core) {
     const sessionId = ctx.callbackQuery.data.slice(2);
     const session = core.sessionManager.getSession(sessionId);
     if (session) {
-      session.dangerousMode = !session.dangerousMode;
+      const newDangerousMode2 = !session.clientOverrides.bypassPermissions;
+      session.clientOverrides.bypassPermissions = newDangerousMode2;
       log18.info(
-        { sessionId, dangerousMode: session.dangerousMode },
+        { sessionId, dangerousMode: newDangerousMode2 },
         "Dangerous mode toggled via button"
       );
-      core.sessionManager.patchRecord(sessionId, { dangerousMode: session.dangerousMode }).catch(() => {
+      core.sessionManager.patchRecord(sessionId, { clientOverrides: session.clientOverrides }).catch(() => {
       });
-      const toastText2 = session.dangerousMode ? "\u2620\uFE0F Dangerous mode enabled \u2014 permissions auto-approved" : "\u{1F510} Dangerous mode disabled \u2014 permissions shown normally";
+      const toastText2 = newDangerousMode2 ? "\u2620\uFE0F Dangerous mode enabled \u2014 permissions auto-approved" : "\u{1F510} Dangerous mode disabled \u2014 permissions shown normally";
       try {
         await ctx.answerCallbackQuery({ text: toastText2 });
       } catch {
@@ -12401,7 +12364,7 @@ function setupDangerousModeCallbacks(bot, core) {
         await ctx.editMessageReplyMarkup({
           reply_markup: buildSessionControlKeyboard(
             sessionId,
-            session.dangerousMode,
+            newDangerousMode2,
             session.voiceMode === "on"
           )
         });
@@ -12419,8 +12382,8 @@ function setupDangerousModeCallbacks(bot, core) {
       }
       return;
     }
-    const newDangerousMode = !(record.dangerousMode ?? false);
-    core.sessionManager.patchRecord(sessionId, { dangerousMode: newDangerousMode }).catch(() => {
+    const newDangerousMode = !(record.clientOverrides?.bypassPermissions ?? record.dangerousMode ?? false);
+    core.sessionManager.patchRecord(sessionId, { clientOverrides: { bypassPermissions: newDangerousMode } }).catch(() => {
     });
     log18.info(
       { sessionId, dangerousMode: newDangerousMode },
@@ -12451,19 +12414,19 @@ async function handleEnableDangerous(ctx, core) {
     });
     return;
   }
-  const session = core.sessionManager.getSessionByThread(
+  const session = await core.getOrResumeSession(
     "telegram",
     String(threadId)
   );
   if (session) {
-    if (session.dangerousMode) {
+    if (session.clientOverrides.bypassPermissions) {
       await ctx.reply("\u2620\uFE0F Dangerous mode is already enabled.", {
         parse_mode: "HTML"
       });
       return;
     }
-    session.dangerousMode = true;
-    core.sessionManager.patchRecord(session.id, { dangerousMode: true }).catch(() => {
+    session.clientOverrides.bypassPermissions = true;
+    core.sessionManager.patchRecord(session.id, { clientOverrides: session.clientOverrides }).catch(() => {
     });
   } else {
     const record = core.sessionManager.getRecordByThread(
@@ -12476,13 +12439,13 @@ async function handleEnableDangerous(ctx, core) {
       });
       return;
     }
-    if (record.dangerousMode) {
+    if (record.clientOverrides?.bypassPermissions ?? record.dangerousMode) {
       await ctx.reply("\u2620\uFE0F Dangerous mode is already enabled.", {
         parse_mode: "HTML"
       });
       return;
     }
-    core.sessionManager.patchRecord(record.sessionId, { dangerousMode: true }).catch(() => {
+    core.sessionManager.patchRecord(record.sessionId, { clientOverrides: { bypassPermissions: true } }).catch(() => {
     });
   }
   await ctx.reply(
@@ -12502,19 +12465,19 @@ async function handleDisableDangerous(ctx, core) {
     });
     return;
   }
-  const session = core.sessionManager.getSessionByThread(
+  const session = await core.getOrResumeSession(
     "telegram",
     String(threadId)
   );
   if (session) {
-    if (!session.dangerousMode) {
+    if (!session.clientOverrides.bypassPermissions) {
       await ctx.reply("\u{1F510} Dangerous mode is already disabled.", {
         parse_mode: "HTML"
       });
       return;
     }
-    session.dangerousMode = false;
-    core.sessionManager.patchRecord(session.id, { dangerousMode: false }).catch(() => {
+    session.clientOverrides.bypassPermissions = false;
+    core.sessionManager.patchRecord(session.id, { clientOverrides: session.clientOverrides }).catch(() => {
     });
   } else {
     const record = core.sessionManager.getRecordByThread(
@@ -12527,13 +12490,13 @@ async function handleDisableDangerous(ctx, core) {
       });
       return;
     }
-    if (!record.dangerousMode) {
+    if (!(record.clientOverrides?.bypassPermissions ?? record.dangerousMode)) {
       await ctx.reply("\u{1F510} Dangerous mode is already disabled.", {
         parse_mode: "HTML"
       });
       return;
     }
-    core.sessionManager.patchRecord(record.sessionId, { dangerousMode: false }).catch(() => {
+    core.sessionManager.patchRecord(record.sessionId, { clientOverrides: { bypassPermissions: false } }).catch(() => {
     });
   }
   await ctx.reply(
@@ -12583,7 +12546,7 @@ function setupTTSCallbacks(bot, core) {
       await ctx.editMessageReplyMarkup({
         reply_markup: buildSessionControlKeyboard(
           sessionId,
-          session.dangerousMode,
+          session.clientOverrides.bypassPermissions ?? false,
           newMode === "on"
         )
       });
@@ -12652,7 +12615,7 @@ async function handleOutputMode(ctx, core) {
       await ctx.reply("\u26A0\uFE0F This command must be used in a session topic.", { parse_mode: "HTML" });
       return;
     }
-    const session = core.sessionManager.getSessionByThread(
+    const session = await core.getOrResumeSession(
       "telegram",
       String(threadId)
     );
@@ -12949,7 +12912,7 @@ async function handleNewChat(ctx, core, chatId) {
     );
     return;
   }
-  const currentSession = core.sessionManager.getSessionByThread(
+  const currentSession = await core.getOrResumeSession(
     "telegram",
     String(threadId)
   );
@@ -13218,7 +13181,7 @@ async function handleCancel(ctx, core, assistant) {
 async function handleStatus(ctx, core) {
   const threadId = ctx.message?.message_thread_id;
   if (threadId) {
-    const session = core.sessionManager.getSessionByThread(
+    const session = await core.getOrResumeSession(
       "telegram",
       String(threadId)
     );
@@ -15714,6 +15677,7 @@ var MessageDraft = class {
   flushTimer;
   flushPromise = Promise.resolve();
   lastSentBuffer = "";
+  lastSentHtml = "";
   displayTruncated = false;
   tracer;
   append(text3) {
@@ -15773,6 +15737,8 @@ var MessageDraft = class {
         this.firstFlushPending = false;
       }
     } else {
+      if (html === this.lastSentHtml) return;
+      this.lastSentHtml = html;
       try {
         const result = await this.sendQueue.enqueue(
           () => this.bot.api.editMessageText(this.chatId, this.messageId, html, {
@@ -16340,10 +16306,10 @@ var TelegramAdapter = class extends MessagingAdapter {
       const chatId = ctx.chat.id;
       const topicId = ctx.message.message_thread_id;
       try {
-        const sessionId = topicId != null ? this.core.sessionManager.getSessionByThread(
+        const sessionId = topicId != null ? (await this.core.getOrResumeSession(
           "telegram",
           String(topicId)
-        )?.id ?? null : null;
+        ))?.id ?? null : null;
         const response = await registry.execute(text3, {
           raw: "",
           sessionId,
@@ -16379,10 +16345,10 @@ var TelegramAdapter = class extends MessagingAdapter {
       const chatId = ctx.chat.id;
       const topicId = ctx.callbackQuery.message?.message_thread_id;
       try {
-        const sessionId = topicId != null ? this.core.sessionManager.getSessionByThread(
+        const sessionId = topicId != null ? (await this.core.getOrResumeSession(
           "telegram",
           String(topicId)
-        )?.id ?? null : null;
+        ))?.id ?? null : null;
         const response = await registry.execute(command, {
           raw: "",
           sessionId,
@@ -16464,7 +16430,7 @@ var TelegramAdapter = class extends MessagingAdapter {
         });
         return;
       }
-      const session = this.core.sessionManager.getSessionByThread(
+      const session = await this.core.getOrResumeSession(
         "telegram",
         String(threadId)
       );
@@ -16736,10 +16702,10 @@ ${lines.join("\n")}`;
         );
         return;
       }
-      const sessionId = this.core.sessionManager.getSessionByThread(
+      const sessionId = (await this.core.getOrResumeSession(
         "telegram",
         String(threadId)
-      )?.id;
+      ))?.id;
       if (sessionId) {
         this.getTracer(sessionId)?.log("telegram", { action: "incoming:message", sessionId, userId: String(ctx.from?.id), text: ctx.message?.text });
         await this.draftManager.finalize(sessionId, this.assistantSession?.id);
@@ -17227,11 +17193,11 @@ Task completed.
     if (!threadId) return;
     await this.skillManager.send(sessionId, threadId, commands);
   }
-  resolveSessionId(threadId) {
-    return this.core.sessionManager.getSessionByThread(
+  async resolveSessionId(threadId) {
+    return (await this.core.getOrResumeSession(
       "telegram",
       String(threadId)
-    )?.id;
+    ))?.id;
   }
   async downloadTelegramFile(fileId) {
     try {
@@ -17252,7 +17218,7 @@ Task completed.
     if (!downloaded) return;
     let buffer = downloaded.buffer;
     let originalFilePath;
-    const sessionId = this.resolveSessionId(threadId) || "unknown";
+    const sessionId = await this.resolveSessionId(threadId) || "unknown";
     if (convertOggToWav) {
       const oggAtt = await this.fileService.saveFile(
         sessionId,
@@ -17287,7 +17253,7 @@ Task completed.
       }
       return;
     }
-    const sid = this.resolveSessionId(threadId);
+    const sid = await this.resolveSessionId(threadId);
     if (sid) await this.draftManager.finalize(sid, this.assistantSession?.id);
     this.core.handleMessage({
       channelId: "telegram",