thepopebot 1.2.76-beta.7 → 1.2.76-beta.9

package/api/index.js

@@ -3,7 +3,7 @@ import { createAgentJob } from '../lib/tools/create-agent-job.js';
 import { setWebhook } from '../lib/tools/telegram.js';
 import { getAgentJobStatus, fetchAgentJobLog } from '../lib/tools/github.js';
 import { getTelegramAdapter } from '../lib/channels/index.js';
-import { chat, summarizeAgentJob } from '../lib/ai/index.js';
+import { chat, chatStream, summarizeAgentJob } from '../lib/ai/index.js';
 import { createNotification } from '../lib/db/notifications.js';
 import { loadTriggers } from '../lib/triggers.js';
 import { verifyApiKey } from '../lib/db/api-keys.js';
@@ -211,19 +211,33 @@ async function handleTelegramWebhook(request) {
 /**
  * Process a normalized message through the AI layer with channel UX.
  * Message persistence is handled centrally by the AI layer.
+ *
+ * Uses chatStream() for progressive tool-call rendering when the adapter
+ * supports it (Telegram: sends each tool call as a message, reacts on completion).
+ * Falls back to chat() for adapters without streamChatResponse.
  */
 async function processChannelMessage(adapter, normalized) {
   await adapter.acknowledge(normalized.metadata);
   const stopIndicator = adapter.startProcessingIndicator(normalized.metadata);
 
   try {
-    const response = await chat(
-      normalized.threadId,
-      normalized.text,
-      normalized.attachments,
-      { userId: 'telegram', chatTitle: 'Telegram' }
-    );
-    await adapter.sendResponse(normalized.threadId, response, normalized.metadata);
+    if (adapter.streamChatResponse) {
+      const chunks = chatStream(
+        normalized.threadId,
+        normalized.text,
+        normalized.attachments,
+        { userId: 'telegram', chatTitle: 'Telegram' }
+      );
+      await adapter.streamChatResponse(normalized.metadata.chatId, chunks);
+    } else {
+      const response = await chat(
+        normalized.threadId,
+        normalized.text,
+        normalized.attachments,
+        { userId: 'telegram', chatTitle: 'Telegram' }
+      );
+      await adapter.sendResponse(normalized.threadId, response, normalized.metadata);
+    }
   } catch (err) {
     console.error('Failed to process message with AI:', err);
     await adapter

package/lib/ai/index.js

@@ -178,19 +178,19 @@ async function* chatStream(threadId, message, attachments = [], options = {}) {
     const setupArgs = { repo, branch, featureBranch };
 
     if (needsSetup) {
-      yield { type: 'tool-call', toolCallId: setupToolCallId, toolName: 'set_up_workspace', args: setupArgs };
+      yield { type: 'tool-call', toolCallId: setupToolCallId, toolName: 'workspace', args: setupArgs };
     }
 
     try {
-      await ensureWorkspaceRepo({ workspaceDir: repoDir, repo, branch, featureBranch });
+      const setupOutput = await ensureWorkspaceRepo({ workspaceDir: repoDir, repo, branch, featureBranch });
       ensureSkills(repoDir, isCodeMode ? 'code' : 'agent');
       if (needsSetup) {
-        const result = `Workspace ready on ${featureBranch || branch}`;
+        const result = setupOutput || `Workspace ready on ${featureBranch || branch}`;
         yield { type: 'tool-result', toolCallId: setupToolCallId, result };
         persistMessage(threadId, 'assistant', JSON.stringify({
           type: 'tool-invocation',
           toolCallId: setupToolCallId,
-          toolName: 'set_up_workspace',
+          toolName: 'workspace',
           state: 'output-available',
           input: setupArgs,
           output: result,

package/lib/ai/workspace-setup.js

@@ -32,20 +32,24 @@ export async function ensureWorkspaceRepo({ workspaceDir, repo, branch, featureB
   if (ghToken) env.GH_TOKEN = ghToken;
 
   const execOpts = { cwd: workspaceDir, env };
+  const log = [];
 
   // 1. Create workspace directory
   mkdirSync(workspaceDir, { recursive: true });
 
   // 2. Configure git to use GH_TOKEN for GitHub HTTPS URLs (mirrors setup-git.sh)
   if (ghToken) {
-    await run('gh', ['auth', 'setup-git'], execOpts);
+    const out = await run('gh', ['auth', 'setup-git'], execOpts);
+    if (out) log.push(out);
   }
 
   // 3. Clone if not already a git repo
   const hasGit = existsSync(path.join(workspaceDir, '.git'));
   if (!hasGit) {
     if (!repo) throw new Error('ensureWorkspaceRepo: repo is required for initial clone');
-    await run('git', ['clone', '--branch', branch || 'main', `https://github.com/${repo}`, '.'], execOpts);
+    const out = await run('git', ['clone', '--branch', branch || 'main', `https://github.com/${repo}`, '.'], execOpts);
+    log.push(`Cloned ${repo} (branch: ${branch || 'main'})`);
+    if (out) log.push(out);
   }
 
   // 3. Git identity (only if not already configured)
@@ -61,6 +65,7 @@ export async function ensureWorkspaceRepo({ workspaceDir, repo, branch, featureB
         const email = user.email || `${user.id}+${user.login}@users.noreply.github.com`;
         await run('git', ['config', 'user.name', name], execOpts);
         await run('git', ['config', 'user.email', email], execOpts);
+        log.push(`Git identity: ${name} <${email}>`);
       } catch (err) {
         console.error('[workspace-setup] Failed to set git identity:', err.message);
       }
@@ -68,7 +73,7 @@ export async function ensureWorkspaceRepo({ workspaceDir, repo, branch, featureB
   }
 
   // 4. Feature branch checkout
-  if (!featureBranch) return;
+  if (!featureBranch) return log.join('\n');
 
   // Already on the right branch locally?
   try {
@@ -77,8 +82,11 @@ export async function ensureWorkspaceRepo({ workspaceDir, repo, branch, featureB
     const current = await run('git', ['rev-parse', '--abbrev-ref', 'HEAD'], execOpts);
     if (current !== featureBranch) {
       await run('git', ['checkout', featureBranch], execOpts);
+      log.push(`Checked out ${featureBranch}`);
+    } else {
+      log.push(`Already on ${featureBranch}`);
     }
-    return;
+    return log.join('\n');
   } catch {
     // Branch doesn't exist locally — check remote
   }
@@ -88,15 +96,20 @@ export async function ensureWorkspaceRepo({ workspaceDir, repo, branch, featureB
     if (remoteCheck) {
       // Remote branch exists — checkout tracking it
       await run('git', ['checkout', '-B', featureBranch, `origin/${featureBranch}`], execOpts);
+      log.push(`Checked out ${featureBranch} (tracking origin)`);
     } else {
       // Create new branch and push
       await run('git', ['checkout', '-b', featureBranch], execOpts);
-      await run('git', ['push', '-u', 'origin', featureBranch], execOpts);
+      const pushOut = await run('git', ['push', '-u', 'origin', featureBranch], execOpts);
+      log.push(`Created and pushed ${featureBranch}`);
+      if (pushOut) log.push(pushOut);
     }
   } catch (err) {
     console.error('[workspace-setup] Feature branch error:', err.message);
     throw err;
   }
+
+  return log.join('\n');
 }
 
 /**

package/lib/channels/telegram.js

@@ -4,8 +4,10 @@ import {
   downloadFile,
   reactToMessage,
   startTypingIndicator,
+  formatToolCall,
 } from '../tools/telegram.js';
 import { isWhisperEnabled, transcribeAudio } from '../tools/openai.js';
+import { getConfig } from '../config.js';
 
 class TelegramAdapter extends ChannelAdapter {
   constructor(botToken) {
@@ -19,15 +21,18 @@ class TelegramAdapter extends ChannelAdapter {
    * Returns null if the update should be ignored.
    */
   async receive(request) {
-    const { TELEGRAM_WEBHOOK_SECRET, TELEGRAM_CHAT_ID, TELEGRAM_VERIFICATION } = process.env;
+    // Read config from DB (with .env fallback via getConfig)
+    const webhookSecret = getConfig('TELEGRAM_WEBHOOK_SECRET');
+    const allowedChatId = getConfig('TELEGRAM_CHAT_ID');
+    const verificationCode = getConfig('TELEGRAM_VERIFICATION');
 
     // Validate secret token (required)
-    if (!TELEGRAM_WEBHOOK_SECRET) {
+    if (!webhookSecret) {
       console.error('[telegram] TELEGRAM_WEBHOOK_SECRET not configured — rejecting webhook');
       return null;
     }
     const headerSecret = request.headers.get('x-telegram-bot-api-secret-token');
-    if (headerSecret !== TELEGRAM_WEBHOOK_SECRET) {
+    if (headerSecret !== webhookSecret) {
       return null;
     }
 
@@ -40,17 +45,27 @@ class TelegramAdapter extends ChannelAdapter {
     let text = message.text || null;
     const attachments = [];
 
-    // Check for verification code — works even before TELEGRAM_CHAT_ID is set
-    if (TELEGRAM_VERIFICATION && text === TELEGRAM_VERIFICATION) {
+    // Check for verification code — works even before TELEGRAM_CHAT_ID is set.
+    // On match, save the chat ID directly and clear the (one-time) verification code.
+    if (verificationCode && text === verificationCode) {
       await sendMessage(this.botToken, chatId, `Your chat ID:\n<code>${chatId}</code>`);
+      try {
+        const { setConfigValue, deleteConfigValue } = await import('../db/config.js');
+        const { invalidateConfigCache } = await import('../config.js');
+        setConfigValue('TELEGRAM_CHAT_ID', chatId);
+        deleteConfigValue('TELEGRAM_VERIFICATION');
+        invalidateConfigCache();
+      } catch (err) {
+        console.error('[telegram] Failed to persist verified chat ID:', err.message);
+      }
       return null;
     }
 
     // Security: if no TELEGRAM_CHAT_ID configured, ignore all messages
-    if (!TELEGRAM_CHAT_ID) return null;
+    if (!allowedChatId) return null;
 
     // Security: only accept messages from configured chat
-    if (chatId !== TELEGRAM_CHAT_ID) return null;
+    if (chatId !== allowedChatId) return null;
 
     // Voice messages → transcribe to text
     if (message.voice) {
@@ -140,6 +155,62 @@ class TelegramAdapter extends ChannelAdapter {
     await sendMessage(this.botToken, threadId, text);
   }
 
+  /**
+   * Consume a chatStream() async iterable and send progressive messages.
+   * - Text chunks accumulate and flush when a tool-call arrives or stream ends.
+   * - Each tool-call sends immediately as its own message.
+   * - Tool-results react to the tool-call message with ✅ (or ❌ on error).
+   *
+   * @param {string} chatId - Telegram chat ID
+   * @param {AsyncIterable} chunks - chatStream() output
+   */
+  async streamChatResponse(chatId, chunks) {
+    let textBuffer = '';
+    // Map toolCallId → { telegramMessageId, hasCompleteArgs }
+    const toolMessages = new Map();
+
+    for await (const chunk of chunks) {
+      if (chunk.type === 'text') {
+        textBuffer += chunk.text;
+      } else if (chunk.type === 'tool-call') {
+        // Skip the first empty-args emission — wait for complete args
+        if (!chunk.args || Object.keys(chunk.args).length === 0) {
+          continue;
+        }
+
+        // Flush accumulated text before tool call
+        if (textBuffer.trim()) {
+          await sendMessage(this.botToken, chatId, textBuffer.trim());
+          textBuffer = '';
+        }
+
+        // Send tool call as its own message
+        const text = formatToolCall(chunk.toolName, chunk.args);
+        try {
+          const msg = await sendMessage(this.botToken, chatId, text);
+          toolMessages.set(chunk.toolCallId, msg.message_id);
+        } catch (err) {
+          console.error('[telegram] Failed to send tool call:', err.message);
+        }
+      } else if (chunk.type === 'tool-result') {
+        const messageId = toolMessages.get(chunk.toolCallId);
+        if (messageId) {
+          const emoji = chunk.result?.includes?.('error') || chunk.result?.includes?.('Error')
+            ? '👎'
+            : '👍';
+          reactToMessage(this.botToken, chatId, messageId, emoji).catch(() => {});
+          toolMessages.delete(chunk.toolCallId);
+        }
+      }
+      // Skip: meta, result, thinking-*, unknown
+    }
+
+    // Flush remaining text
+    if (textBuffer.trim()) {
+      await sendMessage(this.botToken, chatId, textBuffer.trim());
+    }
+  }
+
   get supportsStreaming() {
     return false;
   }

package/lib/chat/actions.js

@@ -966,6 +966,151 @@ export async function regenerateWebhookSecret(key) {
   }
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Settings — Telegram setup flow
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Get Telegram status: bot info (if token valid), webhook info, chat ID.
+ * Used by the admin UI to render the current state of each setup step.
+ */
+export async function getTelegramStatus() {
+  await requireAuth();
+  try {
+    const { getConfigSecret, getConfigValue } = await import('../db/config.js');
+    const { validateBotToken, getTelegramWebhookInfo } = await import('../tools/telegram.js');
+
+    const botToken = getConfigSecret('TELEGRAM_BOT_TOKEN');
+    const webhookSecret = getConfigSecret('TELEGRAM_WEBHOOK_SECRET');
+    const chatId = getConfigValue('TELEGRAM_CHAT_ID');
+    const verificationCode = getConfigValue('TELEGRAM_VERIFICATION');
+
+    let botInfo = null;
+    let webhookInfo = null;
+    if (botToken) {
+      const v = await validateBotToken(botToken);
+      if (v.valid) botInfo = { username: v.botInfo.username, id: v.botInfo.id };
+      try {
+        const info = await getTelegramWebhookInfo(botToken);
+        if (info.ok) {
+          webhookInfo = {
+            url: info.result.url || null,
+            hasCustomCertificate: info.result.has_custom_certificate,
+            pendingUpdates: info.result.pending_update_count,
+            lastErrorMessage: info.result.last_error_message || null,
+          };
+        }
+      } catch {
+        // ignore — webhook info is best-effort
+      }
+    }
+
+    return {
+      botInfo,
+      botTokenSet: !!botToken,
+      webhookSecretSet: !!webhookSecret,
+      webhookInfo,
+      chatId: chatId || null,
+      pendingVerification: !!verificationCode,
+    };
+  } catch (err) {
+    console.error('Failed to get Telegram status:', err);
+    return { error: 'Failed to load Telegram status' };
+  }
+}
+
+/**
+ * Validate a Telegram bot token without saving it.
+ * Called from the UI as the user pastes a token to show live feedback.
+ */
+export async function validateTelegramToken(token) {
+  await requireAuth();
+  if (!token) return { valid: false, error: 'Token is required' };
+  try {
+    const { validateBotToken } = await import('../tools/telegram.js');
+    const result = await validateBotToken(token);
+    if (result.valid) {
+      return { valid: true, botInfo: { username: result.botInfo.username, id: result.botInfo.id } };
+    }
+    return { valid: false, error: result.error };
+  } catch (err) {
+    return { valid: false, error: err.message };
+  }
+}
+
+/**
+ * Register the Telegram webhook with the currently saved bot token.
+ * Generates a fresh webhook secret, saves it, and calls Telegram's setWebhook.
+ * APP_URL must be configured.
+ */
+export async function registerTelegramWebhook() {
+  const user = await requireAuth();
+  try {
+    const { getConfigSecret, setConfigSecret } = await import('../db/config.js');
+    const { invalidateConfigCache, getConfig } = await import('../config.js');
+    const { setTelegramWebhook, generateWebhookSecret } = await import('../tools/telegram.js');
+
+    const botToken = getConfigSecret('TELEGRAM_BOT_TOKEN');
+    if (!botToken) return { error: 'Bot token must be set first' };
+
+    const appUrl = getConfig('APP_URL');
+    if (!appUrl) return { error: 'APP_URL must be configured first' };
+
+    const webhookUrl = `${appUrl.replace(/\/$/, '')}/api/telegram/webhook`;
+    const secret = generateWebhookSecret();
+    setConfigSecret('TELEGRAM_WEBHOOK_SECRET', secret, user.id);
+    invalidateConfigCache();
+
+    const result = await setTelegramWebhook(botToken, webhookUrl, secret);
+    if (!result.ok) {
+      return { error: result.description || 'Failed to register webhook' };
+    }
+    return { success: true, webhookUrl };
+  } catch (err) {
+    console.error('Failed to register Telegram webhook:', err);
+    return { error: err.message };
+  }
+}
+
+/**
+ * Start verification: generate a code, save it, return it to the UI.
+ * User sends the code to the bot; the webhook handler captures the chat ID,
+ * saves it as TELEGRAM_CHAT_ID, and clears this verification code.
+ * The UI polls getTelegramStatus() to detect completion.
+ */
+export async function startTelegramVerification() {
+  const user = await requireAuth();
+  try {
+    const { setConfigValue } = await import('../db/config.js');
+    const { invalidateConfigCache } = await import('../config.js');
+    const { generateVerificationCode } = await import('../tools/telegram.js');
+
+    const code = generateVerificationCode();
+    setConfigValue('TELEGRAM_VERIFICATION', code, user.id);
+    invalidateConfigCache();
+    return { success: true, code };
+  } catch (err) {
+    console.error('Failed to start Telegram verification:', err);
+    return { error: err.message };
+  }
+}
+
+/**
+ * Cancel pending verification (clear the code).
+ */
+export async function cancelTelegramVerification() {
+  await requireAuth();
+  try {
+    const { deleteConfigValue } = await import('../db/config.js');
+    const { invalidateConfigCache } = await import('../config.js');
+    deleteConfigValue('TELEGRAM_VERIFICATION');
+    invalidateConfigCache();
+    return { success: true };
+  } catch (err) {
+    return { error: err.message };
+  }
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Settings — Chat sub-tab
 // ─────────────────────────────────────────────────────────────────────────────

package/lib/chat/components/code-mode-toggle.js

@@ -200,7 +200,7 @@ function WorkspaceBar({
       repoName && /* @__PURE__ */ jsx("span", { className: "shrink-0 cursor-default hidden md:inline", title: repo, children: repoName }),
       branch && /* @__PURE__ */ jsxs(Fragment, { children: [
         /* @__PURE__ */ jsx("span", { className: "shrink-0 text-muted-foreground/30 hidden md:inline", children: "/" }),
-        /* @__PURE__ */ jsx("div", { className: "shrink-0 max-w-[120px]", children: /* @__PURE__ */ jsx(
+        /* @__PURE__ */ jsx("div", { className: "min-w-0 max-w-[120px] md:max-w-[160px]", children: /* @__PURE__ */ jsx(
           Combobox,
           {
             options: branches.map((b) => ({ value: b.name, label: b.name })),
@@ -218,8 +218,8 @@ function WorkspaceBar({
                 }).finally(() => setLoadingBranches(false));
               }
             },
-            triggerClassName: "font-medium text-foreground hover:text-primary hover:bg-accent transition-colors cursor-pointer truncate text-xs rounded px-1 -mx-1",
-            triggerLabel: /* @__PURE__ */ jsx("span", { className: "truncate", title: branch, children: branch })
+            triggerClassName: "block w-full text-left font-medium text-foreground hover:text-primary hover:bg-accent transition-colors cursor-pointer truncate text-xs rounded px-1 -mx-1",
+            triggerLabel: /* @__PURE__ */ jsx("span", { className: "block truncate", title: branch, children: branch })
           }
         ) })
       ] }),

package/lib/chat/components/code-mode-toggle.jsx

@@ -225,7 +225,7 @@ export function WorkspaceBar({
         {branch && (
           <>
             <span className="shrink-0 text-muted-foreground/30 hidden md:inline">/</span>
-            <div className="shrink-0 max-w-[120px]">
+            <div className="min-w-0 max-w-[120px] md:max-w-[160px]">
               <Combobox
                 options={branches.map((b) => ({ value: b.name, label: b.name }))}
                 value={branch}
@@ -242,8 +242,8 @@ export function WorkspaceBar({
                     }).finally(() => setLoadingBranches(false));
                   }
                 }}
-                triggerClassName="font-medium text-foreground hover:text-primary hover:bg-accent transition-colors cursor-pointer truncate text-xs rounded px-1 -mx-1"
-                triggerLabel={<span className="truncate" title={branch}>{branch}</span>}
+                triggerClassName="block w-full text-left font-medium text-foreground hover:text-primary hover:bg-accent transition-colors cursor-pointer truncate text-xs rounded px-1 -mx-1"
+                triggerLabel={<span className="block truncate" title={branch}>{branch}</span>}
               />
             </div>
           </>

package/lib/chat/components/message.js

@@ -434,7 +434,7 @@ function PreviewMessage({ message, isLoading, onRetry, onEdit }) {
 function ThinkingMessage() {
   return /* @__PURE__ */ jsx("div", { className: "flex gap-4 w-full justify-start", children: /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 px-4 py-3 text-sm text-muted-foreground", children: [
     /* @__PURE__ */ jsx(SpinnerIcon, { size: 14 }),
-    /* @__PURE__ */ jsx("span", { children: "Thinking..." })
+    /* @__PURE__ */ jsx("span", { className: "thinking-shimmer", children: "Waiting..." })
   ] }) });
 }
 export {

package/lib/chat/components/message.jsx

@@ -523,7 +523,7 @@ export function ThinkingMessage() {
     <div className="flex gap-4 w-full justify-start">
       <div className="flex items-center gap-2 px-4 py-3 text-sm text-muted-foreground">
         <SpinnerIcon size={14} />
-        <span>Thinking...</span>
+        <span className="thinking-shimmer">Waiting...</span>
       </div>
     </div>
   );