@openacp/cli 2026.331.2 → 2026.331.3

package/dist/cli.js

@@ -3929,7 +3929,7 @@ function initLogger(config) {
         target: "pino-pretty",
         options: {
           colorize: true,
-          translateTime: "HH:mm:ss",
+          translateTime: "SYS:HH:MM:ss",
           ignore: "pid,hostname",
           singleLine: true
         },
@@ -4964,7 +4964,7 @@ var init_tunnel_registry = __esm({
         this.providerOptions = opts.providerOptions ?? {};
         this.registryPath = opts.registryPath ?? path16.join(os9.homedir(), ".openacp", "tunnels.json");
       }
-      async add(port, opts) {
+      async add(port, opts, _autoRetry = true) {
         if (this.entries.has(port)) {
           const existing = this.entries.get(port);
           if (existing.entry.status === "active" || existing.entry.status === "starting") {
@@ -5018,6 +5018,15 @@ var init_tunnel_registry = __esm({
           entry.status = "failed";
           log7.error({ port, err: err.message }, "Tunnel failed to start");
           this.scheduleSave();
+          const live = this.entries.get(port);
+          if (_autoRetry && live && !this.shuttingDown && live.entry.retryCount < MAX_RETRIES) {
+            const delay = BASE_RETRY_DELAY_MS * Math.pow(2, live.entry.retryCount);
+            log7.warn(
+              { port, retry: live.entry.retryCount + 1, maxRetries: MAX_RETRIES, delayMs: delay },
+              "Scheduling retry after initial start failure"
+            );
+            live.retryTimer = setTimeout(() => this.retry(port, opts), delay);
+          }
           throw err;
         });
         this.entries.set(port, { entry, process: provider, spawnPromise, retryTimer: null });
@@ -5034,7 +5043,7 @@ var init_tunnel_registry = __esm({
         if (live.retryTimer) clearTimeout(live.retryTimer);
         this.entries.delete(port);
         try {
-          const entry = await this.add(port, opts);
+          const entry = await this.add(port, opts, false);
           entry.retryCount = retryCount;
         } catch (err) {
           log7.error({ port, err: err.message, retry: retryCount }, "Tunnel retry failed");
@@ -15237,27 +15246,28 @@ var init_adapter = __esm({
           }
           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;
@@ -15505,6 +15515,40 @@ var init_adapter = __esm({
           });
         }
       }
+      /**
+       * 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);
+            log26.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) => {
+          log26.warn({ err }, "Failed to register Telegram commands after retries (non-critical)");
+        });
+      }
       async stop() {
         for (const tracker of this.sessionTrackers.values()) {
           tracker.destroy();
@@ -23097,8 +23141,19 @@ var init_core = __esm({
         this.agentCatalog.refreshRegistryIfStale().catch((err) => {
           log37.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) {
+            log37.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() {