@pixelbyte-software/pixcode 1.53.3 → 1.53.5

package/server/services/telegram/telegram-gateway.js

@@ -0,0 +1,250 @@
+import crypto from 'node:crypto';
+
+import { telegramLinksDb } from '../../database/db.js';
+
+export const TELEGRAM_CONTROL_SCOPES = [
+  'admin',
+  'telegram:read',
+  'telegram:write',
+  'providers:read',
+  'providers:write',
+  'orchestration:read',
+  'orchestration:write',
+  'projects:read',
+  'sessions:read',
+  'webhooks:read',
+];
+
+export const TELEGRAM_PROVIDERS = ['claude', 'cursor', 'codex', 'gemini', 'qwen', 'opencode'];
+
+export const TELEGRAM_PROGRESS_MODES = ['final', 'steps', 'all', 'errors'];
+
+const MAX_TELEGRAM_TEXT = 3600;
+const CONFIRMATION_TTL_MS = 5 * 60 * 1000;
+const DEFAULT_ACTION_TIMEOUT_MS = 10 * 60 * 1000;
+const chatQueues = new Map();
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+export function splitTelegramText(text, max = MAX_TELEGRAM_TEXT) {
+  const value = String(text || '').trim();
+  if (!value) return [''];
+  if (value.length <= max) return [value];
+
+  const chunks = [];
+  let remaining = value;
+  while (remaining.length > max) {
+    let cut = remaining.lastIndexOf('\n', max);
+    if (cut < Math.floor(max * 0.55)) cut = remaining.lastIndexOf(' ', max);
+    if (cut < Math.floor(max * 0.55)) cut = max;
+    chunks.push(remaining.slice(0, cut).trim());
+    remaining = remaining.slice(cut).trim();
+  }
+  if (remaining) chunks.push(remaining);
+  return chunks;
+}
+
+export function normalizeTelegramToolResult(result = {}) {
+  if (result?.ok === false) {
+    return {
+      ok: false,
+      message: String(result.message || result.error || 'Action failed.'),
+      data: result.data ?? null,
+      requiresConfirmation: Boolean(result.requiresConfirmation),
+    };
+  }
+  return {
+    ok: true,
+    message: String(result.message || 'OK'),
+    data: result.data ?? result,
+    requiresConfirmation: Boolean(result.requiresConfirmation),
+  };
+}
+
+export function withTimeout(promiseFactory, timeoutMs = DEFAULT_ACTION_TIMEOUT_MS) {
+  let timeoutId;
+  const timeout = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      const error = new Error(`Telegram action timed out after ${timeoutMs}ms`);
+      error.code = 'TELEGRAM_ACTION_TIMEOUT';
+      reject(error);
+    }, timeoutMs);
+  });
+  return Promise.race([Promise.resolve().then(promiseFactory), timeout])
+    .finally(() => clearTimeout(timeoutId));
+}
+
+function isRetryableError(error) {
+  const status = error?.status || error?.statusCode || error?.response?.status || error?.response?.statusCode;
+  if ([408, 409, 425, 429, 500, 502, 503, 504].includes(Number(status))) return true;
+  const message = String(error?.message || '');
+  return /ECONNRESET|ETIMEDOUT|EAI_AGAIN|fetch failed|network/i.test(message);
+}
+
+export async function retryWithBackoff(action, {
+  retries = 2,
+  baseDelayMs = 500,
+  maxDelayMs = 4000,
+  shouldRetry = isRetryableError,
+} = {}) {
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt += 1) {
+    try {
+      return await action(attempt);
+    } catch (error) {
+      lastError = error;
+      if (attempt >= retries || !shouldRetry(error)) break;
+      const delay = Math.min(maxDelayMs, baseDelayMs * 2 ** attempt);
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+
+export function enqueueTelegramJob(chatId, job, { timeoutMs = DEFAULT_ACTION_TIMEOUT_MS } = {}) {
+  const key = String(chatId);
+  const previous = chatQueues.get(key) || Promise.resolve();
+  const current = previous
+    .catch(() => {})
+    .then(() => withTimeout(job, timeoutMs));
+  let queued;
+  queued = current.finally(() => {
+    if (chatQueues.get(key) === queued) chatQueues.delete(key);
+  }).catch(() => {});
+  chatQueues.set(key, queued);
+  return current;
+}
+
+export async function runTelegramTool({
+  userId,
+  action,
+  execute,
+  remoteControlRequired = true,
+  timeoutMs = DEFAULT_ACTION_TIMEOUT_MS,
+  retries = 1,
+}) {
+  const state = telegramLinksDb.getControlState(userId);
+  if (remoteControlRequired && state.remoteControlEnabled === false) {
+    return normalizeTelegramToolResult({
+      ok: false,
+      message: 'REMOTE_CONTROL_DISABLED',
+      data: { action },
+    });
+  }
+
+  const data = await retryWithBackoff(
+    () => withTimeout(execute, timeoutMs),
+    { retries },
+  );
+  return normalizeTelegramToolResult({ ok: true, message: 'OK', data });
+}
+
+export function createTelegramConfirmation(userId, action, payload = {}) {
+  const pending = {
+    id: crypto.randomBytes(8).toString('hex'),
+    action,
+    payload,
+    expiresAt: new Date(Date.now() + CONFIRMATION_TTL_MS).toISOString(),
+  };
+  telegramLinksDb.updateControlState(userId, { pendingConfirmation: pending });
+  return pending;
+}
+
+export function consumeTelegramConfirmation(userId, id) {
+  const state = telegramLinksDb.getControlState(userId);
+  const pending = state.pendingConfirmation;
+  if (!pending || pending.id !== id) return { ok: false, reason: 'missing' };
+  if (Date.parse(pending.expiresAt) <= Date.now()) {
+    telegramLinksDb.updateControlState(userId, { pendingConfirmation: null });
+    return { ok: false, reason: 'expired' };
+  }
+  telegramLinksDb.updateControlState(userId, { pendingConfirmation: null });
+  return { ok: true, confirmation: pending };
+}
+
+export function clearTelegramConfirmation(userId, id = null) {
+  const state = telegramLinksDb.getControlState(userId);
+  if (id && state.pendingConfirmation?.id !== id) return false;
+  telegramLinksDb.updateControlState(userId, { pendingConfirmation: null });
+  return true;
+}
+
+function normalizedText(text) {
+  return String(text || '')
+    .trim()
+    .toLocaleLowerCase('tr')
+    .replace(/\s+/g, ' ');
+}
+
+export function classifyTelegramIntent(text, state = {}) {
+  if (state.routerEnabled === false || state.routerMode !== 'hybrid') return null;
+
+  const value = normalizedText(text);
+  if (!value) return null;
+
+  for (const provider of TELEGRAM_PROVIDERS) {
+    const providerRe = new RegExp(`(^|\\s)${provider}(\\s|$)`);
+    if (
+      providerRe.test(value)
+      && /(kullan|seç|sec|switch|use|select|provider|sağlayıcı|saglayici)/i.test(value)
+    ) {
+      return { action: 'provider_select', provider };
+    }
+  }
+
+  const projectPick = value.match(/^(?:proje(?:yi)?\s+seç|proje(?:yi)?\s+sec|select project|pick project)\s+(.+)$/i);
+  if (projectPick?.[1]) return { action: 'project_select_query', query: projectPick[1].trim() };
+
+  if (/^(?:projeler|projeleri göster|projeleri goster|proje seç|proje sec|projects?|show projects|select project|pick project)$/.test(value)) {
+    return { action: 'projects' };
+  }
+  if (/^(?:sağlayıcı|saglayici|provider|providers|sağlayıcı seç|saglayici sec|change provider|select provider)$/.test(value)) {
+    return { action: 'provider_menu' };
+  }
+  if (/^(?:model|models|model seç|model sec|change model|select model)$/.test(value)) {
+    return { action: 'model_menu' };
+  }
+  if (/(?:son|last|recent).*(?:run|çalışma|calisma|durum|status)|^(?:runs?|çalışmalar|calismalar)$/.test(value)) {
+    return { action: 'runs' };
+  }
+  if (/^(?:approvals?|onaylar|bekleyen onaylar|izinler)$/.test(value)) {
+    return { action: 'approvals' };
+  }
+  if (/^(?:workflow|workflows|iş akışı|is akisi|orkestrasyon|orchestration|workflow seç|workflow sec)$/.test(value)) {
+    return { action: 'workflows' };
+  }
+  if (/^(?:new chat|yeni sohbet|yeni chat)$/.test(value)) {
+    return { action: 'new_chat' };
+  }
+
+  return null;
+}
+
+export function resolveTelegramProvider(state = {}) {
+  const provider = TELEGRAM_PROVIDERS.includes(state.routerProvider)
+    ? state.routerProvider
+    : state.selectedProvider;
+  return TELEGRAM_PROVIDERS.includes(provider) ? provider : 'opencode';
+}
+
+export function resolveTelegramModel(state = {}) {
+  return typeof state.routerModel === 'string' && state.routerModel.trim()
+    ? state.routerModel.trim()
+    : state.selectedModel;
+}
+
+export function buildTelegramAgentPrompt(prompt, state = {}) {
+  const provider = resolveTelegramProvider(state);
+  const model = resolveTelegramModel(state);
+  const project = state.selectedProjectName || state.selectedProjectPath || 'not selected';
+  return [
+    'Source: Telegram.',
+    `Selected project: ${project}.`,
+    `Selected provider: ${provider}${model ? ` / ${model}` : ''}.`,
+    'Return a Telegram-friendly final summary with status, relevant IDs, concise output, and any diff/test summary.',
+    'Keep the final answer brief unless the user explicitly asks for detail.',
+    '',
+    'User request:',
+    String(prompt || '').trim(),
+  ].join('\n');
+}

package/server/services/telegram/telegram-http-client.js

@@ -53,15 +53,19 @@ async function callApi(token, method, params, { signal } = {}) {
 }
 
 export class TelegramHttpBot extends EventEmitter {
-  constructor(token, { polling = true, pollTimeoutSec = 30 } = {}) {
+  constructor(token, { polling = true, pollTimeoutSec = 30, pollLimit = 25, dropPendingUpdates = true } = {}) {
     super();
     if (!token) throw new Error('TelegramHttpBot: token is required');
     this._token = token;
     this._pollTimeoutSec = pollTimeoutSec;
+    this._pollLimit = pollLimit;
+    this._dropPendingUpdates = dropPendingUpdates;
     this._offset = 0;
     this._polling = false;
     this._abortController = null;
-    if (polling) this._startPolling();
+    this._pollingLoop = null;
+    this._pollingErrorCount = 0;
+    if (polling) this.startPolling();
   }
 
   // ---------- Public API (mirrors node-telegram-bot-api surface) ----------
@@ -96,56 +100,102 @@ export class TelegramHttpBot extends EventEmitter {
     this._polling = false;
     try { this._abortController?.abort(); } catch { /* ignore */ }
     this._abortController = null;
+    if (this._pollingLoop) {
+      await this._pollingLoop.catch(() => {});
+      this._pollingLoop = null;
+    }
   }
 
   // ---------- Polling loop ----------
 
-  async _startPolling() {
+  async startPolling({ dropPendingUpdates = this._dropPendingUpdates } = {}) {
+    if (this._polling) return;
     this._polling = true;
-    // Kick off a non-awaited loop. Each iteration long-polls getUpdates for
-    // up to pollTimeoutSec, then loops immediately. We deliberately serialize
-    // (no concurrent long-polls) because Telegram rejects that with 409.
-    (async () => {
-      while (this._polling) {
-        this._abortController = new AbortController();
-        try {
-          const updates = await callApi(
-            this._token,
-            'getUpdates',
-            {
-              offset: this._offset,
-              timeout: this._pollTimeoutSec,
-              allowed_updates: ['message', 'callback_query'],
-            },
-            { signal: this._abortController.signal },
-          );
-          for (const update of updates) {
-            if (typeof update.update_id === 'number') {
-              this._offset = Math.max(this._offset, update.update_id + 1);
-            }
-            if (update.message) {
-              try { this.emit('message', update.message); } catch (err) {
-                // Don't let a listener exception break the poll loop.
-                this.emit('polling_error', err);
-              }
-            }
-            if (update.callback_query) {
-              try { this.emit('callback_query', update.callback_query); } catch (err) {
-                this.emit('polling_error', err);
-              }
-            }
+    this._pollingLoop = this._runPollingLoop({ dropPendingUpdates });
+    await Promise.resolve();
+  }
+
+  async _dropPendingUpdatesBeforePolling() {
+    try {
+      await callApi(this._token, 'deleteWebhook', { drop_pending_updates: true });
+      return;
+    } catch (err) {
+      this.emit('polling_error', err);
+    }
+
+    // Fallback for environments where deleteWebhook is rejected: a negative
+    // offset asks Telegram to forget older queued updates.
+    try {
+      const updates = await callApi(this._token, 'getUpdates', {
+        offset: -1,
+        limit: 1,
+        timeout: 0,
+        allowed_updates: ['message', 'callback_query'],
+      });
+      const lastUpdate = Array.isArray(updates) ? updates.at(-1) : null;
+      if (typeof lastUpdate?.update_id === 'number') {
+        this._offset = lastUpdate.update_id + 1;
+      }
+    } catch (err) {
+      this.emit('polling_error', err);
+    }
+  }
+
+  async _emitSerial(eventName, payload) {
+    const listeners = this.listeners(eventName);
+    for (const listener of listeners) {
+      try {
+        await listener(payload);
+      } catch (err) {
+        this.emit('polling_error', err);
+      }
+    }
+  }
+
+  async _runPollingLoop({ dropPendingUpdates }) {
+    if (dropPendingUpdates) {
+      await this._dropPendingUpdatesBeforePolling();
+    }
+
+    // Each iteration long-polls getUpdates for up to pollTimeoutSec, then
+    // loops immediately. We deliberately serialize update handling because a
+    // stale Telegram backlog can otherwise fan out into many expensive scans.
+    while (this._polling) {
+      this._abortController = new AbortController();
+      try {
+        const updates = await callApi(
+          this._token,
+          'getUpdates',
+          {
+            offset: this._offset,
+            limit: this._pollLimit,
+            timeout: this._pollTimeoutSec,
+            allowed_updates: ['message', 'callback_query'],
+          },
+          { signal: this._abortController.signal },
+        );
+        for (const update of updates) {
+          if (typeof update.update_id === 'number') {
+            this._offset = Math.max(this._offset, update.update_id + 1);
+          }
+          if (update.message) {
+            await this._emitSerial('message', update.message);
+          }
+          if (update.callback_query) {
+            await this._emitSerial('callback_query', update.callback_query);
           }
-        } catch (err) {
-          // AbortError is the expected path when stopPolling() is called.
-          if (err?.name === 'AbortError' || !this._polling) break;
-          this.emit('polling_error', err);
-          // Back off before retrying — rapid retries on 401/409 would
-          // otherwise spin at 100% CPU. Upstream consumer's polling_error
-          // handler may also call stopBot() on 401/409 which flips _polling
-          // off and breaks the loop on the next tick.
-          await new Promise((r) => setTimeout(r, 2000));
         }
+        this._pollingErrorCount = 0;
+      } catch (err) {
+        // AbortError is the expected path when stopPolling() is called.
+        if (err?.name === 'AbortError' || !this._polling) break;
+        this.emit('polling_error', err);
+        const status = err?.response?.statusCode || err?.code;
+        const baseDelay = status === 409 ? 2000 : 1000;
+        const delay = Math.min(60_000, baseDelay * 2 ** this._pollingErrorCount);
+        this._pollingErrorCount = Math.min(this._pollingErrorCount + 1, 6);
+        await new Promise((r) => setTimeout(r, delay));
       }
-    })();
+    }
   }
 }

package/server/services/telegram/translations.js

@@ -55,8 +55,11 @@ const EN = {
   'control.button.refresh': 'Refresh',
   'control.button.approve': 'Approve',
   'control.button.deny': 'Deny',
+  'control.button.confirm': 'Confirm',
+  'control.button.cancel': 'Cancel',
   'control.noProjects': 'No Pixcode projects were found yet. Add/open a project in Pixcode first.',
   'control.pickProject': 'Pick the project Telegram should control:',
+  'control.projectNotFound': 'No project matched "{{query}}". Pick one from the list.',
   'control.pickProvider': 'Pick the CLI provider Telegram should use:',
   'control.modelsFor': 'Models for {{provider}}:',
   'control.pickWorkflow': 'Pick an orchestration workflow:',
@@ -83,6 +86,12 @@ const EN = {
   'control.authMenu': 'Pick a provider for OAuth/login instructions:',
   'control.manualInstall': 'Manual install for {{provider}}:\n{{manual}}',
   'control.installStarted': 'Install started for {{provider}}.\nJob: {{jobId}}\nCommand: {{command}}',
+  'control.confirmationRequired': 'This action needs confirmation before it can run.',
+  'control.confirmInstall': 'Confirm CLI install/repair for {{provider}}?',
+  'control.confirmCancelRun': 'Confirm cancel for workflow run {{runId}}?',
+  'control.confirmationExpired': 'That confirmation expired. Start the action again.',
+  'control.confirmationMissing': 'No matching confirmation is pending. Start the action again.',
+  'control.confirmationCanceled': 'Action canceled.',
   'control.settingsTitle': 'Telegram settings',
   'control.pickLanguage': 'Pick Telegram language:',
   'control.menuExpired': 'This menu expired. Send /menu.',
@@ -157,8 +166,11 @@ const TR = {
   'control.button.refresh': 'Yenile',
   'control.button.approve': 'Onayla',
   'control.button.deny': 'Reddet',
+  'control.button.confirm': 'Onayla',
+  'control.button.cancel': 'Vazgeç',
   'control.noProjects': 'Henüz Pixcode projesi bulunamadı. Önce Pixcode içinde proje ekle/aç.',
   'control.pickProject': 'Telegramın kontrol edeceği projeyi seç:',
+  'control.projectNotFound': '"{{query}}" ile eşleşen proje bulunamadı. Listeden birini seç.',
   'control.pickProvider': 'Telegramın kullanacağı CLI sağlayıcısını seç:',
   'control.modelsFor': '{{provider}} modelleri:',
   'control.pickWorkflow': 'Bir orkestrasyon iş akışı seç:',
@@ -185,6 +197,12 @@ const TR = {
   'control.authMenu': 'OAuth/giriş yönergeleri için sağlayıcı seç:',
   'control.manualInstall': '{{provider}} manuel kurulum:\n{{manual}}',
   'control.installStarted': '{{provider}} kurulumu başladı.\nİş: {{jobId}}\nKomut: {{command}}',
+  'control.confirmationRequired': 'Bu işlem çalışmadan önce onay gerektiriyor.',
+  'control.confirmInstall': '{{provider}} için CLI kurulum/onarım işlemini onaylıyor musun?',
+  'control.confirmCancelRun': '{{runId}} workflow çalışmasını iptal etmeyi onaylıyor musun?',
+  'control.confirmationExpired': 'Bu onayın süresi doldu. İşlemi yeniden başlat.',
+  'control.confirmationMissing': 'Bekleyen eşleşen bir onay yok. İşlemi yeniden başlat.',
+  'control.confirmationCanceled': 'İşlem iptal edildi.',
   'control.settingsTitle': 'Telegram ayarları',
   'control.pickLanguage': 'Telegram dilini seç:',
   'control.menuExpired': 'Bu menünün süresi doldu. /menu gönder.',