thepopebot 1.2.76-beta.2 → 1.2.76-beta.21

package/lib/chat/actions.js

@@ -7,7 +7,6 @@ import {
   getChatByWorkspaceId,
   getMessagesByChatId,
   deleteChat as dbDeleteChat,
-  deleteAllChatsByUser,
   updateChatTitle,
   toggleChatStarred,
 } from '../db/chats.js';
@@ -139,15 +138,6 @@ export async function starChat(chatId) {
   return { success: true, starred };
 }
 
-/**
- * Delete all chats for the authenticated user.
- * @returns {Promise<{success: boolean}>}
- */
-export async function deleteAllChats() {
-  const user = await requireAuth();
-  deleteAllChatsByUser(user.id);
-  return { success: true };
-}
 
 /**
  * Get notifications, newest first, with pagination.
@@ -666,6 +656,10 @@ export async function getCodingAgentSettings() {
     const kimiCliEnabled = getConfig('CODING_AGENT_KIMI_CLI_ENABLED');
     const kimiCliProvider = getConfig('CODING_AGENT_KIMI_CLI_PROVIDER') || '';
     const kimiCliModel = getConfig('CODING_AGENT_KIMI_CLI_MODEL') || '';
+    const agentModeBranch = getConfig('AGENT_MODE_BRANCH');
+    const codeModeBranch = getConfig('CODE_MODE_BRANCH');
+    const agentModeGitAction = getConfig('AGENT_MODE_GIT_ACTION');
+    const codeModeGitAction = getConfig('CODE_MODE_GIT_ACTION');
 
     // Credential readiness
     const oauthTokenCount = getOAuthTokenCount('claudeCode');
@@ -712,6 +706,10 @@ export async function getCodingAgentSettings() {
         provider: kimiCliProvider,
         model: kimiCliModel,
       },
+      modeDefaults: {
+        agent: { branch: agentModeBranch, gitAction: agentModeGitAction },
+        code: { branch: codeModeBranch, gitAction: codeModeGitAction },
+      },
       builtinProviders: BUILTIN_PROVIDERS,
       credentialStatuses,
       customProviders,
@@ -722,6 +720,66 @@ export async function getCodingAgentSettings() {
   }
 }
 
+/**
+ * Return the list of coding agents that are enabled and have valid credentials.
+ * Used to populate the right-click agent picker on the Interactive toggle.
+ * @returns {Promise<Array<{value: string, label: string}>>}
+ */
+export async function getAvailableCodingAgents() {
+  await requireAuth();
+  try {
+    const settings = await getCodingAgentSettings();
+    if (settings.error) return [];
+
+    const statusMap = new Map((settings.credentialStatuses || []).map(s => [s.key, s.isSet]));
+
+    function isProviderReady(provider) {
+      const builtin = settings.builtinProviders?.[provider];
+      if (builtin?.credentialKey) return statusMap.get(builtin.credentialKey) || false;
+      // Custom providers store their own credentials — if selected they're ready
+      const custom = (settings.customProviders || []).find(p => p.id === provider);
+      return !!custom;
+    }
+
+    const available = [];
+
+    if (settings.claudeCode?.enabled) {
+      const { claudeCode } = settings;
+      const backend = claudeCode.backend || 'anthropic';
+      const ready = backend === 'anthropic'
+        ? (claudeCode.auth === 'oauth' ? claudeCode.oauthTokenCount > 0 : claudeCode.anthropicKeySet)
+        : isProviderReady(backend);
+      if (ready) available.push({ value: 'claude-code', label: 'Claude Code' });
+    }
+
+    if (settings.pi?.enabled && settings.pi?.provider && isProviderReady(settings.pi.provider)) {
+      available.push({ value: 'pi-coding-agent', label: 'Pi' });
+    }
+
+    if (settings.geminiCli?.enabled && settings.geminiCli?.googleKeySet) {
+      available.push({ value: 'gemini-cli', label: 'Gemini CLI' });
+    }
+
+    if (settings.codexCli?.enabled) {
+      const { codexCli } = settings;
+      const ready = codexCli.auth === 'oauth' ? codexCli.oauthTokenCount > 0 : codexCli.codexKeySet;
+      if (ready) available.push({ value: 'codex-cli', label: 'Codex CLI' });
+    }
+
+    if (settings.openCode?.enabled && settings.openCode?.provider && isProviderReady(settings.openCode.provider)) {
+      available.push({ value: 'opencode', label: 'OpenCode' });
+    }
+
+    if (settings.kimiCli?.enabled && settings.kimiCli?.provider && isProviderReady(settings.kimiCli.provider)) {
+      available.push({ value: 'kimi-cli', label: 'Kimi CLI' });
+    }
+
+    return available;
+  } catch {
+    return [];
+  }
+}
+
 /**
  * Update per-agent coding agent config.
  * @param {string} agent - 'claude-code' or 'pi-coding-agent'
@@ -790,6 +848,54 @@ export async function setCodingAgentDefault(agent) {
   }
 }
 
+const MODE_BRANCH_VALUES = new Set(['default', 'dynamic']);
+const MODE_GIT_ACTION_VALUES = new Set(['commit', 'push', 'create-pr', 'pull']);
+
+/**
+ * Get the admin-configured default git action for a chat mode.
+ * Used by the chat UI to seed the workspace command dropdown.
+ * @param {'agent'|'code'} mode
+ */
+export async function getModeGitActionDefault(mode) {
+  await requireAuth();
+  if (mode !== 'agent' && mode !== 'code') return null;
+  const { getConfig } = await import('../config.js');
+  return getConfig(mode === 'code' ? 'CODE_MODE_GIT_ACTION' : 'AGENT_MODE_GIT_ACTION') || null;
+}
+
+/**
+ * Set a per-mode default (branch behavior or git action).
+ * @param {'agent'|'code'} mode
+ * @param {'branch'|'gitAction'} field
+ * @param {string} value
+ */
+export async function setModeDefault(mode, field, value) {
+  await requireAuth();
+  try {
+    if (mode !== 'agent' && mode !== 'code') return { error: 'Invalid mode' };
+    if (field === 'branch' && !MODE_BRANCH_VALUES.has(value)) return { error: 'Invalid branch value' };
+    if (field === 'gitAction' && !MODE_GIT_ACTION_VALUES.has(value)) return { error: 'Invalid git action value' };
+
+    const keyMap = {
+      'agent.branch': 'AGENT_MODE_BRANCH',
+      'code.branch': 'CODE_MODE_BRANCH',
+      'agent.gitAction': 'AGENT_MODE_GIT_ACTION',
+      'code.gitAction': 'CODE_MODE_GIT_ACTION',
+    };
+    const key = keyMap[`${mode}.${field}`];
+    if (!key) return { error: 'Invalid field' };
+
+    const { setConfigValue } = await import('../db/config.js');
+    const { invalidateConfigCache } = await import('../config.js');
+    setConfigValue(key, value);
+    invalidateConfigCache();
+    return { success: true };
+  } catch (err) {
+    console.error('Failed to set mode default:', err);
+    return { error: 'Failed to set mode default' };
+  }
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Settings — General sub-tab
 // ─────────────────────────────────────────────────────────────────────────────
@@ -846,7 +952,6 @@ const API_KEY_SECRETS = new Set([
   'TELEGRAM_WEBHOOK_SECRET',
   'ASSEMBLYAI_API_KEY',
 ]);
-const API_KEY_CONFIGS = new Set(['TELEGRAM_CHAT_ID']);
 
 /**
  * Get settings for the API Keys sub-tab.
@@ -854,11 +959,9 @@ const API_KEY_CONFIGS = new Set(['TELEGRAM_CHAT_ID']);
 export async function getApiKeySettings() {
   await requireAuth();
   try {
-    const { getSecretStatus, getConfigValue } = await import('../db/config.js');
-    const secretKeys = [...API_KEY_SECRETS];
-    const statuses = getSecretStatus(secretKeys);
-    const telegramChatId = getConfigValue('TELEGRAM_CHAT_ID');
-    return { secrets: statuses, telegramChatId };
+    const { getSecretStatus } = await import('../db/config.js');
+    const statuses = getSecretStatus([...API_KEY_SECRETS]);
+    return { secrets: statuses };
   } catch (err) {
     console.error('Failed to get API key settings:', err);
     return { error: 'Failed to load settings' };
@@ -870,20 +973,17 @@ export async function getApiKeySettings() {
  */
 export async function updateApiKeySetting(key, value) {
   const user = await requireAuth();
+  if (!API_KEY_SECRETS.has(key)) {
+    return { error: 'Invalid key' };
+  }
   try {
-    const { setConfigSecret, setConfigValue, deleteConfigSecret } = await import('../db/config.js');
+    const { setConfigSecret, deleteConfigSecret } = await import('../db/config.js');
     const { invalidateConfigCache } = await import('../config.js');
 
-    if (API_KEY_SECRETS.has(key)) {
-      if (value) {
-        setConfigSecret(key, value, user.id);
-      } else {
-        deleteConfigSecret(key);
-      }
-    } else if (API_KEY_CONFIGS.has(key)) {
-      setConfigValue(key, value, user.id);
+    if (value) {
+      setConfigSecret(key, value, user.id);
     } else {
-      return { error: 'Invalid key' };
+      deleteConfigSecret(key);
     }
 
     invalidateConfigCache();
@@ -916,12 +1016,114 @@ export async function regenerateWebhookSecret(key) {
   }
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Settings — Telegram setup flow
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Get Telegram status: bot info (if token valid) and webhook info.
+ * Used by the admin UI to render the current state of each setup step.
+ */
+export async function getTelegramStatus() {
+  await requireAuth();
+  try {
+    const { getConfigSecret } = 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');
+
+    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,
+    };
+  } 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 };
+  }
+}
+
 // ─────────────────────────────────────────────────────────────────────────────
 // Settings — Chat sub-tab
 // ─────────────────────────────────────────────────────────────────────────────
 
 /**
- * Get settings for the Chat sub-tab.
+ * Get settings for the Helper LLM page (and Providers page — both share this).
  */
 export async function getChatSettings() {
   await requireAuth();
@@ -936,34 +1138,16 @@ export async function getChatSettings() {
     // Get custom providers (masked)
     const customProviders = getCustomProviders();
 
-    // Get active config values
+    // Get active helper LLM config
     const activeProvider = getConfigValue('LLM_PROVIDER') || '';
     const activeModel = getConfigValue('LLM_MODEL') || '';
     const maxTokens = getConfigValue('LLM_MAX_TOKENS') || '4096';
     const agentBackend = getConfigValue('AGENT_BACKEND') || '';
 
-    // Check if the current coding agent has an in-process SDK adapter
-    const { getConfig } = await import('../config.js');
-    const { getSdkAdapter } = await import('../ai/sdk-adapters/index.js');
-    const codingAgent = getConfig('CODING_AGENT');
-    const sdkAgentActive = !!getSdkAdapter(codingAgent);
-
-    // Human-readable agent names
-    const agentNames = {
-      'claude-code': 'Claude Code',
-      'pi-coding-agent': 'Pi Coding Agent',
-      'gemini-cli': 'Gemini CLI',
-      'codex-cli': 'Codex CLI',
-      'opencode': 'OpenCode',
-      'kimi-cli': 'Kimi CLI',
-    };
-
     return {
       builtinProviders: BUILTIN_PROVIDERS,
       credentialStatuses,
       customProviders,
-      sdkAgentActive,
-      defaultAgent: agentNames[codingAgent] || codingAgent,
       active: {
         provider: activeProvider,
         model: activeModel,
@@ -972,8 +1156,8 @@ export async function getChatSettings() {
       },
     };
   } catch (err) {
-    console.error('Failed to get chat settings:', err);
-    return { error: 'Failed to load chat settings' };
+    console.error('Failed to get helper LLM settings:', err);
+    return { error: 'Failed to load helper LLM settings' };
   }
 }
 
@@ -1189,6 +1373,7 @@ export async function getGitHubConfig() {
   }
 
   // Build variables list: known names + any extras, with current value
+  const variablesError = !Array.isArray(remoteVariables) ? (remoteVariables?.error || 'Failed to load variables') : null;
   const remoteVarMap = new Map(
     Array.isArray(remoteVariables) ? remoteVariables.map((v) => [v.name, v.value]) : []
   );
@@ -1199,7 +1384,7 @@ export async function getGitHubConfig() {
     }
   }
 
-  return { secrets, variables };
+  return { secrets, variables, variablesError };
 }
 
 /**
@@ -1348,3 +1533,39 @@ export async function deleteGitHubVariableAction(name) {
   }
 }
 
+/**
+ * Issue (or re-issue) a Telegram verification code for the current user.
+ * Returns the code, expiry, and the bot's @username for instructions.
+ */
+export async function issueTelegramCode() {
+  const user = await requireAuth();
+  const { issueCode } = await import('../db/user-channels.js');
+  const { getConfig } = await import('../config.js');
+  const { validateBotToken } = await import('../tools/telegram.js');
+
+  try {
+    const row = issueCode(user.id, 'telegram');
+    const botToken = getConfig('TELEGRAM_BOT_TOKEN');
+    let botUsername = null;
+    if (botToken) {
+      const info = await validateBotToken(botToken);
+      if (info.valid) botUsername = info.botInfo.username;
+    }
+    return { code: row.code, expiresAt: row.codeExpiresAt, botUsername };
+  } catch (err) {
+    // If already verified, surface that so the UI can offer "unlink first"
+    return { error: err.message };
+  }
+}
+
+/**
+ * Unlink the current user's Telegram channel binding.
+ */
+export async function unlinkTelegramChannel() {
+  const user = await requireAuth();
+  const { unlink } = await import('../db/user-channels.js');
+  unlink(user.id, 'telegram');
+  return { ok: true };
+}
+
+