onbuzz 4.9.11 → 4.9.12

package/src/interfaces/marketplaceRoutes.js

@@ -0,0 +1,376 @@
+/**
+ * Marketplace proxy routes on the local CLI server.
+ *
+ * Purpose:
+ *   Forward every browser-side marketplaceApi call to the upstream
+ *   marketplace service via the local server. The renderer never has
+ *   to know the upstream URL, and — more importantly — every payload
+ *   that comes back through `/items/:id/download` is byte-verified
+ *   here before the browser sees it.
+ *
+ *   The historical pain point this guards against: the upstream
+ *   marketplace service may stream a partial response (network blip,
+ *   load-balancer reset, half-written blob), and a naive proxy would
+ *   serve that 200-OK truncated body to the browser. The browser would
+ *   then write a half-baked skill / agent to disk and "successfully"
+ *   install something that doesn't run. Integrity verification on the
+ *   server-side means the renderer ONLY ever sees a verified body or
+ *   an explicit 502 with `error: 'integrity_mismatch'`.
+ *
+ * Contract with the upstream marketplace service (see shared
+ * "INTEGRITY ADDITIONS" in the marketplace plan):
+ *   - GET /items/:id/download MUST set
+ *       Content-Length: <bytes>
+ *       X-Content-Hash:  sha256-<hex>
+ *     where `<bytes>` is the byte length of the response body and
+ *     `<hex>` is the lowercase hex-encoded SHA-256 of those bytes.
+ *   - GET /items/:id MUST include `content_hash` and
+ *     `content_size_bytes` in the JSON response.
+ *   - POST /items computes both fields server-side; the renderer
+ *     never sends them.
+ *
+ * Verification policy on /items/:id/download:
+ *   1. If upstream did NOT return `X-Content-Hash`, we treat the
+ *      response as opaque pass-through (legacy items). A WARN is
+ *      logged so we can spot listings that haven't been re-hashed
+ *      after a backfill, but we do NOT 502 — that would block all
+ *      pre-hash listings instantly.
+ *   2. If upstream DID return `X-Content-Hash`, we buffer the body
+ *      and compute SHA-256. On mismatch → 502
+ *      `{ error: 'integrity_mismatch', expectedHash, actualHash,
+ *         expectedBytes, actualBytes }`.
+ *   3. Content-Length is verified when present, even without a hash.
+ *      Truncated body → 502 with `error: 'content_length_mismatch'`.
+ *   4. Mid-stream upstream error → 502 with
+ *      `error: 'stream_truncated'`. The browser never sees a 200 with
+ *      a partial body.
+ *   5. On success we forward `X-Content-Hash`, `Content-Length`, and
+ *      `X-Integrity-Verified: true` so the renderer can surface a
+ *      "verified" indicator.
+ *
+ * Auth forwarding:
+ *   Whatever Authorization header the browser sent is forwarded
+ *   verbatim to upstream. The marketplace service verifies JWTs
+ *   itself (it shares the autopilot-backend signing secret). The
+ *   local server adds nothing and strips nothing — symmetry with
+ *   the direct-from-browser marketplaceApi call site preserves the
+ *   existing auth contract.
+ *
+ * Testable design:
+ *   `createMarketplaceRouter()` accepts every dependency (fetch impl,
+ *   upstream URL, logger). No global state, no hidden coupling. See
+ *   webServer.marketplace.test.js for the proxy-roundtrip, auth-
+ *   forwarding, integrity-mismatch, length-mismatch, stream-truncation,
+ *   and error-mapping coverage.
+ */
+
+import express from 'express';
+import crypto from 'crypto';
+
+const DEFAULT_UPSTREAM = 'https://autopilot-marketplace.azurewebsites.net';
+
+export const INTEGRITY_ERROR_CODES = Object.freeze({
+  INTEGRITY_MISMATCH:      'integrity_mismatch',
+  CONTENT_LENGTH_MISMATCH: 'content_length_mismatch',
+  STREAM_TRUNCATED:        'stream_truncated',
+  UPSTREAM_UNREACHABLE:    'upstream_unreachable',
+});
+
+/**
+ * Parse the upstream `X-Content-Hash` header.
+ *
+ * Accepts:
+ *   "sha256-<hex>"   (canonical form per contract)
+ *   "<hex>"          (lowered-cased upstream variant we tolerate)
+ *
+ * Returns the lowercase hex digest, or null if the header is absent
+ * or unparseable.
+ */
+export function parseContentHashHeader(header) {
+  if (typeof header !== 'string' || header.length === 0) return null;
+  const trimmed = header.trim().toLowerCase();
+  if (trimmed.startsWith('sha256-')) {
+    const hex = trimmed.slice('sha256-'.length);
+    return /^[0-9a-f]+$/.test(hex) ? hex : null;
+  }
+  return /^[0-9a-f]+$/.test(trimmed) ? trimmed : null;
+}
+
+/**
+ * Verify a buffered download body against the upstream's declared
+ * Content-Length and X-Content-Hash. Pure function, no I/O.
+ *
+ * @param {Buffer|Uint8Array} bodyBytes
+ * @param {{ expectedHash: string|null, expectedBytes: number|null }} expected
+ * @returns {{ ok: true, actualHash: string, actualBytes: number }
+ *          | { ok: false, code: string, expectedHash: string|null,
+ *              actualHash: string, expectedBytes: number|null,
+ *              actualBytes: number }}
+ */
+export function verifyDownloadBytes(bodyBytes, { expectedHash, expectedBytes }) {
+  const buf = Buffer.isBuffer(bodyBytes) ? bodyBytes : Buffer.from(bodyBytes);
+  const actualBytes = buf.length;
+  const actualHash = crypto.createHash('sha256').update(buf).digest('hex');
+
+  // Length check first — cheaper, and a length mismatch is almost
+  // certainly the root cause of any hash mismatch that follows.
+  if (expectedBytes !== null && expectedBytes !== undefined && expectedBytes !== actualBytes) {
+    return {
+      ok: false,
+      code: INTEGRITY_ERROR_CODES.CONTENT_LENGTH_MISMATCH,
+      expectedHash: expectedHash || null,
+      actualHash,
+      expectedBytes,
+      actualBytes,
+    };
+  }
+  if (expectedHash && expectedHash !== actualHash) {
+    return {
+      ok: false,
+      code: INTEGRITY_ERROR_CODES.INTEGRITY_MISMATCH,
+      expectedHash,
+      actualHash,
+      expectedBytes: expectedBytes ?? null,
+      actualBytes,
+    };
+  }
+  return { ok: true, actualHash, actualBytes };
+}
+
+/**
+ * Build the marketplace router.
+ *
+ * @param {Object} deps
+ * @param {string} [deps.upstreamBaseUrl] — upstream marketplace base URL.
+ * @param {typeof fetch} [deps.fetchImpl] — fetch impl (DI for tests).
+ * @param {Object} [deps.logger] — logger with info/warn/error.
+ */
+export function createMarketplaceRouter({
+  upstreamBaseUrl = DEFAULT_UPSTREAM,
+  fetchImpl = fetch,
+  logger = console,
+} = {}) {
+  const router = express.Router();
+  const baseUrl = upstreamBaseUrl.replace(/\/$/, '');
+
+  /**
+   * Build the forwarded header set. Authorization is passed verbatim;
+   * Content-Type is preserved for body-carrying methods.
+   *
+   * We deliberately do NOT forward hop-by-hop headers (Host,
+   * Connection, Transfer-Encoding, etc.). We also drop the browser's
+   * Origin/Referer because upstream's CORS check would otherwise
+   * reject the call when the request is server-to-server.
+   */
+  function forwardHeaders(req, { withContentType = true } = {}) {
+    const headers = {};
+    const auth = req.headers['authorization'];
+    if (typeof auth === 'string' && auth.length > 0) {
+      headers['Authorization'] = auth;
+    }
+    if (withContentType) {
+      headers['Content-Type'] = req.headers['content-type'] || 'application/json';
+    }
+    return headers;
+  }
+
+  /**
+   * Generic JSON proxy used for every endpoint that returns a JSON
+   * envelope (browse, get-item, publish, update, delete, rate,
+   * featured, my-items, tags). Body is parsed as text-then-JSON so
+   * non-JSON 5xx HTML pages don't crash the parser.
+   */
+  async function proxyJson(req, res, { method, path, body }) {
+    const url = `${baseUrl}${path}`;
+    const init = {
+      method,
+      headers: forwardHeaders(req, { withContentType: body !== undefined }),
+    };
+    if (body !== undefined) {
+      init.body = typeof body === 'string' ? body : JSON.stringify(body);
+    }
+
+    let upstreamRes;
+    try {
+      upstreamRes = await fetchImpl(url, init);
+    } catch (err) {
+      logger?.warn?.('[marketplaceRoutes] upstream fetch failed', {
+        url, method, error: err.message,
+      });
+      return res.status(502).json({
+        error: INTEGRITY_ERROR_CODES.UPSTREAM_UNREACHABLE,
+        message: 'Could not reach marketplace service',
+        details: err.message,
+      });
+    }
+
+    const text = await upstreamRes.text().catch(() => '');
+    let parsed;
+    try { parsed = text ? JSON.parse(text) : {}; } catch { parsed = { raw: text }; }
+    return res.status(upstreamRes.status).json(parsed);
+  }
+
+  // ── Browse / list ─────────────────────────────────────────────────
+  router.get('/items', async (req, res) => {
+    const qs = req.originalUrl.includes('?')
+      ? req.originalUrl.slice(req.originalUrl.indexOf('?'))
+      : '';
+    return proxyJson(req, res, { method: 'GET', path: `/api/items${qs}` });
+  });
+
+  // Featured, tags, my-items are fixed paths under /items or top-level.
+  router.get('/items/featured', async (req, res) =>
+    proxyJson(req, res, { method: 'GET', path: '/api/items/featured' })
+  );
+  router.get('/items/tags', async (req, res) =>
+    proxyJson(req, res, { method: 'GET', path: '/api/items/tags' })
+  );
+  router.get('/my-items', async (req, res) =>
+    proxyJson(req, res, { method: 'GET', path: '/api/my-items' })
+  );
+
+  // ── Detail (single item) ──────────────────────────────────────────
+  router.get('/items/:id', async (req, res) =>
+    proxyJson(req, res, { method: 'GET', path: `/api/items/${encodeURIComponent(req.params.id)}` })
+  );
+
+  // ── Download (INTEGRITY-VERIFIED) ─────────────────────────────────
+  // This is the security-critical path. We buffer the upstream body
+  // and verify SHA-256 + length BEFORE the browser sees anything.
+  router.get('/items/:id/download', async (req, res) => {
+    const url = `${baseUrl}/api/items/${encodeURIComponent(req.params.id)}/download`;
+
+    let upstreamRes;
+    try {
+      upstreamRes = await fetchImpl(url, {
+        method: 'GET',
+        headers: forwardHeaders(req, { withContentType: false }),
+      });
+    } catch (err) {
+      logger?.warn?.('[marketplaceRoutes] download upstream fetch failed', {
+        url, error: err.message,
+      });
+      return res.status(502).json({
+        error: INTEGRITY_ERROR_CODES.UPSTREAM_UNREACHABLE,
+        message: 'Could not reach marketplace service for download',
+        details: err.message,
+      });
+    }
+
+    // Non-2xx → pass through status with parsed body. No integrity
+    // check necessary because the body is an error envelope, not
+    // an installable payload.
+    if (!upstreamRes.ok) {
+      const errText = await upstreamRes.text().catch(() => '');
+      let errBody;
+      try { errBody = errText ? JSON.parse(errText) : {}; } catch { errBody = { raw: errText }; }
+      return res.status(upstreamRes.status).json(errBody);
+    }
+
+    // Read upstream headers BEFORE consuming the stream so we know
+    // what to verify against.
+    const expectedHash  = parseContentHashHeader(upstreamRes.headers.get('x-content-hash'));
+    const expectedBytesRaw = upstreamRes.headers.get('content-length');
+    // Guard against non-numeric Content-Length: Number("foo") === NaN,
+    // which then serialises as null in the JSON error payload and confuses
+    // the operator. Treat any non-finite parse as "unknown" so the
+    // verification gracefully skips the length check rather than reporting
+    // a misleading mismatch.
+    const expectedBytesParsed =
+      expectedBytesRaw === null || expectedBytesRaw === undefined
+        ? null
+        : Number(expectedBytesRaw);
+    const expectedBytes = Number.isFinite(expectedBytesParsed) ? expectedBytesParsed : null;
+
+    // Buffer the body. We tolerate two upstream shapes: a real
+    // ReadableStream (Node 18+ fetch) and the test-friendly
+    // arrayBuffer() shortcut.
+    let bodyBytes;
+    try {
+      if (typeof upstreamRes.arrayBuffer === 'function') {
+        const ab = await upstreamRes.arrayBuffer();
+        bodyBytes = Buffer.from(ab);
+      } else if (upstreamRes.body && typeof upstreamRes.body.getReader === 'function') {
+        const reader = upstreamRes.body.getReader();
+        const chunks = [];
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          chunks.push(Buffer.from(value));
+        }
+        bodyBytes = Buffer.concat(chunks);
+      } else {
+        const text = await upstreamRes.text();
+        bodyBytes = Buffer.from(text);
+      }
+    } catch (err) {
+      logger?.warn?.('[marketplaceRoutes] stream truncated', {
+        url, error: err.message,
+      });
+      return res.status(502).json({
+        error: INTEGRITY_ERROR_CODES.STREAM_TRUNCATED,
+        message: 'Marketplace download was interrupted',
+        details: err.message,
+      });
+    }
+
+    // Verify. If upstream sent neither header, we pass through with
+    // a warning — legacy item, no integrity contract.
+    if (expectedHash === null && expectedBytes === null) {
+      logger?.warn?.('[marketplaceRoutes] download missing integrity headers', { url });
+      res.setHeader('X-Integrity-Verified', 'false');
+      res.setHeader('X-Integrity-Reason', 'no_upstream_headers');
+      res.status(200);
+      res.setHeader('Content-Type', upstreamRes.headers.get('content-type') || 'application/octet-stream');
+      return res.send(bodyBytes);
+    }
+
+    const verdict = verifyDownloadBytes(bodyBytes, { expectedHash, expectedBytes });
+    if (!verdict.ok) {
+      logger?.warn?.('[marketplaceRoutes] integrity check failed', { url, ...verdict });
+      return res.status(502).json({
+        error: verdict.code,
+        expectedHash: verdict.expectedHash,
+        actualHash: verdict.actualHash,
+        expectedBytes: verdict.expectedBytes,
+        actualBytes: verdict.actualBytes,
+      });
+    }
+
+    // Verified. Forward headers + body byte-identically.
+    res.setHeader('Content-Type', upstreamRes.headers.get('content-type') || 'application/octet-stream');
+    res.setHeader('Content-Length', String(verdict.actualBytes));
+    res.setHeader('X-Content-Hash', `sha256-${verdict.actualHash}`);
+    res.setHeader('X-Integrity-Verified', 'true');
+    return res.status(200).send(bodyBytes);
+  });
+
+  // ── Publish / update / delete / rate ──────────────────────────────
+  router.post('/items', async (req, res) =>
+    proxyJson(req, res, { method: 'POST', path: '/api/items', body: req.body })
+  );
+  router.put('/items/:id', async (req, res) =>
+    proxyJson(req, res, {
+      method: 'PUT',
+      path: `/api/items/${encodeURIComponent(req.params.id)}`,
+      body: req.body,
+    })
+  );
+  router.delete('/items/:id', async (req, res) =>
+    proxyJson(req, res, {
+      method: 'DELETE',
+      path: `/api/items/${encodeURIComponent(req.params.id)}`,
+    })
+  );
+  router.post('/items/:id/rate', async (req, res) =>
+    proxyJson(req, res, {
+      method: 'POST',
+      path: `/api/items/${encodeURIComponent(req.params.id)}/rate`,
+      body: req.body,
+    })
+  );
+
+  return router;
+}
+
+export const __test__ = { parseContentHashHeader, verifyDownloadBytes };

package/src/interfaces/webServer.js

@@ -36,6 +36,7 @@ import { projectActiveRuns } from '../utilities/flowRunFilters.js';
 import { recordOAuthResult, recordResolvedUser, projectAuthStatus, isAuthExpired } from '../utilities/authCache.js';
 import AuthCacheStore from '../services/authCacheStore.js';
 import { createAccountRouter } from './accountRoutes.js';
+import { createMarketplaceRouter } from './marketplaceRoutes.js';
 import { getBrand } from '../utilities/brand.js';
 
 // Connect visual editor server to bridge (enables element selection forwarding)
@@ -1070,6 +1071,21 @@ h2{color:#16a34a;margin-bottom:.5rem;} p{color:#666;}</style></head>
       logger:   this.logger,
     }));
 
+    // =====================================================
+    // Marketplace proxy (integrity-verifying).
+    // Defined in `interfaces/marketplaceRoutes.js`; mounted at
+    // /api/marketplace so the web-UI can route every browse / publish
+    // / install call through the local server. The download endpoint
+    // verifies SHA-256 + Content-Length against the upstream's
+    // X-Content-Hash header BEFORE the browser sees any bytes — a
+    // truncated upstream response can never reach the renderer as a
+    // 200-OK partial body.
+    // =====================================================
+    this.app.use('/api/marketplace', createMarketplaceRouter({
+      upstreamBaseUrl: this.config?.marketplace?.baseUrl,
+      logger: this.logger,
+    }));
+
     // =====================================================
     // System Update API
     // =====================================================

package/src/services/__tests__/telegramService.test.js

@@ -94,8 +94,20 @@ class MockBot {
 }
 
 let currentBot;
-jest.unstable_mockModule('node-telegram-bot-api', () => ({
-  default: jest.fn(() => {
+// We migrated off node-telegram-bot-api to telegraf via a thin compat
+// wrapper at src/services/telegrafBot.js. The MockBot above implements
+// exactly the wrapper's surface (sendMessage, editMessageText,
+// deleteMessage, sendChatAction, sendPhoto, sendDocument,
+// answerCallbackQuery, getFileLink, getMe, stopPolling, onText, on) so
+// retargeting the mock to the wrapper module is the entire test-side
+// change. telegramService.js calls `createTelegrafBot(token, opts)` —
+// match that shape (async factory returning the wrapper).
+jest.unstable_mockModule('../telegrafBot.js', () => ({
+  createTelegrafBot: jest.fn(async () => {
+    currentBot = new MockBot();
+    return currentBot;
+  }),
+  default: jest.fn(async () => {
     currentBot = new MockBot();
     return currentBot;
   }),

package/src/services/composioService.js

@@ -118,8 +118,15 @@ export async function getClient() {
     const mod = await import('@composio/core');
     Composio = mod.Composio || mod.default?.Composio || mod.default;
   } catch (e) {
+    // Do NOT cache this one. Background: `npm audit fix --force` has
+    // historically nuked @composio/core (its tree carries the loudest
+    // CVEs in the project — 16 vulns, 2 critical), then a follow-up
+    // `npm install @composio/core@^0.6.11` restores it. If we cache the
+    // "SDK is not installed" reason permanently, every subsequent call
+    // returns the stale failure until the CLI is restarted — exactly the
+    // "I installed it but the UI still complains" loop we hit. Returning
+    // the error without caching lets the next call retry the import.
     const reason = `@composio/core SDK is not installed. Run \`npm install @composio/core\`. Detail: ${e.message}`;
-    _unavailableReason = reason;
     return { error: reason };
   }
 
@@ -128,8 +135,10 @@ export async function getClient() {
     _activeKeyFingerprint = fingerprint;
     return { client: _client };
   } catch (e) {
+    // Same reasoning as above — SDK init failures can come from transient
+    // upstream issues (bad key, network) that don't need a CLI restart to
+    // clear. Let the next call retry.
     const reason = `Composio SDK initialization failed: ${e.message}`;
-    _unavailableReason = reason;
     return { error: reason };
   }
 }

package/src/services/telegrafBot.js

@@ -0,0 +1,174 @@
+/**
+ * telegrafBot — node-telegram-bot-api-compatible wrapper around `telegraf`.
+ *
+ * Why this layer exists:
+ *
+ *   We migrated off `node-telegram-bot-api` because it kept the deprecated
+ *   `request` / `form-data` / `@cypress/request` chain alive (9 CVEs incl.
+ *   2 critical, no upstream fix). `telegraf` is the modern Telegram Bot
+ *   API library with no deprecated transitive deps.
+ *
+ *   But `telegramService.js` is ~1900 LOC built against the
+ *   node-telegram-bot-api surface (`bot.sendMessage(chatId, text, opts)`,
+ *   `bot.editMessageText(text, opts)`, `bot.onText(regex, handler)`,
+ *   `bot.on('message', handler)`, etc.). Rewriting every call site to
+ *   telegraf's middleware/Context paradigm would be a 1900-line diff
+ *   touching every handler. Insted, this thin wrapper presents the
+ *   familiar surface on top of telegraf so the service code is
+ *   unchanged.
+ *
+ *   The wrapper also keeps the test seam stable — the existing MockBot
+ *   in __tests__/telegramService.test.js implements exactly this
+ *   surface, so the test file's mock just retargets to this module.
+ *
+ * What it preserves:
+ *
+ *   - `bot.getMe()`            → telegraf `bot.telegram.getMe()`
+ *   - `bot.stopPolling()`      → telegraf `bot.stop()`
+ *   - `bot.sendMessage()`      → `bot.telegram.sendMessage()`
+ *   - `bot.editMessageText()`  → flat → positional adapter (see below)
+ *   - `bot.deleteMessage()`    → `bot.telegram.deleteMessage()`
+ *   - `bot.sendChatAction()`   → `bot.telegram.sendChatAction()`
+ *   - `bot.sendDocument()`     → buffer → `{ source, filename }`
+ *   - `bot.sendPhoto()`        → buffer → `{ source, filename }`
+ *   - `bot.answerCallbackQuery(id, opts)` → `answerCbQuery(id, text, opts)`
+ *   - `bot.getFileLink()`      → string (telegraf returns URL object)
+ *   - `bot.onText(regex, fn)`  → `bot.hears(regex, ctx⇒fn(ctx.message, ctx.match))`
+ *   - `bot.on('message', fn)`  → `bot.on('message', ctx⇒fn(ctx.message))`
+ *   - `bot.on('callback_query', fn)` → likewise with ctx.callbackQuery
+ *
+ * Signature drift worth flagging:
+ *
+ *   node-telegram-bot-api editMessageText: (text, { chat_id, message_id, ... })
+ *   telegraf  editMessageText:             (chat_id, message_id, inline_id, text, extra)
+ *   The wrapper unpacks the options bag and routes appropriately.
+ */
+
+export async function createTelegrafBot(token, options = {}) {
+  const { Telegraf } = await import('telegraf');
+
+  const tgraf = new Telegraf(token);
+  const tg = tgraf.telegram;
+
+  // Telegraf handlers throw errors back into the polling loop and stop the
+  // bot by default. node-telegram-bot-api was much more forgiving — it
+  // logged and kept polling. Match that: catch+log so a single bad
+  // handler doesn't take the bot down.
+  tgraf.catch((err, ctx) => {
+    // eslint-disable-next-line no-console
+    console.warn('[telegrafBot] handler error:', err?.message || err, 'updateType:', ctx?.updateType);
+  });
+
+  // Track whether `launch()` has been called — repeated launches throw in
+  // telegraf, and we want stopPolling() to be a safe no-op when not
+  // launched yet.
+  let launched = false;
+
+  const wrapper = {
+    // ─── Internal access for advanced use / tests ──────────────────────
+    _tgraf: tgraf,
+    _tg: tg,
+
+    // ─── Lifecycle ─────────────────────────────────────────────────────
+    async getMe() {
+      return tg.getMe();
+    },
+
+    async stopPolling() {
+      if (!launched) return;
+      try { tgraf.stop(); } catch { /* idempotent */ }
+      launched = false;
+    },
+
+    // ─── Senders ───────────────────────────────────────────────────────
+    async sendMessage(chatId, text, opts = {}) {
+      return tg.sendMessage(chatId, text, opts);
+    },
+
+    async editMessageText(text, opts = {}) {
+      // node-telegram-bot-api's signature is a flat options bag. Telegraf's
+      // is positional. Unpack and route.
+      const { chat_id, message_id, inline_message_id, ...extra } = opts;
+      return tg.editMessageText(chat_id, message_id, inline_message_id, text, extra);
+    },
+
+    async deleteMessage(chatId, messageId) {
+      return tg.deleteMessage(chatId, messageId);
+    },
+
+    async sendChatAction(chatId, action) {
+      return tg.sendChatAction(chatId, action);
+    },
+
+    async sendPhoto(chatId, photo, opts = {}, fileOpts = {}) {
+      // node-telegram-bot-api accepts a Buffer with an optional fileOpts.filename.
+      // Telegraf wants { source: buffer, filename } for buffers.
+      if (Buffer.isBuffer(photo)) {
+        return tg.sendPhoto(chatId, { source: photo, filename: fileOpts.filename }, opts);
+      }
+      return tg.sendPhoto(chatId, photo, opts);
+    },
+
+    async sendDocument(chatId, doc, opts = {}, fileOpts = {}) {
+      if (Buffer.isBuffer(doc)) {
+        return tg.sendDocument(chatId, { source: doc, filename: fileOpts.filename }, opts);
+      }
+      return tg.sendDocument(chatId, doc, opts);
+    },
+
+    async answerCallbackQuery(queryId, opts = {}) {
+      // node-telegram-bot-api: (queryId, { text, show_alert, url, cache_time })
+      // telegraf:               answerCbQuery(queryId, text, extra)
+      const { text, ...extra } = opts || {};
+      return tg.answerCbQuery(queryId, text, extra);
+    },
+
+    async getFileLink(fileId) {
+      // Telegraf returns a URL object; node-telegram-bot-api returned a
+      // plain string. Coerce.
+      const url = await tg.getFileLink(fileId);
+      return typeof url === 'string' ? url : url.toString();
+    },
+
+    // ─── Event subscription ────────────────────────────────────────────
+    onText(regex, handler) {
+      // node-telegram-bot-api fires every matching handler in turn and
+      // passes (msg, regexMatch). Telegraf's `hears` does likewise via
+      // ctx.match.
+      tgraf.hears(regex, async (ctx) => {
+        await handler(ctx.message, ctx.match);
+      });
+    },
+
+    on(event, handler) {
+      if (event === 'message') {
+        tgraf.on('message', async (ctx) => { await handler(ctx.message); });
+        return;
+      }
+      if (event === 'callback_query') {
+        tgraf.on('callback_query', async (ctx) => { await handler(ctx.callbackQuery); });
+        return;
+      }
+      // Forward anything else verbatim — caller is on their own to handle
+      // the ctx vs raw-msg shape difference.
+      tgraf.on(event, async (ctx) => { await handler(ctx.update); });
+    },
+  };
+
+  // Telegraf's launch() is the equivalent of node-telegram-bot-api's
+  // `{ polling: true }` constructor option. It returns a promise that
+  // resolves only when the bot stops — we must NOT await it here or the
+  // wrapper-creation never returns. Fire-and-forget; surface errors via
+  // the central .catch above.
+  if (options.polling !== false) {
+    tgraf.launch().catch((err) => {
+      // eslint-disable-next-line no-console
+      console.warn('[telegrafBot] launch failed:', err?.message || err);
+    });
+    launched = true;
+  }
+
+  return wrapper;
+}
+
+export default createTelegrafBot;

package/src/services/telegramService.js

@@ -308,8 +308,16 @@ class TelegramService {
     this.logger?.info('[TelegramService] Connecting...');
 
     try {
-      const TelegramBot = (await import('node-telegram-bot-api')).default;
-      this.bot = new TelegramBot(botToken, { polling: true });
+      // Migrated from node-telegram-bot-api → telegraf via the local
+      // compat wrapper (src/services/telegrafBot.js). The wrapper
+      // preserves the entire node-telegram-bot-api surface this file is
+      // written against, so the body below — onText, on('message'),
+      // sendMessage, editMessageText, sendChatAction, sendDocument, etc.
+      // — keeps working unchanged. The motivation was 9 CVEs (incl. 2
+      // critical) in the deprecated `request`/`form-data`/`@cypress/request`
+      // chain that node-telegram-bot-api's latest version still hauls in.
+      const { createTelegrafBot } = await import('./telegrafBot.js');
+      this.bot = await createTelegrafBot(botToken, { polling: true });
 
       const me = await this.bot.getMe();
       this.botUsername = me.username || null;

package/web-ui/build/index.html

@@ -6,8 +6,8 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Loxia Autopilot One</title>
     <meta name="description" content="AI Agents System - No-code/vibe-code/companion-coder platform" />
-    <script type="module" crossorigin src="/static/index-CqUnzzzp.js"></script>
-    <link rel="stylesheet" crossorigin href="/static/index-DkBBEGYj.css">
+    <script type="module" crossorigin src="/static/index-XpeihKUG.js"></script>
+    <link rel="stylesheet" crossorigin href="/static/index-BdXFo8aC.css">
   </head>
   <body>
     <div id="root"></div>

package/web-ui/build/static/1c-DWkKesyK.js

@@ -0,0 +1,2 @@
+import{g as f}from"./index-XpeihKUG.js";import{r as s}from"./index-Dt2cTASt.js";function i(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const c=Object.getOwnPropertyDescriptor(e,r);c&&Object.defineProperty(t,r,c.get?c:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var a=s();const p=f(a),l=i({__proto__:null,default:p},[a]);export{l as _};
+//# sourceMappingURL=1c-DWkKesyK.js.map

package/web-ui/build/static/1c-DWkKesyK.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"1c-DWkKesyK.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/web-ui/build/static/abap-DwXHChnN.js

@@ -0,0 +1,2 @@
+import{g as s,r as f}from"./index-XpeihKUG.js";function c(t,n){for(var o=0;o<n.length;o++){const e=n[o];if(typeof e!="string"&&!Array.isArray(e)){for(const r in e)if(r!=="default"&&!(r in t)){const a=Object.getOwnPropertyDescriptor(e,r);a&&Object.defineProperty(t,r,a.get?a:{enumerable:!0,get:()=>e[r]})}}}return Object.freeze(Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}))}var p=f();const i=s(p),b=c({__proto__:null,default:i},[p]);export{b as a};
+//# sourceMappingURL=abap-DwXHChnN.js.map