@openacp/cli 2026.331.2 → 2026.331.4

package/dist/index.d.ts

@@ -1056,7 +1056,7 @@ interface IChannelAdapter {
     createSessionThread(sessionId: string, name: string): Promise<string>;
     renameSessionThread(sessionId: string, newName: string): Promise<void>;
     deleteSessionThread?(sessionId: string): Promise<void>;
-    archiveSessionTopic?(sessionId: string): Promise<string>;
+    archiveSessionTopic?(sessionId: string): Promise<void>;
     stripTTSBlock?(sessionId: string): Promise<void>;
     sendSkillCommands?(sessionId: string, commands: AgentCommand[]): Promise<void>;
     cleanupSkillCommands?(sessionId: string): Promise<void>;
@@ -1084,7 +1084,7 @@ declare abstract class ChannelAdapter<TCore = unknown> implements IChannelAdapte
     sendSkillCommands(_sessionId: string, _commands: AgentCommand[]): Promise<void>;
     cleanupSkillCommands(_sessionId: string): Promise<void>;
     cleanupSessionState(_sessionId: string): Promise<void>;
-    archiveSessionTopic(_sessionId: string): Promise<string>;
+    archiveSessionTopic(_sessionId: string): Promise<void>;
 }
 
 declare function nodeToWebWritable(nodeStream: NodeJS.WritableStream): WritableStream<Uint8Array>;
@@ -2014,6 +2014,14 @@ interface EventBusEvents {
         attachments?: unknown[];
     }) => void;
     "usage:recorded": (data: UsageRecordEvent) => void;
+    "session:agentSwitch": (data: {
+        sessionId: string;
+        fromAgent: string;
+        toAgent: string;
+        status: "starting" | "succeeded" | "failed";
+        resumed?: boolean;
+        error?: string;
+    }) => void;
 }
 declare class EventBus extends TypedEmitter<EventBusEvents> {
 }
@@ -2174,8 +2182,9 @@ declare class SessionFactory {
     private sessionManager;
     private speechServiceAccessor;
     private eventBus;
+    private instanceRoot?;
     middlewareChain?: MiddlewareChain;
-    constructor(agentManager: AgentManager, sessionManager: SessionManager, speechServiceAccessor: SpeechService | (() => SpeechService), eventBus: EventBus);
+    constructor(agentManager: AgentManager, sessionManager: SessionManager, speechServiceAccessor: SpeechService | (() => SpeechService), eventBus: EventBus, instanceRoot?: string | undefined);
     private get speechService();
     create(params: SessionCreateParams): Promise<Session>;
     wireSideEffects(session: Session, deps: SideEffectDeps): void;
@@ -2409,7 +2418,6 @@ declare class OpenACPCore {
     stop(): Promise<void>;
     archiveSession(sessionId: string): Promise<{
         ok: true;
-        newThreadId: string;
     } | {
         ok: false;
         error: string;
@@ -3155,6 +3163,16 @@ declare class TelegramAdapter extends MessagingAdapter {
         assistantTopicId?: number;
     }) => Promise<void>);
     start(): Promise<void>;
+    /**
+     * Retry an async operation with exponential backoff.
+     * Used for Telegram API calls that may fail due to transient network issues.
+     */
+    private retryWithBackoff;
+    /**
+     * Register Telegram commands in the background with retries.
+     * Non-critical — bot works fine without autocomplete commands.
+     */
+    private registerCommandsWithRetry;
     stop(): Promise<void>;
     private renderCommandResponse;
     private toCallbackData;
@@ -3193,7 +3211,7 @@ declare class TelegramAdapter extends MessagingAdapter {
     cleanupSkillCommands(sessionId: string): Promise<void>;
     cleanupSessionState(sessionId: string): Promise<void>;
     stripTTSBlock(sessionId: string): Promise<void>;
-    archiveSessionTopic(sessionId: string): Promise<string>;
+    archiveSessionTopic(sessionId: string): Promise<void>;
 }
 
 export { ActivityTracker, type AdapterCapabilities, type AgentCapabilities, AgentCatalog, type AgentCommand, type AgentDefinition, type AgentDistribution, type AgentEvent, AgentInstance, type AgentListItem, AgentManager, AgentStore, type AgentSwitchEntry, type ApiConfig, ApiServer, type Attachment, type AuthMethod, type AuthenticateRequest, type AvailabilityResult, BaseRenderer, type BridgeDeps, CONFIG_REGISTRY, ChannelAdapter, type ChannelConfig, type CleanupResult, type CommandArgs, type CommandDef, CommandRegistry, type CommandResponse, type Config, type ConfigFieldDef, ConfigManager$1 as ConfigManager, type ConfigOption, type ConfigSelectChoice, type ConfigSelectGroup, type ContentBlock, ContextManager, type ContextOptions, type ContextProvider, type ContextQuery, type ContextResult, type ContextService, type SessionInfo as ContextSessionInfo, type DeleteTopicResult, DisplaySpecBuilder, type DisplayVerbosity, DoctorEngine, type DoctorReport, DraftManager, EntireProvider, EventBus, type EventBusEvents, FileService, type FileServiceInterface, GroqSTT, type IChannelAdapter, type IRenderer, type IncomingMessage, type InstallContext, type InstallProgress, type InstallResult, type InstalledAgent, KIND_ICONS, type ListItem, type Logger$1 as Logger, type LoggingConfig, type McpServerConfig, type MenuOption, MessageTransformer, MessagingAdapter, type MessagingAdapterConfig, type MigrateContext, type ModelInfo, type NewSessionResponse, NotificationManager, type NotificationMessage, type NotificationService, OpenACPCore, type OpenACPPlugin, type OutgoingMessage, type OutputMode, OutputModeResolver, PRODUCT_GUIDE, type PendingFix, PermissionGate, type PermissionOption, type PermissionRequest, type PlanEntry, type PluginContext, type PluginPermission, type PluginStorage, PromptQueue, type PromptResponse, type RegistryAgent, type RegistryBinaryTarget, type RegistryDistribution, type RenderedMessage, SSEManager, STATUS_ICONS, type STTOptions, type STTProvider$1 as STTProvider, type STTResult, SecurityGuard, type SecurityService, SendQueue, Session, SessionBridge, type SessionCreateParams, type SessionEvents, SessionFactory, type SessionListItem, type SessionListResponse, type SessionListResult, SessionManager, type SessionMode, type SessionModeState, type SessionModelState, type SessionRecord, type SessionStatus, type SetConfigOptionValue, type SettingsAPI, type SideEffectDeps, type SpeechProviderConfig, SpeechService, type SpeechServiceConfig, type SpeechServiceInterface, StaticServer, StderrCapture, type StopReason, StreamAdapter, type TTSOptions, type TTSProvider$1 as TTSProvider, type TTSResult, TelegramAdapter, type TelegramPlatformData, type TerminalIO, ThoughtBuffer, type ThoughtDisplaySpec, type ToolCallMeta, ToolCallTracker, type ToolCardSnapshot, ToolCardState, type ToolCardStateConfig, type ToolDisplaySpec, type ToolEntry, ToolStateMap, type ToolUpdateMeta, type TopicInfo, TopicManager, type TunnelServiceInterface, TypedEmitter, type UsageConfig, type UsageRecord, type UsageRecordEvent, type UsageService, type ViewerLinks, cleanupOldSessionLogs, createChildLogger, createSessionLogger, expandHome, extractContentText, formatTokens, formatToolSummary, formatToolTitle, getConfigValue, getFieldDef, getPidPath, getSafeFields, getStatus, initLogger, installAutoStart, isAutoStartInstalled, isAutoStartSupported, isHotReloadable, log, nodeToWebReadable, nodeToWebWritable, progressBar, resolveOptions, resolveToolIcon, runConfigEditor, setLogLevel, shutdownLogger, splitMessage, startDaemon, stopDaemon, stripCodeFences, truncateContent, uninstallAutoStart };

package/dist/index.js

@@ -105,7 +105,7 @@ function initLogger(config) {
         target: "pino-pretty",
         options: {
           colorize: true,
-          translateTime: "HH:mm:ss",
+          translateTime: "SYS:HH:MM:ss",
           ignore: "pid,hostname",
           singleLine: true
         },
@@ -2383,7 +2383,6 @@ var ChannelAdapter = class {
   async cleanupSessionState(_sessionId) {
   }
   async archiveSessionTopic(_sessionId) {
-    return "";
   }
 };
 
@@ -4742,13 +4741,17 @@ var SessionBridge = class {
       }
     };
     this.session.on("status_change", this.statusChangeHandler);
-    this.namedHandler = (name) => {
-      this.deps.sessionManager.patchRecord(this.session.id, { name });
+    this.namedHandler = async (name) => {
+      const record = this.deps.sessionManager.getSessionRecord(this.session.id);
+      const alreadyNamed = !!record?.name;
+      await this.deps.sessionManager.patchRecord(this.session.id, { name });
       this.deps.eventBus?.emit("session:updated", {
         sessionId: this.session.id,
         name
       });
-      this.adapter.renameSessionThread(this.session.id, name);
+      if (!alreadyNamed) {
+        await this.adapter.renameSessionThread(this.session.id, name);
+      }
     };
     this.session.on("named", this.namedHandler);
     this.promptCountHandler = (count) => {
@@ -4762,11 +4765,12 @@ var SessionBridge = class {
 init_log();
 var log7 = createChildLogger({ module: "session-factory" });
 var SessionFactory = class {
-  constructor(agentManager, sessionManager, speechServiceAccessor, eventBus) {
+  constructor(agentManager, sessionManager, speechServiceAccessor, eventBus, instanceRoot) {
     this.agentManager = agentManager;
     this.sessionManager = sessionManager;
     this.speechServiceAccessor = speechServiceAccessor;
     this.eventBus = eventBus;
+    this.instanceRoot = instanceRoot;
   }
   middlewareChain;
   get speechService() {
@@ -4793,14 +4797,73 @@ var SessionFactory = class {
         channelId: result.channelId
       };
     }
-    const agentInstance = createParams.resumeAgentSessionId ? await this.agentManager.resume(
-      createParams.agentName,
-      createParams.workingDirectory,
-      createParams.resumeAgentSessionId
-    ) : await this.agentManager.spawn(
-      createParams.agentName,
-      createParams.workingDirectory
-    );
+    let agentInstance;
+    try {
+      agentInstance = createParams.resumeAgentSessionId ? await this.agentManager.resume(
+        createParams.agentName,
+        createParams.workingDirectory,
+        createParams.resumeAgentSessionId
+      ) : await this.agentManager.spawn(
+        createParams.agentName,
+        createParams.workingDirectory
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const guidanceLines = [
+        `\u274C Failed to start agent "${createParams.agentName}": ${message}`,
+        "",
+        "Run the agent CLI once in a terminal for this OpenACP instance to complete login or setup."
+      ];
+      if (this.instanceRoot) {
+        guidanceLines.push(
+          "",
+          "Copy and run this command in your terminal:",
+          `  cd "${this.instanceRoot}" && openacp agents run ${createParams.agentName}`
+        );
+      } else {
+        guidanceLines.push(
+          "",
+          "Copy and run this command in your terminal (same project where you started OpenACP):",
+          `  openacp agents run ${createParams.agentName}`
+        );
+      }
+      guidanceLines.push(
+        "",
+        "After setup completes, retry creating the session here."
+      );
+      const guidance = {
+        type: "system_message",
+        message: guidanceLines.join("\n")
+      };
+      const failedSession = new Session({
+        id: createParams.existingSessionId,
+        channelId: createParams.channelId,
+        agentName: createParams.agentName,
+        workingDirectory: createParams.workingDirectory,
+        // Dummy agent instance — will never be prompted
+        agentInstance: {
+          sessionId: "",
+          prompt: async () => {
+          },
+          cancel: async () => {
+          },
+          destroy: async () => {
+          },
+          on: () => {
+          },
+          off: () => {
+          }
+        },
+        speechService: this.speechService
+      });
+      this.sessionManager.registerSession(failedSession);
+      failedSession.emit("agent_event", guidance);
+      this.eventBus.emit("agent:event", {
+        sessionId: failedSession.id,
+        event: guidance
+      });
+      throw err;
+    }
     agentInstance.middlewareChain = this.middlewareChain;
     const session = new Session({
       id: createParams.existingSessionId,
@@ -6313,7 +6376,8 @@ var OpenACPCore = class {
       this.agentManager,
       this.sessionManager,
       () => this.speechService,
-      this.eventBus
+      this.eventBus,
+      ctx?.root
     );
     this.lifecycleManager = new LifecycleManager({
       serviceRegistry: new ServiceRegistry(),
@@ -6365,8 +6429,19 @@ var OpenACPCore = class {
     this.agentCatalog.refreshRegistryIfStale().catch((err) => {
       log12.warn({ err }, "Background registry refresh failed");
     });
-    for (const adapter of this.adapters.values()) {
-      await adapter.start();
+    const failures = [];
+    for (const [name, adapter] of this.adapters.entries()) {
+      try {
+        await adapter.start();
+      } catch (err) {
+        log12.error({ err, adapter: name }, `Adapter "${name}" failed to start`);
+        failures.push({ name, error: err });
+      }
+    }
+    if (failures.length > 0 && failures.length === this.adapters.size) {
+      throw new Error(
+        `All adapters failed to start: ${failures.map((f) => f.name).join(", ")}`
+      );
     }
   }
   async stop() {
@@ -6397,20 +6472,9 @@ var OpenACPCore = class {
     if (!adapter) return { ok: false, error: "Adapter not found for session" };
     if (!adapter.archiveSessionTopic) return { ok: false, error: "Adapter does not support topic archiving" };
     try {
-      const newThreadId = await adapter.archiveSessionTopic(session.id);
-      session.threadId = newThreadId;
-      try {
-        const platform2 = {};
-        if (session.channelId === "telegram") {
-          platform2.topicId = Number(newThreadId);
-        } else {
-          platform2.threadId = newThreadId;
-        }
-        await this.sessionManager.patchRecord(sessionId, { platform: platform2 });
-      } catch (patchErr) {
-        log12.warn({ err: patchErr, sessionId }, "Failed to update session record after archive \u2014 session will work but may not survive restart");
-      }
-      return { ok: true, newThreadId };
+      await adapter.archiveSessionTopic(session.id);
+      await this.sessionManager.cancelSession(sessionId);
+      return { ok: true };
     } catch (err) {
       session.archiving = false;
       return { ok: false, error: err.message };
@@ -6717,6 +6781,21 @@ var OpenACPCore = class {
     const caps = getAgentCapabilities(toAgent);
     const canResume = !!(lastEntry && caps.supportsResume && lastEntry.promptCount === 0);
     const resumed = canResume;
+    const startEvent = {
+      type: "system_message",
+      message: `Switching from ${fromAgent} to ${toAgent}...`
+    };
+    session.emit("agent_event", startEvent);
+    this.eventBus.emit("agent:event", {
+      sessionId,
+      event: startEvent
+    });
+    this.eventBus.emit("session:agentSwitch", {
+      sessionId,
+      fromAgent,
+      toAgent,
+      status: "starting"
+    });
     const bridge = this.bridges.get(sessionId);
     if (bridge) bridge.disconnect();
     const switchAdapter = this.adapters.get(session.channelId);
@@ -6751,7 +6830,40 @@ var OpenACPCore = class {
           return instance;
         }
       });
+      const successEvent = {
+        type: "system_message",
+        message: resumed ? `Switched to ${toAgent} (resumed previous session).` : `Switched to ${toAgent} (new session).`
+      };
+      session.emit("agent_event", successEvent);
+      this.eventBus.emit("agent:event", {
+        sessionId,
+        event: successEvent
+      });
+      this.eventBus.emit("session:agentSwitch", {
+        sessionId,
+        fromAgent,
+        toAgent,
+        status: "succeeded",
+        resumed
+      });
     } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      const failedEvent = {
+        type: "system_message",
+        message: `Failed to switch to ${toAgent}: ${errorMessage}`
+      };
+      session.emit("agent_event", failedEvent);
+      this.eventBus.emit("agent:event", {
+        sessionId,
+        event: failedEvent
+      });
+      this.eventBus.emit("session:agentSwitch", {
+        sessionId,
+        fromAgent,
+        toAgent,
+        status: "failed",
+        error: errorMessage
+      });
       try {
         let rollbackInstance;
         try {
@@ -13901,7 +14013,7 @@ async function handleArchive(ctx, core) {
     return;
   }
   await ctx.reply(
-    "\u26A0\uFE0F <b>Archive this session?</b>\n\nThis will:\n\u2022 Delete this topic and recreate it (clearing chat history)\n\u2022 The agent session will keep running\n\n<i>Chat history cannot be recovered.</i>",
+    "\u26A0\uFE0F <b>Archive this session?</b>\n\nThis will:\n\u2022 Stop the agent session\n\u2022 Delete this topic permanently\n\n<i>This cannot be undone.</i>",
     {
       parse_mode: "HTML",
       reply_markup: new InlineKeyboard3().text("\u{1F5D1} Yes, archive", `ar:yes:${identifier}`).text("\u274C Cancel", `ar:no:${identifier}`)
@@ -13922,18 +14034,7 @@ async function handleArchiveConfirm(ctx, core, chatId) {
     return;
   }
   const result = await core.archiveSession(identifier);
-  if (result.ok) {
-    const adapter = core.adapters.get("telegram");
-    if (adapter) {
-      try {
-        await adapter.sendMessage(identifier, {
-          type: "text",
-          text: "Chat history cleared. Session is still active \u2014 send a message to continue."
-        });
-      } catch {
-      }
-    }
-  } else {
+  if (!result.ok) {
     try {
       await ctx.editMessageText(`Failed to archive: <code>${escapeHtml(result.error)}</code>`, { parse_mode: "HTML" });
     } catch {
@@ -16703,27 +16804,28 @@ var TelegramAdapter = class extends MessagingAdapter {
       }
       return prev(method, payload, signal);
     });
-    await this.bot.api.setMyCommands(STATIC_COMMANDS, {
-      scope: { type: "chat", chat_id: this.telegramConfig.chatId }
-    });
+    this.registerCommandsWithRetry();
     this.bot.use((ctx, next) => {
       const chatId = ctx.chat?.id ?? ctx.callbackQuery?.message?.chat?.id;
       if (chatId !== this.telegramConfig.chatId) return;
       return next();
     });
-    const topics = await ensureTopics(
-      this.bot,
-      this.telegramConfig.chatId,
-      this.telegramConfig,
-      async (updates) => {
-        if (this.saveTopicIds) {
-          await this.saveTopicIds(updates);
-        } else {
-          await this.core.configManager.save({
-            channels: { telegram: updates }
-          });
+    const topics = await this.retryWithBackoff(
+      () => ensureTopics(
+        this.bot,
+        this.telegramConfig.chatId,
+        this.telegramConfig,
+        async (updates) => {
+          if (this.saveTopicIds) {
+            await this.saveTopicIds(updates);
+          } else {
+            await this.core.configManager.save({
+              channels: { telegram: updates }
+            });
+          }
         }
-      }
+      ),
+      "ensureTopics"
     );
     this.notificationTopicId = topics.notificationTopicId;
     this.assistantTopicId = topics.assistantTopicId;
@@ -16971,6 +17073,40 @@ var TelegramAdapter = class extends MessagingAdapter {
       });
     }
   }
+  /**
+   * Retry an async operation with exponential backoff.
+   * Used for Telegram API calls that may fail due to transient network issues.
+   */
+  async retryWithBackoff(fn, label, maxRetries = 5, baseDelayMs = 2e3) {
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (err) {
+        if (attempt === maxRetries) throw err;
+        const delay = baseDelayMs * Math.pow(2, attempt - 1);
+        log31.warn(
+          { err, attempt, maxRetries, delayMs: delay, operation: label },
+          `${label} failed, retrying in ${delay}ms`
+        );
+        await new Promise((r) => setTimeout(r, delay));
+      }
+    }
+    throw new Error("unreachable");
+  }
+  /**
+   * Register Telegram commands in the background with retries.
+   * Non-critical — bot works fine without autocomplete commands.
+   */
+  registerCommandsWithRetry() {
+    this.retryWithBackoff(
+      () => this.bot.api.setMyCommands(STATIC_COMMANDS, {
+        scope: { type: "chat", chat_id: this.telegramConfig.chatId }
+      }),
+      "setMyCommands"
+    ).catch((err) => {
+      log31.warn({ err }, "Failed to register Telegram commands after retries (non-critical)");
+    });
+  }
   async stop() {
     for (const tracker of this.sessionTrackers.values()) {
       tracker.destroy();
@@ -17687,10 +17823,6 @@ Task completed.
       this.sessionTrackers.delete(session.id);
     }
     await deleteSessionTopic(this.bot, chatId, oldTopicId);
-    const topicName = session.name ?? `Session ${session.id.slice(0, 6)}`;
-    const newTopicId = await createSessionTopic(this.bot, chatId, topicName);
-    session.archiving = false;
-    return String(newTopicId);
   }
 };
 export {