appback-remoteagent 0.13.0 → 0.13.2

package/dist/bot.js

@@ -1030,12 +1030,11 @@ function sanitizeLoggedTelegramText(text) {
 async function runWithPendingAnimation(botToken, chatId, task) {
     let typingStopped = false;
     let typingTimer;
-    const typingStartedAt = Date.now();
-    const pulseTyping = () => {
+    const pulseTyping = async () => {
         if (typingStopped) {
             return;
         }
-        void sendTelegramChatAction(botToken, chatId, "typing").catch((error) => {
+        await sendTelegramChatAction(botToken, chatId, "typing").catch((error) => {
             if (isTelegramForbiddenError(error)) {
                 console.warn(`[telegram-delivery] chat=${chatId} skipped typing action: ${error instanceof Error ? error.message : String(error)}`);
                 typingStopped = true;
@@ -1043,12 +1042,14 @@ async function runWithPendingAnimation(botToken, chatId, task) {
             }
             console.warn(`[telegram-chat-action] chat=${chatId} failed: ${error instanceof Error ? error.message : String(error)}`);
         });
-        const elapsedMs = Date.now() - typingStartedAt;
-        const nextDelayMs = elapsedMs < 60_000 ? 4_000 : 30_000;
-        typingTimer = setTimeout(pulseTyping, nextDelayMs);
+        typingTimer = setTimeout(() => {
+            void pulseTyping();
+        }, config.telegramTypingIntervalMs);
         typingTimer.unref?.();
     };
-    pulseTyping();
+    await withTimeout(pulseTyping(), 1500).catch((error) => {
+        console.warn(`[telegram-chat-action] chat=${chatId} initial typing action was not confirmed: ${error instanceof Error ? error.message : String(error)}`);
+    });
     try {
         const helpers = {
             reportProgress: async (chunks, parseMode) => {
@@ -1470,6 +1471,23 @@ function formatProviderTimeoutFinalMessage(message) {
 async function sleep(ms) {
     await new Promise((resolve) => setTimeout(resolve, ms));
 }
+async function withTimeout(promise, timeoutMs) {
+    let timer;
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                timer = setTimeout(() => reject(new Error(`Timed out after ${timeoutMs}ms`)), timeoutMs);
+                timer.unref?.();
+            }),
+        ]);
+    }
+    finally {
+        if (timer) {
+            clearTimeout(timer);
+        }
+    }
+}
 async function ensureOwnerControlAccess(ctx) {
     if (ctx.chat?.type !== "private") {
         throw new Error("This command is available only in private 1:1 chats.");

package/dist/config.js

@@ -136,6 +136,7 @@ export const config = {
     telegramPollingMaxConcurrency: readTimeout("TELEGRAM_POLLING_MAX_CONCURRENCY", 3),
     telegramOwnerId: readOptional("TELEGRAM_OWNER_ID"),
     telegramMessageBatchMs: readNonNegativeTimeout("TELEGRAM_MESSAGE_BATCH_MS", 1500),
+    telegramTypingIntervalMs: readTimeout("TELEGRAM_TYPING_INTERVAL_MS", 4_000),
     telegramAutoProgressMaxTurns: readOptionalNonNegativeInteger("TELEGRAM_AUTO_PROGRESS_MAX_TURNS") ?? 6,
     telegramEmptyResponseRetries: readOptionalNonNegativeInteger("TELEGRAM_EMPTY_RESPONSE_RETRIES") ?? 1,
     telegramRetryableErrorRetries: readOptionalNonNegativeInteger("TELEGRAM_RETRYABLE_ERROR_RETRIES") ?? 2,

package/dist/index.js

@@ -60,7 +60,7 @@ async function main() {
             console.error("Local UI failed to start:", error);
         });
     }
-    const botInfos = config.telegramBotTokens.map((token, index) => buildBotInfo(token, index));
+    const botInfos = await Promise.all(config.telegramBotTokens.map((token, index) => resolveBotInfo(token, index)));
     const bots = config.telegramBotTokens.map((token, index) => createBot(token, bridge, botManagement, botInfos[index]));
     if (config.telegramCommandMenuEnabled) {
         for (const bot of bots) {
@@ -416,11 +416,41 @@ class AsyncSemaphore {
         }
     }
 }
-function buildBotInfo(token, index) {
+async function resolveBotInfo(token, index) {
+    try {
+        const { stdout } = await execFileAsync("curl", [
+            "-sS",
+            "-4",
+            "--max-time",
+            "10",
+            `https://api.telegram.org/bot${token}/getMe`,
+        ]);
+        const payload = JSON.parse(stdout);
+        if (payload.ok && payload.result?.id && payload.result.username) {
+            return buildBotInfoFromIdentity(payload.result.id, payload.result.username, payload.result.first_name);
+        }
+        console.warn(`Telegram getMe failed for bot ${tokenIdLabel(token)}: ${payload.description || "missing bot identity"}`);
+    }
+    catch (error) {
+        console.warn(`Telegram getMe failed for bot ${tokenIdLabel(token)}: ${summarizeTelegramIdentityError(error)}`);
+    }
+    return buildFallbackBotInfo(token, index);
+}
+function buildBotInfoFromIdentity(id, username, firstName) {
+    return {
+        id,
+        is_bot: true,
+        first_name: firstName || username,
+        username,
+        can_join_groups: false,
+        can_read_all_group_messages: false,
+        supports_inline_queries: false,
+    };
+}
+function buildFallbackBotInfo(token, index) {
     const id = Number.parseInt(token.split(":", 1)[0] ?? "", 10);
-    const configuredUsername = config.telegramBotUsernames[index];
     const fallbackUsername = knownBotUsername(id);
-    const username = configuredUsername || fallbackUsername || `bot_${Number.isFinite(id) ? id : index + 1}`;
+    const username = fallbackUsername || `bot_${Number.isFinite(id) ? id : index + 1}`;
     return {
         id: Number.isFinite(id) ? id : index + 1,
         is_bot: true,
@@ -431,6 +461,20 @@ function buildBotInfo(token, index) {
         supports_inline_queries: false,
     };
 }
+function tokenIdLabel(token) {
+    return token.split(":", 1)[0] || "unknown";
+}
+function summarizeTelegramIdentityError(error) {
+    if (!(error instanceof Error)) {
+        return String(error);
+    }
+    const code = typeof error === "object" && error !== null && "code" in error
+        ? String(error.code ?? "")
+        : "";
+    return [code, error.message.replace(/bot\d+:[A-Za-z0-9_-]+/g, "bot[redacted]")]
+        .filter(Boolean)
+        .join(" ");
+}
 function knownBotUsername(id) {
     if (id === 8369496408) {
         return "codex_remoteagent_bot";

package/dist/services/bot-management-service.js

@@ -206,8 +206,8 @@ export class BotManagementService {
         const transient = [];
         for (const bot of bots) {
             try {
-                await this.fetchBotIdentity(bot.token);
-                alive.push(bot);
+                const identity = await this.fetchBotIdentity(bot.token);
+                alive.push({ ...identity, index: bot.index });
             }
             catch (error) {
                 const reason = error instanceof Error ? error.message : String(error);
@@ -453,7 +453,8 @@ export class BotManagementService {
             : singleTokenLine
                 ? [singleTokenLine.slice("TELEGRAM_BOT_TOKEN=".length).trim()].filter(Boolean)
                 : [];
-        const usernames = usernameLine ? this.parseCsv(usernameLine.slice("TELEGRAM_BOT_USERNAMES=".length)) : [];
+        const configuredUsernames = usernameLine ? this.parseCsv(usernameLine.slice("TELEGRAM_BOT_USERNAMES=".length)) : [];
+        const usernames = await this.normalizeUsernamesFromTelegram(tokens, configuredUsernames);
         return {
             lines,
             tokens,
@@ -462,7 +463,7 @@ export class BotManagementService {
         };
     }
     async writeEnvConfig(originalLines, tokens, usernames, mainBotId) {
-        const normalizedUsernames = this.normalizeUsernames(tokens, usernames);
+        const normalizedUsernames = await this.normalizeUsernamesFromTelegram(tokens, usernames);
         const normalizedMainBotId = this.resolveMainBotId(this.zipBots(tokens, normalizedUsernames), mainBotId);
         const nextLines = [];
         let hasMulti = false;
@@ -510,7 +511,23 @@ export class BotManagementService {
         await fs.writeFile(this.envPath, output, "utf8");
     }
     normalizeUsernames(tokens, usernames) {
-        return tokens.map((token, index) => usernames[index]?.trim() || `bot_${this.tokenId(token)}`);
+        return tokens.map((token, index) => usernames[index]?.trim() || this.fallbackUsername(token));
+    }
+    async normalizeUsernamesFromTelegram(tokens, usernames) {
+        const normalized = [];
+        for (const token of tokens) {
+            try {
+                const identity = await this.fetchBotIdentity(token);
+                normalized.push(identity.username);
+            }
+            catch {
+                normalized.push(this.fallbackUsername(token));
+            }
+        }
+        return normalized;
+    }
+    fallbackUsername(token) {
+        return `bot_${this.tokenId(token)}`;
     }
     zipBots(tokens, usernames) {
         const normalizedUsernames = this.normalizeUsernames(tokens, usernames);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appback-remoteagent",
-  "version": "0.13.0",
+  "version": "0.13.2",
   "description": "Personal installable session server for continuing local AI work across PC and Telegram",
   "license": "MIT",
   "type": "module",