@openacp/cli 0.4.2 → 0.4.4

package/dist/{chunk-WXPN5UOT.js → chunk-VRXFGWZJ.js}

@@ -876,6 +876,13 @@ var SessionManager = class {
       await this.store.save({ ...record, status });
     }
   }
+  async updateSessionDangerousMode(sessionId, dangerousMode) {
+    if (!this.store) return;
+    const record = this.store.get(sessionId);
+    if (record) {
+      await this.store.save({ ...record, dangerousMode });
+    }
+  }
   async updateSessionName(sessionId, name) {
     if (!this.store) return;
     const record = this.store.get(sessionId);
@@ -1436,6 +1443,7 @@ var OpenACPCore = class {
         session.agentSessionId = agentInstance.sessionId;
         session.status = "active";
         session.name = record.name;
+        session.dangerousMode = record.dangerousMode ?? false;
         this.sessionManager.registerSession(session);
         const adapter = this.adapters.get(message.channelId);
         if (adapter) {
@@ -2040,7 +2048,6 @@ function buildDeepLink(chatId, messageId) {
 
 // src/adapters/telegram/commands.ts
 import { InlineKeyboard } from "grammy";
-import { nanoid as nanoid2 } from "nanoid";
 var log7 = createChildLogger({ module: "telegram-commands" });
 function setupCommands(bot, core, chatId, assistant) {
   bot.command("new", (ctx) => handleNew(ctx, core, chatId, assistant));
@@ -2199,6 +2206,11 @@ async function handleNewChat(ctx, core, chatId) {
       chatId,
       topicName
     );
+    const topicLink = buildDeepLink(chatId, newThreadId);
+    await ctx.reply(
+      `\u2705 New chat created \u2192 <a href="${topicLink}">Open topic</a>`,
+      { parse_mode: "HTML" }
+    );
     await ctx.api.sendMessage(chatId, `\u23F3 Setting up session, please wait...`, {
       message_thread_id: newThreadId,
       parse_mode: "HTML"
@@ -2351,23 +2363,44 @@ function setupDangerousModeCallbacks(bot, core) {
   bot.callbackQuery(/^d:/, async (ctx) => {
     const sessionId = ctx.callbackQuery.data.slice(2);
     const session = core.sessionManager.getSession(sessionId);
-    if (!session) {
+    if (session) {
+      session.dangerousMode = !session.dangerousMode;
+      log7.info({ sessionId, dangerousMode: session.dangerousMode }, "Dangerous mode toggled via button");
+      core.sessionManager.updateSessionDangerousMode(sessionId, session.dangerousMode).catch(() => {
+      });
+      const toastText2 = session.dangerousMode ? "\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 {
+      }
+      try {
+        await ctx.editMessageReplyMarkup({
+          reply_markup: buildDangerousModeKeyboard(sessionId, session.dangerousMode)
+        });
+      } catch {
+      }
+      return;
+    }
+    const record = core.sessionManager.getSessionRecord(sessionId);
+    if (!record || record.status === "cancelled" || record.status === "error") {
       try {
         await ctx.answerCallbackQuery({ text: "\u26A0\uFE0F Session not found or already ended." });
       } catch {
       }
       return;
     }
-    session.dangerousMode = !session.dangerousMode;
-    log7.info({ sessionId, dangerousMode: session.dangerousMode }, "Dangerous mode toggled via button");
-    const toastText = session.dangerousMode ? "\u2620\uFE0F Dangerous mode enabled \u2014 permissions auto-approved" : "\u{1F510} Dangerous mode disabled \u2014 permissions shown normally";
+    const newDangerousMode = !(record.dangerousMode ?? false);
+    core.sessionManager.updateSessionDangerousMode(sessionId, newDangerousMode).catch(() => {
+    });
+    log7.info({ sessionId, dangerousMode: newDangerousMode }, "Dangerous mode toggled via button (store-only, session not in memory)");
+    const toastText = newDangerousMode ? "\u2620\uFE0F Dangerous mode enabled \u2014 permissions auto-approved" : "\u{1F510} Dangerous mode disabled \u2014 permissions shown normally";
     try {
       await ctx.answerCallbackQuery({ text: toastText });
     } catch {
     }
     try {
       await ctx.editMessageReplyMarkup({
-        reply_markup: buildDangerousModeKeyboard(sessionId, session.dangerousMode)
+        reply_markup: buildDangerousModeKeyboard(sessionId, newDangerousMode)
       });
     } catch {
     }
@@ -2380,15 +2413,27 @@ async function handleEnableDangerous(ctx, core) {
     return;
   }
   const session = core.sessionManager.getSessionByThread("telegram", String(threadId));
-  if (!session) {
-    await ctx.reply("\u26A0\uFE0F No active session in this topic.", { parse_mode: "HTML" });
-    return;
-  }
-  if (session.dangerousMode) {
-    await ctx.reply("\u2620\uFE0F Dangerous mode is already enabled.", { parse_mode: "HTML" });
-    return;
+  if (session) {
+    if (session.dangerousMode) {
+      await ctx.reply("\u2620\uFE0F Dangerous mode is already enabled.", { parse_mode: "HTML" });
+      return;
+    }
+    session.dangerousMode = true;
+    core.sessionManager.updateSessionDangerousMode(session.id, true).catch(() => {
+    });
+  } else {
+    const record = core.sessionManager.getRecordByThread("telegram", String(threadId));
+    if (!record || record.status === "cancelled" || record.status === "error") {
+      await ctx.reply("\u26A0\uFE0F No active session in this topic.", { parse_mode: "HTML" });
+      return;
+    }
+    if (record.dangerousMode) {
+      await ctx.reply("\u2620\uFE0F Dangerous mode is already enabled.", { parse_mode: "HTML" });
+      return;
+    }
+    core.sessionManager.updateSessionDangerousMode(record.sessionId, true).catch(() => {
+    });
   }
-  session.dangerousMode = true;
   await ctx.reply(
     `\u26A0\uFE0F <b>Dangerous mode enabled</b>
 
@@ -2451,55 +2496,50 @@ async function handleDisableDangerous(ctx, core) {
     return;
   }
   const session = core.sessionManager.getSessionByThread("telegram", String(threadId));
-  if (!session) {
-    await ctx.reply("\u26A0\uFE0F No active session in this topic.", { parse_mode: "HTML" });
-    return;
-  }
-  if (!session.dangerousMode) {
-    await ctx.reply("\u{1F510} Dangerous mode is already disabled.", { parse_mode: "HTML" });
-    return;
+  if (session) {
+    if (!session.dangerousMode) {
+      await ctx.reply("\u{1F510} Dangerous mode is already disabled.", { parse_mode: "HTML" });
+      return;
+    }
+    session.dangerousMode = false;
+    core.sessionManager.updateSessionDangerousMode(session.id, false).catch(() => {
+    });
+  } else {
+    const record = core.sessionManager.getRecordByThread("telegram", String(threadId));
+    if (!record || record.status === "cancelled" || record.status === "error") {
+      await ctx.reply("\u26A0\uFE0F No active session in this topic.", { parse_mode: "HTML" });
+      return;
+    }
+    if (!record.dangerousMode) {
+      await ctx.reply("\u{1F510} Dangerous mode is already disabled.", { parse_mode: "HTML" });
+      return;
+    }
+    core.sessionManager.updateSessionDangerousMode(record.sessionId, false).catch(() => {
+    });
   }
-  session.dangerousMode = false;
   await ctx.reply("\u{1F510} <b>Dangerous mode disabled</b>\n\nPermission requests will be shown normally.", { parse_mode: "HTML" });
 }
 function botFromCtx(ctx) {
   return { api: ctx.api };
 }
-var skillCallbackMap = /* @__PURE__ */ new Map();
-function buildSkillKeyboard(sessionId, commands) {
-  const keyboard = new InlineKeyboard();
+var TELEGRAM_MSG_LIMIT = 4096;
+function buildSkillMessages(commands) {
   const sorted = [...commands].sort((a, b) => a.name.localeCompare(b.name));
-  for (let i = 0; i < sorted.length; i++) {
-    const cmd = sorted[i];
-    const key = nanoid2(8);
-    skillCallbackMap.set(key, { sessionId, commandName: cmd.name });
-    keyboard.text(`/${cmd.name}`, `s:${key}`);
-    if (i % 2 === 1 && i < sorted.length - 1) {
-      keyboard.row();
-    }
-  }
-  return keyboard;
-}
-function clearSkillCallbacks(sessionId) {
-  for (const [key, entry] of skillCallbackMap) {
-    if (entry.sessionId === sessionId) {
-      skillCallbackMap.delete(key);
+  const header = "\u{1F6E0} <b>Available Skills</b>\n";
+  const lines = sorted.map((c) => `<code>/${c.name}</code>`);
+  const messages = [];
+  let current = header;
+  for (const line of lines) {
+    const candidate = current + "\n" + line;
+    if (candidate.length > TELEGRAM_MSG_LIMIT) {
+      messages.push(current);
+      current = line;
+    } else {
+      current = candidate;
     }
   }
-}
-function setupSkillCallbacks(bot, core) {
-  bot.callbackQuery(/^s:/, async (ctx) => {
-    try {
-      await ctx.answerCallbackQuery();
-    } catch {
-    }
-    const key = ctx.callbackQuery.data.slice(2);
-    const entry = skillCallbackMap.get(key);
-    if (!entry) return;
-    const session = core.sessionManager.getSession(entry.sessionId);
-    if (!session || session.status !== "active") return;
-    await session.enqueuePrompt(`/${entry.commandName}`);
-  });
+  if (current) messages.push(current);
+  return messages;
 }
 async function executeNewSession(bot, core, chatId, agentName, workspace) {
   const threadId = await createSessionTopic(bot, chatId, "\u{1F504} New Session");
@@ -2553,7 +2593,7 @@ var STATIC_COMMANDS = [
 
 // src/adapters/telegram/permissions.ts
 import { InlineKeyboard as InlineKeyboard2 } from "grammy";
-import { nanoid as nanoid3 } from "nanoid";
+import { nanoid as nanoid2 } from "nanoid";
 var log8 = createChildLogger({ module: "telegram-permissions" });
 var PermissionHandler = class {
   constructor(bot, chatId, getSession, sendNotification) {
@@ -2565,7 +2605,7 @@ var PermissionHandler = class {
   pending = /* @__PURE__ */ new Map();
   async sendPermissionRequest(session, request) {
     const threadId = Number(session.threadId);
-    const callbackKey = nanoid3(8);
+    const callbackKey = nanoid2(8);
     this.pending.set(callbackKey, {
       sessionId: session.id,
       requestId: request.id,
@@ -3034,7 +3074,7 @@ var TelegramSendQueue = class {
 };
 
 // src/adapters/telegram/action-detect.ts
-import { nanoid as nanoid4 } from "nanoid";
+import { nanoid as nanoid3 } from "nanoid";
 import { InlineKeyboard as InlineKeyboard3 } from "grammy";
 var CMD_NEW_RE = /\/new(?:\s+([^\s\u0080-\uFFFF]+)(?:\s+([^\s\u0080-\uFFFF]+))?)?/;
 var CMD_CANCEL_RE = /\/cancel\b/;
@@ -3060,7 +3100,7 @@ function detectAction(text) {
 var ACTION_TTL_MS = 5 * 60 * 1e3;
 var actionMap = /* @__PURE__ */ new Map();
 function storeAction(action) {
-  const id = nanoid4(10);
+  const id = nanoid3(10);
   actionMap.set(id, { action, createdAt: Date.now() });
   for (const [key, entry] of actionMap) {
     if (Date.now() - entry.createdAt > ACTION_TTL_MS) {
@@ -3288,7 +3328,6 @@ var TelegramAdapter = class extends ChannelAdapter {
       (sessionId) => this.core.sessionManager.getSession(sessionId),
       (notification) => this.sendNotification(notification)
     );
-    setupSkillCallbacks(this.bot, this.core);
     setupDangerousModeCallbacks(this.bot, this.core);
     setupActionCallbacks(
       this.bot,
@@ -3693,9 +3732,7 @@ Task completed.
   }
   async sendSkillCommands(sessionId, commands) {
     if (sessionId === this.assistantSession?.id) return;
-    const session = this.core.sessionManager.getSession(
-      sessionId
-    );
+    const session = this.core.sessionManager.getSession(sessionId);
     if (!session) return;
     const threadId = Number(session.threadId);
     if (!threadId) return;
@@ -3710,54 +3747,52 @@ Task completed.
       await this.cleanupSkillCommands(sessionId);
       return;
     }
-    clearSkillCallbacks(sessionId);
-    const keyboard = buildSkillKeyboard(sessionId, commands);
-    const text = "\u{1F6E0} <b>Available commands:</b>";
+    const messages = buildSkillMessages(commands);
     const existingMsgId = this.skillMessages.get(sessionId);
     if (existingMsgId) {
       try {
         await this.bot.api.editMessageText(
           this.telegramConfig.chatId,
           existingMsgId,
-          text,
-          { parse_mode: "HTML", reply_markup: keyboard }
+          messages[0],
+          { parse_mode: "HTML" }
         );
         return;
       } catch {
       }
     }
     try {
-      const msg = await this.sendQueue.enqueue(
-        () => this.bot.api.sendMessage(
-          this.telegramConfig.chatId,
-          text,
-          {
-            message_thread_id: threadId,
-            parse_mode: "HTML",
-            reply_markup: keyboard,
-            disable_notification: true
-          }
-        )
-      );
-      this.skillMessages.set(sessionId, msg.message_id);
+      let firstMsgId;
+      for (const text of messages) {
+        const msg = await this.sendQueue.enqueue(
+          () => this.bot.api.sendMessage(
+            this.telegramConfig.chatId,
+            text,
+            {
+              message_thread_id: threadId,
+              parse_mode: "HTML",
+              disable_notification: true
+            }
+          )
+        );
+        if (!firstMsgId) firstMsgId = msg.message_id;
+      }
+      this.skillMessages.set(sessionId, firstMsgId);
       const record = this.core.sessionManager.getSessionRecord(sessionId);
       if (record) {
         await this.core.sessionManager.updateSessionPlatform(
           sessionId,
-          { ...record.platform, skillMsgId: msg.message_id }
+          { ...record.platform, skillMsgId: firstMsgId }
         );
       }
       await this.bot.api.pinChatMessage(
         this.telegramConfig.chatId,
-        msg.message_id,
-        {
-          disable_notification: true
-        }
+        firstMsgId,
+        { disable_notification: true }
       );
     } catch (err) {
       log11.error({ err, sessionId }, "Failed to send skill commands");
     }
-    await this.updateCommandAutocomplete(session.agentName, commands);
   }
   async cleanupSkillCommands(sessionId) {
     const msgId = this.skillMessages.get(sessionId);
@@ -3773,35 +3808,12 @@ Task completed.
     } catch {
     }
     this.skillMessages.delete(sessionId);
-    clearSkillCallbacks(sessionId);
     const record = this.core.sessionManager.getSessionRecord(sessionId);
     if (record) {
       const { skillMsgId: _removed, ...rest } = record.platform;
       await this.core.sessionManager.updateSessionPlatform(sessionId, rest);
     }
   }
-  async updateCommandAutocomplete(agentName, skillCommands) {
-    const prefix = `[${agentName}] `;
-    const validSkills = skillCommands.map((c) => ({
-      command: c.name.toLowerCase().replace(/[^a-z0-9_]/g, "_").slice(0, 32),
-      description: (prefix + (c.description || c.name).replace(/\n/g, " ")).slice(0, 256)
-    })).filter((c) => c.command.length > 0);
-    const all = [...STATIC_COMMANDS, ...validSkills];
-    try {
-      await this.bot.api.setMyCommands(all, {
-        scope: { type: "chat", chat_id: this.telegramConfig.chatId }
-      });
-      log11.info(
-        { count: all.length, skills: validSkills.length },
-        "Updated command autocomplete"
-      );
-    } catch (err) {
-      log11.error(
-        { err, commands: all },
-        "Failed to update command autocomplete"
-      );
-    }
-  }
   async finalizeDraft(sessionId) {
     const draft = this.sessionDrafts.get(sessionId);
     if (!draft) return;
@@ -3849,4 +3861,4 @@ export {
   ApiServer,
   TelegramAdapter
 };
-//# sourceMappingURL=chunk-WXPN5UOT.js.map
+//# sourceMappingURL=chunk-VRXFGWZJ.js.map