rex-claude 4.0.0 → 6.0.0

package/dist/gateway-YLP66MCQ.js

@@ -0,0 +1,2273 @@
+#!/usr/bin/env node
+import {
+  __require
+} from "./chunk-PDX44BCA.js";
+
+// src/gateway.ts
+import { homedir } from "os";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync, unlinkSync } from "fs";
+import { join, basename, extname } from "path";
+import { execSync, execFileSync } from "child_process";
+var LOCK_FILE = join(homedir(), ".rex-memory", "gateway.lock");
+function acquireLock() {
+  const pid = process.pid;
+  try {
+    if (existsSync(LOCK_FILE)) {
+      const existing = parseInt(readFileSync(LOCK_FILE, "utf-8").trim(), 10);
+      if (existing && existing !== pid) {
+        try {
+          process.kill(existing, 0);
+          return false;
+        } catch {
+        }
+      }
+    }
+    const dir = join(homedir(), ".rex-memory");
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(LOCK_FILE, String(pid));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function releaseLock() {
+  try {
+    if (existsSync(LOCK_FILE)) {
+      const content = readFileSync(LOCK_FILE, "utf-8").trim();
+      if (parseInt(content, 10) === process.pid) {
+        unlinkSync(LOCK_FILE);
+      }
+    }
+  } catch {
+  }
+}
+var OLLAMA_URL = process.env.OLLAMA_URL || "http://localhost:11434";
+var STATE_FILE = join(homedir(), ".rex-memory", "gateway-state.json");
+var LOG_FILE = join(homedir(), ".claude", "rex-gateway-commands.log");
+var UPLOADS_ROOT = join(homedir(), ".rex-memory", "gateway-uploads");
+var NOTIFS_FILE = join(homedir(), ".rex-memory", "notifications.json");
+var MAX_UPLOADS = 200;
+var UPLOAD_RETENTION_DAYS = Math.max(1, parseInt(process.env.REX_UPLOAD_RETENTION_DAYS || "10", 10) || 10);
+var MAX_MEDIA_MB = Math.max(1, parseInt(process.env.REX_GATEWAY_MAX_MEDIA_MB || "20", 10) || 20);
+var MAX_MEDIA_BYTES = MAX_MEDIA_MB * 1024 * 1024;
+var AUTO_UPLOAD_ANALYZE = process.env.REX_GATEWAY_AUTO_ANALYZE_UPLOADS !== "0";
+var AUTO_UPLOAD_MODE = (process.env.REX_GATEWAY_AUTO_ANALYZE_MODE || "claude").toLowerCase() === "qwen" ? "qwen" : "claude";
+var AUTO_UPLOAD_TASK = process.env.REX_GATEWAY_AUTO_ANALYZE_TASK || "Parse this uploaded file and produce a concise coding-oriented brief with next actions.";
+function loadConfig() {
+  const defaults = {
+    macTailscaleIp: "100.112.24.122",
+    macAddress: "52:f1:cf:b2:a5:32",
+    vpsTailscaleIp: "100.86.167.118",
+    pollTimeout: 30,
+    maxOutputLength: 4e3
+  };
+  try {
+    const settingsPath = join(homedir(), ".claude", "settings.json");
+    const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    const gw = settings.env || {};
+    return {
+      macTailscaleIp: gw.REX_MAC_TAILSCALE_IP || defaults.macTailscaleIp,
+      macAddress: gw.REX_MAC_ADDRESS || defaults.macAddress,
+      vpsTailscaleIp: gw.REX_VPS_TAILSCALE_IP || defaults.vpsTailscaleIp,
+      pollTimeout: parseInt(gw.REX_POLL_TIMEOUT || "") || defaults.pollTimeout,
+      maxOutputLength: parseInt(gw.REX_MAX_OUTPUT || "") || defaults.maxOutputLength
+    };
+  } catch {
+    return defaults;
+  }
+}
+function loadState() {
+  try {
+    if (existsSync(STATE_FILE)) {
+      const parsed = JSON.parse(readFileSync(STATE_FILE, "utf-8"));
+      return {
+        mode: parsed.mode === "claude" ? "claude" : "qwen",
+        localModel: parsed.localModel || null,
+        claudeModel: parsed.claudeModel || null,
+        lastActivity: parsed.lastActivity || (/* @__PURE__ */ new Date()).toISOString(),
+        sessionsCount: typeof parsed.sessionsCount === "number" ? parsed.sessionsCount : 0,
+        uploads: Array.isArray(parsed.uploads) ? parsed.uploads : []
+      };
+    }
+  } catch {
+  }
+  return { mode: "qwen", localModel: null, claudeModel: null, lastActivity: (/* @__PURE__ */ new Date()).toISOString(), sessionsCount: 0, uploads: [] };
+}
+function saveState(state2) {
+  try {
+    const dir = join(homedir(), ".rex-memory");
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(STATE_FILE, JSON.stringify(state2, null, 2));
+  } catch {
+  }
+}
+var state = loadState();
+var config = loadConfig();
+var activeStreamController = null;
+function loadNotifications() {
+  try {
+    return JSON.parse(readFileSync(NOTIFS_FILE, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function saveNotifications(notifs) {
+  try {
+    const dir = join(homedir(), ".rex-memory");
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(NOTIFS_FILE, JSON.stringify(notifs.slice(-500), null, 2));
+  } catch {
+  }
+}
+function addNotification(project, title, message, priority = "normal") {
+  const notifs = loadNotifications();
+  notifs.push({
+    id: `${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    project,
+    title,
+    message,
+    priority,
+    read: false
+  });
+  saveNotifications(notifs);
+}
+function priorityEmoji(p) {
+  return p === "urgent" ? "\u{1F6A8}" : p === "high" ? "\u{1F534}" : p === "low" ? "\u{1F535}" : "\u{1F514}";
+}
+function timeAgo(ts) {
+  const diff = Math.floor((Date.now() - new Date(ts).getTime()) / 1e3);
+  if (diff < 60) return `${diff}s`;
+  if (diff < 3600) return `${Math.floor(diff / 60)}m`;
+  if (diff < 86400) return `${Math.floor(diff / 3600)}h`;
+  return `${Math.floor(diff / 86400)}j`;
+}
+function buildNotifsMessage(project, page) {
+  const allNotifs = loadNotifications();
+  const filtered = project && project !== "all" ? allNotifs.filter((n) => n.project === project) : allNotifs;
+  const sorted = [...filtered].reverse();
+  const PAGE_SIZE = 5;
+  const total = sorted.length;
+  const start = page * PAGE_SIZE;
+  const items = sorted.slice(start, start + PAGE_SIZE);
+  const projects = [...new Set(allNotifs.map((n) => n.project))].sort();
+  const header = project && project !== "all" ? `\u{1F514} *Notifs \u2014 ${project}*` : `\u{1F514} *Notifications* (${total})`;
+  const unread = filtered.filter((n) => !n.read).length;
+  const subtitle = unread > 0 ? `_${unread} non lue(s)_` : "_Tout lu_";
+  if (items.length === 0) {
+    return {
+      text: `${header}
+
+_Aucune notification_`,
+      buttons: [[{ text: "\u25C0\uFE0F Menu", callback_data: "menu" }]]
+    };
+  }
+  const lines = items.map((n) => {
+    const status = n.read ? "\u2705" : priorityEmoji(n.priority);
+    const proj = n.project;
+    const msg = n.message ? `
+   _${n.message.slice(0, 100)}_` : "";
+    return `${status} *[${proj}]* ${n.title} \u2014 _${timeAgo(n.ts)} ago_${msg}`;
+  });
+  const text = `${header}
+${subtitle}
+
+${lines.join("\n\n")}`;
+  const filterBtns = [{ text: project === "all" || !project ? "\u2022 Toutes \u2022" : "Toutes", callback_data: "notif_filter_all" }];
+  for (const p of projects.slice(0, 5)) {
+    filterBtns.push({ text: p === project ? `\u2022 ${p} \u2022` : p, callback_data: `notif_filter_${p}` });
+  }
+  const navBtns = [];
+  if (start > 0) navBtns.push({ text: "\u25C0", callback_data: `notif_page_${page - 1}_${project || "all"}` });
+  if (start + PAGE_SIZE < total) navBtns.push({ text: "\u25B6", callback_data: `notif_page_${page + 1}_${project || "all"}` });
+  if (unread > 0) navBtns.push({ text: "\u2705 Tout lire", callback_data: `notif_markall_${project || "all"}` });
+  const buttons = [filterBtns];
+  if (navBtns.length) buttons.push(navBtns);
+  buttons.push([{ text: "\u25C0\uFE0F Menu", callback_data: "menu" }]);
+  return { text, buttons };
+}
+function ensureUploadsDir() {
+  if (!existsSync(UPLOADS_ROOT)) mkdirSync(UPLOADS_ROOT, { recursive: true });
+}
+function slugFileName(name) {
+  return name.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "upload";
+}
+function rememberUpload(entry) {
+  state.uploads.push(entry);
+  if (state.uploads.length > MAX_UPLOADS) {
+    state.uploads = state.uploads.slice(-MAX_UPLOADS);
+  }
+  saveState(state);
+}
+function recentUploads(chatId, limit = 10) {
+  return state.uploads.filter((u) => u.chatId === chatId).slice(-limit).reverse();
+}
+function latestUpload(chatId) {
+  const list = recentUploads(chatId, 1);
+  return list.length ? list[0] : null;
+}
+function cleanupOldUploads() {
+  ensureUploadsDir();
+  const now = Date.now();
+  const maxAgeMs = UPLOAD_RETENTION_DAYS * 24 * 60 * 60 * 1e3;
+  try {
+    const files = readdirSync(UPLOADS_ROOT);
+    for (const file of files) {
+      const full = join(UPLOADS_ROOT, file);
+      let st;
+      try {
+        st = statSync(full);
+      } catch {
+        continue;
+      }
+      if (!st.isFile()) continue;
+      if (now - st.mtimeMs > maxAgeMs) {
+        try {
+          unlinkSync(full);
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  const existing = /* @__PURE__ */ new Set();
+  try {
+    for (const file of readdirSync(UPLOADS_ROOT)) {
+      existing.add(join(UPLOADS_ROOT, file));
+    }
+  } catch {
+  }
+  state.uploads = state.uploads.filter((u) => existing.has(u.filePath));
+  saveState(state);
+}
+function logCommand(from, command, result) {
+  try {
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const entry = `[${ts}] @${from}: ${command} -> ${result.slice(0, 200)}
+`;
+    const dir = join(homedir(), ".claude");
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(LOG_FILE, entry, { flag: "a" });
+  } catch {
+  }
+}
+var COLORS = {
+  reset: "\x1B[0m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  dim: "\x1B[2m",
+  bold: "\x1B[1m",
+  cyan: "\x1B[36m"
+};
+function getCredentials() {
+  const settingsPath = join(homedir(), ".claude", "settings.json");
+  try {
+    const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    const token2 = settings.env?.REX_TELEGRAM_BOT_TOKEN;
+    const chatId2 = settings.env?.REX_TELEGRAM_CHAT_ID;
+    if (token2 && chatId2) return { token: token2, chatId: chatId2 };
+  } catch {
+  }
+  const token = process.env.REX_TELEGRAM_BOT_TOKEN;
+  const chatId = process.env.REX_TELEGRAM_CHAT_ID;
+  if (token && chatId) return { token, chatId };
+  return null;
+}
+async function tg(token, method, body) {
+  try {
+    const res = await fetch(`https://api.telegram.org/bot${token}/${method}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+    const json = await res.json();
+    if (!json?.ok && method !== "getUpdates") {
+      console.error(`${COLORS.dim}TG ${method} failed: ${json?.description || res.status}${COLORS.reset}`);
+    }
+    return json;
+  } catch (e) {
+    console.error(`${COLORS.dim}TG ${method} error: ${e?.message || e}${COLORS.reset}`);
+    return null;
+  }
+}
+async function send(token, chatId, text, keyboard) {
+  const body = { chat_id: chatId, text, parse_mode: "Markdown" };
+  if (keyboard) {
+    body.reply_markup = { inline_keyboard: keyboard };
+  }
+  return tg(token, "sendMessage", body);
+}
+async function editMessage(token, chatId, messageId, text, keyboard) {
+  const body = { chat_id: chatId, message_id: messageId, text, parse_mode: "Markdown" };
+  if (keyboard) {
+    body.reply_markup = { inline_keyboard: keyboard };
+  }
+  return tg(token, "editMessageText", body);
+}
+async function answerCallback(token, callbackId, text) {
+  return tg(token, "answerCallbackQuery", { callback_query_id: callbackId, text });
+}
+function isAuthorized(msgChatId, authorizedChatId) {
+  return String(msgChatId) === String(authorizedChatId);
+}
+function mainMenu() {
+  return [
+    [
+      { text: "\u{1F4CA} Status", callback_data: "status" },
+      { text: "\u{1FA7A} Doctor", callback_data: "doctor" },
+      { text: "\u{1F50D} Memory", callback_data: "memory_menu" }
+    ],
+    [
+      { text: "\u{1F5A5} Git", callback_data: "git" },
+      { text: "\u26A1 Optimize", callback_data: "optimize" },
+      { text: "\u{1F4E5} Ingest", callback_data: "ingest" }
+    ],
+    [
+      { text: `\u{1F916} Mode: ${state.mode === "qwen" ? "Qwen (local)" : "Claude"}`, callback_data: "switch_mode" },
+      { text: "\u{1F9F9} Prune", callback_data: "prune" }
+    ],
+    [
+      { text: "\u{1F4A4} Wake Mac", callback_data: "wake_mac" },
+      { text: "\u{1F50C} Mac Status", callback_data: "mac_status" }
+    ],
+    [
+      { text: "\u{1F4CB} Sessions", callback_data: "sessions" },
+      { text: "\u{1F4DD} Logs", callback_data: "logs" },
+      { text: "\u{1F4CE} Files", callback_data: "files_menu" }
+    ],
+    [
+      { text: "\u{1F514} Notifs", callback_data: "notifs" },
+      { text: "\u{1F9ED} Advanced", callback_data: "advanced_menu" }
+    ]
+  ];
+}
+function backButton() {
+  return [[{ text: "\u25C0\uFE0F Menu", callback_data: "menu" }]];
+}
+function claudeMenu() {
+  return [
+    [
+      { text: "\u{1F4AC} New Session", callback_data: "claude_new" },
+      { text: "\u{1F4C2} Continue Last", callback_data: "claude_continue" }
+    ],
+    [
+      { text: "\u{1F4CB} List Sessions", callback_data: "claude_sessions" },
+      { text: "\u{1F504} Resume #", callback_data: "claude_resume" }
+    ],
+    [{ text: "\u25C0\uFE0F Menu", callback_data: "menu" }]
+  ];
+}
+function advancedMenu() {
+  return [
+    [
+      { text: "\u{1F9E0} Agents", callback_data: "agents_menu" },
+      { text: "\u{1F50C} MCP", callback_data: "mcp_menu" }
+    ],
+    [
+      { text: "\u{1F9EA} Audit", callback_data: "audit" },
+      { text: "\u{1F4DD} Logs", callback_data: "logs" }
+    ],
+    [{ text: "\u{1F39B} Mod\xE8les", callback_data: "models_menu" }],
+    [{ text: "\u25C0\uFE0F Menu", callback_data: "menu" }]
+  ];
+}
+function modelsMenu() {
+  const local = state.localModel || "auto";
+  const claude = state.claudeModel || "sonnet-4-6";
+  return [
+    [{ text: `\u{1F9E0} Local: ${local}`, callback_data: "models_local_menu" }],
+    [
+      { text: `qwen2.5:1.5b`, callback_data: "set_local_qwen2.5:1.5b" },
+      { text: `qwen3.5:4b`, callback_data: "set_local_qwen3.5:4b" },
+      { text: `qwen3.5:9b`, callback_data: "set_local_qwen3.5:9b" },
+      { text: `auto`, callback_data: "set_local_auto" }
+    ],
+    [{ text: `\u{1F916} Claude: ${claude}`, callback_data: "models_claude_menu" }],
+    [
+      { text: `haiku-4-5`, callback_data: "set_claude_claude-haiku-4-5-20251001" },
+      { text: `sonnet-4-6`, callback_data: "set_claude_claude-sonnet-4-6" },
+      { text: `opus-4-6`, callback_data: "set_claude_claude-opus-4-6" }
+    ],
+    [{ text: "\u25C0\uFE0F Advanced", callback_data: "advanced_menu" }]
+  ];
+}
+function agentsMenu() {
+  return [
+    [
+      { text: "\u{1F504} Refresh", callback_data: "agents_menu" },
+      { text: "\u{1F4E6} Profiles", callback_data: "agents_profiles" }
+    ],
+    [
+      { text: "\u2795 Read", callback_data: "agents_create_read" },
+      { text: "\u2795 Review", callback_data: "agents_create_review" }
+    ],
+    [
+      { text: "\u25B6\uFE0F Start all", callback_data: "agents_start_all" },
+      { text: "\u23F9 Stop all", callback_data: "agents_stop_all" }
+    ],
+    [{ text: "\u25C0\uFE0F Advanced", callback_data: "advanced_menu" }]
+  ];
+}
+function mcpMenu() {
+  return [
+    [
+      { text: "\u{1F504} Refresh", callback_data: "mcp_menu" },
+      { text: "\u{1F501} Sync Claude", callback_data: "mcp_sync" }
+    ],
+    [
+      { text: "\u2705 Check enabled", callback_data: "mcp_check_enabled" },
+      { text: "\u{1F4E4} Export", callback_data: "mcp_export" }
+    ],
+    [{ text: "\u25C0\uFE0F Advanced", callback_data: "advanced_menu" }]
+  ];
+}
+function filesMenu() {
+  return [
+    [
+      { text: "\u{1F195} Last file", callback_data: "file_last" },
+      { text: "\u{1F4DA} List", callback_data: "files_list" }
+    ],
+    [
+      { text: "\u{1F916} Analyze Claude", callback_data: "file_analyze_claude" },
+      { text: "\u{1F9E0} Analyze Qwen", callback_data: "file_analyze_qwen" }
+    ],
+    [{ text: "\u25C0\uFE0F Menu", callback_data: "menu" }]
+  ];
+}
+function run(cmd, timeout = 3e4) {
+  try {
+    return execSync(cmd, { timeout, encoding: "utf-8" }).trim();
+  } catch (e) {
+    return e.stderr?.trim() || e.message || "Command failed";
+  }
+}
+function runRex(args, timeout = 3e4) {
+  try {
+    return execFileSync("rex", args, { timeout, encoding: "utf-8" }).trim();
+  } catch (e) {
+    const stderr = e?.stderr?.toString?.().trim?.() || "";
+    const stdout = e?.stdout?.toString?.().trim?.() || "";
+    return stderr || stdout || e.message || "Command failed";
+  }
+}
+function runRexJson(args, timeout = 3e4) {
+  const raw = strip(runRex(args, timeout)).trim();
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function strip(text) {
+  return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function truncate(text, max) {
+  const limit = max || config.maxOutputLength;
+  if (text.length <= limit) return text;
+  return text.slice(0, limit) + "\n\n... (truncated)";
+}
+function sanitizeToken(input) {
+  const value = input.trim();
+  if (!value) return null;
+  if (!/^[a-zA-Z0-9._:-]+$/.test(value)) return null;
+  return value;
+}
+function loadAgents() {
+  const parsed = runRexJson(["agents", "list", "--json"], 15e3);
+  const agents = parsed?.agents;
+  if (!Array.isArray(agents)) return [];
+  return agents;
+}
+function loadMcpServers() {
+  const parsed = runRexJson(["mcp", "list", "--json"], 15e3);
+  const servers = parsed?.servers;
+  if (!Array.isArray(servers)) return [];
+  return servers;
+}
+function renderAgentsSummary(max = 8) {
+  const agents = loadAgents();
+  if (agents.length === 0) {
+    return [
+      "\u{1F9E0} *Agents*",
+      "No agents configured.",
+      "",
+      "Create quickly:",
+      "`/agent_create read`",
+      "`/agent_create code-review`"
+    ].join("\n");
+  }
+  const lines = agents.slice(0, max).map((a) => {
+    const icon = a.running ? "\u{1F7E2}" : a.enabled ? "\u{1F7E1}" : "\u26AB\uFE0F";
+    return `${icon} \`${a.id}\` \u2022 ${a.profile} \u2022 ${a.running ? "running" : "stopped"}`;
+  });
+  const more = agents.length > max ? `
+... +${agents.length - max} more` : "";
+  return [
+    `\u{1F9E0} *Agents* (${agents.length})`,
+    "",
+    ...lines,
+    more,
+    "",
+    "Commands:",
+    "`/agent_start <id>` `/agent_stop <id>` `/agent_run <id>`"
+  ].filter(Boolean).join("\n");
+}
+function renderMcpSummary(max = 8) {
+  const servers = loadMcpServers();
+  if (servers.length === 0) {
+    return [
+      "\u{1F50C} *MCP Registry*",
+      "No servers configured.",
+      "",
+      "Add one:",
+      "`rex mcp add <name> --command <cmd>`"
+    ].join("\n");
+  }
+  const lines = servers.slice(0, max).map((s) => {
+    const icon = s.enabled ? "\u{1F7E2}" : "\u26AB\uFE0F";
+    const target = s.type === "stdio" ? `${s.command || "n/a"} ${(s.args || []).join(" ")}`.trim() : s.url || "n/a";
+    return `${icon} \`${s.id}\` \u2022 ${s.type} \u2022 ${target}`;
+  });
+  const more = servers.length > max ? `
+... +${servers.length - max} more` : "";
+  return [
+    `\u{1F50C} *MCP Registry* (${servers.length})`,
+    "",
+    ...lines,
+    more,
+    "",
+    "Commands:",
+    "`/mcp_check <id>` `/mcp_sync`"
+  ].filter(Boolean).join("\n");
+}
+function pickAttachment(msg) {
+  const caption = String(msg?.caption || "").trim();
+  if (msg?.document?.file_id) {
+    return {
+      fileId: String(msg.document.file_id),
+      kind: "document",
+      fileName: String(msg.document.file_name || `document-${Date.now()}`),
+      mimeType: String(msg.document.mime_type || "application/octet-stream"),
+      size: Number(msg.document.file_size || 0),
+      caption
+    };
+  }
+  if (Array.isArray(msg?.photo) && msg.photo.length > 0) {
+    const sorted = [...msg.photo].sort((a, b) => Number(a?.file_size || 0) - Number(b?.file_size || 0));
+    const best = sorted[sorted.length - 1] || {};
+    return {
+      fileId: String(best.file_id),
+      kind: "photo",
+      fileName: `photo-${Date.now()}.jpg`,
+      mimeType: "image/jpeg",
+      size: Number(best.file_size || 0),
+      caption
+    };
+  }
+  if (msg?.audio?.file_id) {
+    const ext = extname(String(msg.audio.file_name || "")).replace(".", "") || "mp3";
+    return {
+      fileId: String(msg.audio.file_id),
+      kind: "audio",
+      fileName: String(msg.audio.file_name || `audio-${Date.now()}.${ext}`),
+      mimeType: String(msg.audio.mime_type || "audio/mpeg"),
+      size: Number(msg.audio.file_size || 0),
+      caption
+    };
+  }
+  if (msg?.voice?.file_id) {
+    return {
+      fileId: String(msg.voice.file_id),
+      kind: "voice",
+      fileName: `voice-${Date.now()}.ogg`,
+      mimeType: String(msg.voice.mime_type || "audio/ogg"),
+      size: Number(msg.voice.file_size || 0),
+      caption
+    };
+  }
+  if (msg?.video?.file_id) {
+    const ext = extname(String(msg.video.file_name || "")).replace(".", "") || "mp4";
+    return {
+      fileId: String(msg.video.file_id),
+      kind: "video",
+      fileName: String(msg.video.file_name || `video-${Date.now()}.${ext}`),
+      mimeType: String(msg.video.mime_type || "video/mp4"),
+      size: Number(msg.video.file_size || 0),
+      caption
+    };
+  }
+  return null;
+}
+async function downloadTelegramFile(token, fileId, fileName) {
+  const info = await tg(token, "getFile", { file_id: fileId });
+  const tgPath = info?.result?.file_path;
+  if (!tgPath) throw new Error("Telegram getFile failed");
+  const res = await fetch(`https://api.telegram.org/file/bot${token}/${tgPath}`);
+  if (!res.ok) throw new Error(`Download failed (${res.status})`);
+  const ab = await res.arrayBuffer();
+  const buffer = Buffer.from(ab);
+  if (buffer.byteLength > MAX_MEDIA_BYTES) {
+    throw new Error(`File too large (${Math.round(buffer.byteLength / 1024 / 1024)}MB > ${MAX_MEDIA_MB}MB)`);
+  }
+  ensureUploadsDir();
+  const base = slugFileName(fileName || basename(tgPath));
+  const ext = extname(base) || extname(tgPath) || "";
+  const stem = ext ? base.replace(new RegExp(`${ext.replace(".", "\\.")}$`), "") : base;
+  const finalName = `${stem}-${Date.now()}${ext}`;
+  const full = join(UPLOADS_ROOT, finalName);
+  writeFileSync(full, buffer);
+  return { path: full, size: buffer.byteLength };
+}
+function commandExists(cmd) {
+  return run(`command -v ${cmd} >/dev/null 2>&1 && echo ok`).includes("ok");
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function extractFilePreview(upload, maxChars = 9e3) {
+  const path = upload.filePath;
+  const qPath = shellQuote(path);
+  const name = upload.fileName.toLowerCase();
+  const mime = upload.mimeType.toLowerCase();
+  if (mime.includes("pdf") || name.endsWith(".pdf")) {
+    if (commandExists("pdftotext")) {
+      const out = run(`pdftotext -layout ${qPath} - 2>/dev/null | head -c ${maxChars}`, 3e4);
+      if (out.trim()) return out.trim();
+    }
+    if (commandExists("python3")) {
+      const py = run(
+        `python3 -c "import sys
+p=sys.argv[1]
+t=''
+try:
+ import pypdf
+ r=pypdf.PdfReader(p)
+ t='\\n'.join([(pg.extract_text() or '') for pg in r.pages])
+except Exception:
+ try:
+  import PyPDF2
+  r=PyPDF2.PdfReader(p)
+  t='\\n'.join([(pg.extract_text() or '') for pg in r.pages])
+ except Exception:
+  pass
+print(t[:${maxChars}])" ${qPath}`,
+        45e3
+      );
+      if (py.trim()) return py.trim();
+    }
+    const raw = run(`strings ${qPath} 2>/dev/null | head -c ${maxChars}`, 1e4);
+    return raw.trim();
+  }
+  const textLike = mime.startsWith("text/") || name.endsWith(".md") || name.endsWith(".txt") || name.endsWith(".json") || name.endsWith(".ts") || name.endsWith(".tsx") || name.endsWith(".js") || name.endsWith(".yml") || name.endsWith(".yaml") || name.endsWith(".toml") || name.endsWith(".csv");
+  if (textLike) {
+    const out = run(`head -c ${maxChars} ${qPath}`, 1e4);
+    return out.trim();
+  }
+  if (upload.kind === "photo" && commandExists("tesseract")) {
+    const out = run(`tesseract ${qPath} stdout 2>/dev/null | head -c ${maxChars}`, 3e4);
+    return out.trim();
+  }
+  return "";
+}
+async function analyzeUpload(upload, task, mode) {
+  const preview = extractFilePreview(upload);
+  const activeMode = mode || state.mode;
+  const prompt = [
+    "You are processing a file uploaded from Telegram to REX.",
+    `File path: ${upload.filePath}`,
+    `File name: ${upload.fileName}`,
+    `Kind: ${upload.kind}`,
+    `Mime type: ${upload.mimeType}`,
+    `Size: ${upload.size} bytes`,
+    `User task: ${task}`,
+    "",
+    preview ? `Extracted preview:\\n${preview}` : "No text preview available from this file type. Explain what can be done next.",
+    "",
+    "Return:",
+    "1) concise summary",
+    "2) useful action plan for coding/ops"
+  ].join("\n");
+  if (activeMode === "claude") {
+    return askClaude(prompt);
+  }
+  return askLLM(prompt);
+}
+function renderUpload(u) {
+  const mb = (u.size / 1024 / 1024).toFixed(2);
+  return [
+    `id: ${u.id}`,
+    `type: ${u.kind}`,
+    `name: ${u.fileName}`,
+    `mime: ${u.mimeType}`,
+    `size: ${mb} MB`,
+    `path: ${u.filePath}`,
+    `time: ${u.uploadedAt}`
+  ].join("\n");
+}
+function renderUploadsList(chatId) {
+  const uploads = recentUploads(chatId, 10);
+  if (uploads.length === 0) {
+    return "\u{1F4CE} *Files*\nNo uploads yet.\n\nSend an image, PDF, audio, or document to this bot.";
+  }
+  const lines = uploads.map((u) => {
+    const mb = (u.size / 1024 / 1024).toFixed(2);
+    return `\u2022 \`${u.id}\` ${u.kind} ${u.fileName} (${mb}MB)`;
+  });
+  return ["\u{1F4CE} *Recent uploads*", "", ...lines, "", "Auto-analysis is ON. Optional override: `/file_analyze <prompt>`"].join("\n");
+}
+async function handleAttachment(token, chatId, msg, from) {
+  const attachment = pickAttachment(msg);
+  if (!attachment) return "";
+  if (attachment.size > MAX_MEDIA_BYTES) {
+    return `\u26A0\uFE0F File too large (${Math.round(attachment.size / 1024 / 1024)}MB). Limit is ${MAX_MEDIA_MB}MB.`;
+  }
+  const dl = await downloadTelegramFile(token, attachment.fileId, attachment.fileName);
+  const entry = {
+    id: `up-${Date.now().toString(36)}`,
+    chatId,
+    from,
+    kind: attachment.kind,
+    filePath: dl.path,
+    fileName: attachment.fileName,
+    mimeType: attachment.mimeType,
+    size: dl.size,
+    caption: attachment.caption || void 0,
+    uploadedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  rememberUpload(entry);
+  let text = `\u{1F4CE} *File received*
+\`\`\`
+${renderUpload(entry)}
+\`\`\``;
+  if (AUTO_UPLOAD_ANALYZE) {
+    const mode = AUTO_UPLOAD_MODE;
+    const task = attachment.caption && attachment.caption.length > 2 ? attachment.caption : AUTO_UPLOAD_TASK;
+    try {
+      const out = await analyzeUpload(entry, task, mode);
+      text += `
+
+${mode === "claude" ? "\u{1F916}" : "\u{1F9E0}"} *Auto analysis* (${mode})
+${truncate(out, 2800)}`;
+    } catch (e) {
+      const err = e instanceof Error ? e.message : String(e);
+      text += `
+
+\u26A0\uFE0F Auto analysis failed: ${err}`;
+    }
+  } else {
+    text += "\n\nAuto analysis disabled. Use `/file_analyze <prompt>`.";
+  }
+  logCommand(from, `[upload] ${attachment.kind}:${attachment.fileName}`, "saved");
+  return text;
+}
+async function wakeMac() {
+  try {
+    const mac = config.macAddress.replace(/:/g, "");
+    const pyCmd = `python3 -c "
+import socket, struct
+mac = bytes.fromhex('${mac}')
+pkt = b'\\xff'*6 + mac*16
+s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+s.sendto(pkt, ('255.255.255.255', 9))
+s.sendto(pkt, ('${config.macTailscaleIp}', 9))
+s.close()
+print('Magic packet sent')
+"`;
+    const out = run(pyCmd, 5e3);
+    if (out.includes("Magic packet sent")) return "\u2705 Magic packet sent to Mac";
+  } catch {
+  }
+  try {
+    const ping = run(`ping -c 1 -W 2 ${config.macTailscaleIp} 2>/dev/null`, 5e3);
+    if (ping.includes("1 packets received") || ping.includes("1 received")) {
+      return "\u2705 Mac is already awake (responds to ping)";
+    }
+  } catch {
+  }
+  return "\u26A0\uFE0F Magic packet sent \u2014 Mac may take 30s to wake";
+}
+async function checkMacStatus() {
+  try {
+    const ping = run(`ping -c 1 -W 3 ${config.macTailscaleIp} 2>/dev/null`, 5e3);
+    const online = ping.includes("1 packets received") || ping.includes("1 received");
+    if (online) {
+      const ts = run("tailscale status 2>/dev/null | head -5", 5e3);
+      return { online: true, details: ts };
+    }
+    return { online: false, details: "Mac not responding to ping" };
+  } catch {
+    return { online: false, details: "Ping failed" };
+  }
+}
+async function askLLM(prompt) {
+  if (state.mode === "qwen") {
+    return askQwen(prompt);
+  } else {
+    return askClaude(prompt);
+  }
+}
+async function askQwen(prompt) {
+  try {
+    const check = await fetch(`${OLLAMA_URL}/api/tags`);
+    if (!check.ok) return "\u26A0\uFE0F Ollama not running. /wake to wake Mac first.";
+  } catch {
+    return "\u26A0\uFE0F Ollama not running. Wake Mac first.";
+  }
+  const out = runRex(["llm", prompt], 6e4);
+  if (!out || out.includes("rex-claude") || out.includes("Commands:")) {
+    return "\u26A0\uFE0F LLM returned no useful response";
+  }
+  return truncate(out);
+}
+async function askQwenStream(token, chatId, prompt) {
+  let model = state.localModel || "qwen3.5:4b";
+  if (!state.localModel) {
+    try {
+      const tags = await fetch(`${OLLAMA_URL}/api/tags`);
+      if (!tags.ok) return "\u26A0\uFE0F Ollama not running.";
+      const data = await tags.json();
+      const names = data.models.map((m) => m.name);
+      for (const pref of ["qwen3.5:9b", "qwen3.5:4b", "qwen2.5:1.5b"]) {
+        const base = pref.split(":")[0];
+        const match = names.find((n) => n.includes(base));
+        if (match) {
+          model = match;
+          break;
+        }
+      }
+    } catch {
+      return "\u26A0\uFE0F Ollama not running.";
+    }
+  } else {
+    try {
+      const check = await fetch(`${OLLAMA_URL}/api/tags`);
+      if (!check.ok) return "\u26A0\uFE0F Ollama not running.";
+    } catch {
+      return "\u26A0\uFE0F Ollama not running.";
+    }
+  }
+  const initMsg = await tg(token, "sendMessage", {
+    chat_id: chatId,
+    text: "\u{1F9E0} _Qwen thinking..._",
+    parse_mode: "Markdown"
+  });
+  const msgId = initMsg?.result?.message_id;
+  if (!msgId) return "\u26A0\uFE0F Failed to send initial message";
+  const controller = new AbortController();
+  activeStreamController = controller;
+  const streamTimeout = setTimeout(() => controller.abort(), 12e4);
+  const res = await fetch(`${OLLAMA_URL}/api/chat`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model,
+      messages: [{ role: "user", content: prompt }],
+      stream: true,
+      think: false
+    }),
+    signal: controller.signal
+  });
+  if (!res.ok || !res.body) {
+    await editMessage(token, chatId, msgId, "\u26A0\uFE0F Ollama stream failed");
+    return "\u26A0\uFE0F Ollama stream failed";
+  }
+  function stripThinkBlocks(raw) {
+    let clean = raw.replace(/<think>[\s\S]*?<\/think>/g, "");
+    clean = clean.replace(/<think>[\s\S]*$/, "");
+    return clean.trim();
+  }
+  let rawFull = "";
+  let lastEdit = 0;
+  let wasThinking = false;
+  const EDIT_INTERVAL = 800;
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const chunk = JSON.parse(line);
+          if (chunk.message?.content) {
+            rawFull += chunk.message.content;
+          }
+        } catch {
+        }
+      }
+      const now = Date.now();
+      if (now - lastEdit > EDIT_INTERVAL) {
+        const visible2 = stripThinkBlocks(rawFull);
+        const isThinking = rawFull.includes("<think>") && !rawFull.includes("</think>");
+        if (isThinking && !wasThinking) {
+          try {
+            await editMessage(token, chatId, msgId, "\u{1F9E0} _R\xE9flexion en cours..._");
+          } catch {
+          }
+          wasThinking = true;
+        } else if (visible2.length > 0) {
+          wasThinking = false;
+          const display = visible2.length > 4e3 ? visible2.slice(-4e3) : visible2;
+          try {
+            await editMessage(token, chatId, msgId, `\u{1F9E0} ${display}`);
+          } catch {
+          }
+        }
+        lastEdit = now;
+      }
+    }
+    if (buffer.trim()) {
+      try {
+        const chunk = JSON.parse(buffer);
+        if (chunk.message?.content) rawFull += chunk.message.content;
+      } catch {
+      }
+    }
+  } catch {
+  } finally {
+    clearTimeout(streamTimeout);
+    activeStreamController = null;
+  }
+  const visible = stripThinkBlocks(rawFull);
+  const finalText = truncate(visible || rawFull || "\u26A0\uFE0F Empty response");
+  try {
+    await editMessage(token, chatId, msgId, `\u{1F9E0} ${finalText}`, [
+      [
+        { text: "Mode: qwen", callback_data: "switch_mode" },
+        { text: "\u25C0\uFE0F Menu", callback_data: "menu" }
+      ]
+    ]);
+  } catch {
+  }
+  return finalText;
+}
+function claudeEnv() {
+  const env = { ...process.env };
+  delete env.CLAUDECODE;
+  return env;
+}
+async function runClaudeAsync(args, timeoutMs, onProgress) {
+  const { spawn } = __require("child_process");
+  const modelArgs = state.claudeModel ? ["--model", state.claudeModel, ...args] : args;
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+    let child;
+    try {
+      child = spawn("claude", modelArgs, { env: claudeEnv() });
+    } catch (e) {
+      resolve({ stdout: "", stderr: e?.message || "spawn failed" });
+      return;
+    }
+    child.stdout?.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    let frameIdx = 0;
+    const timer = onProgress ? setInterval(() => {
+      if (!settled) onProgress(frameIdx++).catch(() => {
+      });
+    }, 3e3) : null;
+    const done = () => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearInterval(timer);
+      resolve({ stdout: stdout.trim(), stderr: stderr.trim() });
+    };
+    child.on("close", done);
+    child.on("error", (e) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearInterval(timer);
+      const code = e.code;
+      resolve({ stdout: "", stderr: code === "ENOENT" ? "claude CLI not found in PATH" : e.message });
+    });
+    const to = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        if (timer) clearInterval(timer);
+        try {
+          child.kill();
+        } catch {
+        }
+        resolve({ stdout: "", stderr: `Claude CLI timed out after ${Math.round(timeoutMs / 1e3)}s` });
+      }
+    }, timeoutMs);
+    child.on("close", () => clearTimeout(to));
+  });
+}
+function parseClaudeError(stderr) {
+  const s = stderr.toLowerCase();
+  if (s.includes("nested session") || s.includes("claudecode") || s.includes("cannot be launched inside")) {
+    return "\u26A0\uFE0F Claude: nested session conflict \u2014 restart gateway outside Claude Code";
+  }
+  if (s.includes("not logged in") || s.includes("authenticate") || s.includes("unauthorized") || s.includes("401")) {
+    return "\u26A0\uFE0F Claude: not authenticated \u2014 run `claude auth login`";
+  }
+  if (s.includes("rate limit") || s.includes("429") || s.includes("quota exceeded")) {
+    return "\u26A0\uFE0F Claude: rate limit \u2014 r\xE9essaie dans quelques minutes";
+  }
+  if (s.includes("timed out")) {
+    return "\u26A0\uFE0F Claude: timeout \u2014 requ\xEAte trop longue";
+  }
+  if (s.includes("not found in path") || s.includes("enoent")) {
+    return "\u26A0\uFE0F Claude CLI introuvable \u2014 v\xE9rifie l'installation";
+  }
+  if (s.includes("network") || s.includes("econnrefused") || s.includes("fetch failed")) {
+    return "\u26A0\uFE0F Claude: erreur r\xE9seau \u2014 v\xE9rifie la connexion";
+  }
+  return `\u26A0\uFE0F Claude: ${stderr.slice(0, 400)}`;
+}
+async function askClaude(prompt) {
+  const { stdout, stderr } = await runClaudeAsync(["-p", prompt], 12e4);
+  if (stdout) return truncate(stdout);
+  if (stderr) {
+    console.error(`Claude CLI stderr: ${stderr.slice(0, 300)}`);
+    return parseClaudeError(stderr);
+  }
+  return "\u26A0\uFE0F Claude CLI returned empty";
+}
+async function askClaudeWithProgress(token, chatId, msgId, args) {
+  const frames = [
+    "\u{1F916} _Claude r\xE9fl\xE9chit..._",
+    "\u{1F916} _Claude r\xE9fl\xE9chit.._",
+    "\u{1F916} _Claude r\xE9fl\xE9chit._",
+    "\u{1F916} _Claude r\xE9fl\xE9chit..._"
+  ];
+  const { stdout, stderr } = await runClaudeAsync(args, 18e4, async (idx) => {
+    try {
+      await editMessage(token, chatId, msgId, frames[idx % frames.length]);
+    } catch {
+    }
+  });
+  if (stdout) return truncate(stdout);
+  if (stderr) {
+    console.error(`Claude session stderr: ${stderr.slice(0, 300)}`);
+    return parseClaudeError(stderr);
+  }
+  return "\u26A0\uFE0F No response from Claude";
+}
+async function claudeSession(token, chatId, msgId, prompt, resume) {
+  const args = resume ? ["--continue", "-p", prompt] : ["-p", prompt];
+  const result = await askClaudeWithProgress(token, chatId, msgId, args);
+  if (!result.startsWith("\u26A0\uFE0F")) {
+    state.sessionsCount++;
+    saveState(state);
+  }
+  return result;
+}
+async function handleCallback(token, chatId, messageId, callbackId, data, from) {
+  await answerCallback(token, callbackId);
+  logCommand(from, `[btn] ${data}`, "ok");
+  state = loadState();
+  switch (data) {
+    case "menu":
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        "\u{1F996} *REX Gateway v3*\nChoisis une action :",
+        mainMenu()
+      );
+      break;
+    case "status": {
+      const out = strip(run("rex status"));
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u{1F4CA} *Status*
+${out}`,
+        backButton()
+      );
+      break;
+    }
+    case "doctor": {
+      await editMessage(token, chatId, messageId, "\u{1FA7A} _Running diagnostics..._");
+      const out = truncate(strip(run("rex doctor")));
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u{1FA7A} *Doctor*
+\`\`\`
+${out}
+\`\`\``,
+        backButton()
+      );
+      break;
+    }
+    case "git": {
+      const branch = run('git branch --show-current 2>/dev/null || echo "n/a"');
+      const status = run("git status --short 2>/dev/null | head -15");
+      const lastCommit = run('git log -1 --format="%s" 2>/dev/null || echo "n/a"');
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u{1F5A5} *Git*
+Branch: \`${branch}\`
+Last: ${lastCommit}
+\`\`\`
+${status || "Clean"}
+\`\`\``,
+        backButton()
+      );
+      break;
+    }
+    case "optimize": {
+      await editMessage(token, chatId, messageId, "\u26A1 _Analyzing CLAUDE.md..._");
+      const out = truncate(strip(run("rex optimize", 6e4)), 3500);
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u26A1 *Optimize*
+\`\`\`
+${out}
+\`\`\``,
+        [[
+          { text: "\u{1F527} Apply", callback_data: "optimize_apply" },
+          { text: "\u25C0\uFE0F Menu", callback_data: "menu" }
+        ]]
+      );
+      break;
+    }
+    case "optimize_apply": {
+      await editMessage(token, chatId, messageId, "\u{1F527} _Applying optimizations..._");
+      const out = truncate(strip(run("rex optimize --apply", 12e4)), 3500);
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u{1F527} *Applied*
+\`\`\`
+${out}
+\`\`\``,
+        backButton()
+      );
+      break;
+    }
+    case "ingest": {
+      await editMessage(token, chatId, messageId, "\u{1F4E5} _Ingesting sessions..._");
+      const out = truncate(strip(run("rex ingest", 12e4)), 3500);
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u{1F4E5} *Ingest*
+\`\`\`
+${out}
+\`\`\``,
+        backButton()
+      );
+      break;
+    }
+    case "prune": {
+      await editMessage(token, chatId, messageId, "\u{1F9F9} _Pruning old memories..._");
+      const out = truncate(strip(run("rex prune", 6e4)));
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u{1F9F9} *Prune*
+\`\`\`
+${out}
+\`\`\``,
+        backButton()
+      );
+      break;
+    }
+    case "memory_menu":
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        "\u{1F50D} *Memory*\nEnvoie ta recherche en texte ou :",
+        [
+          [
+            { text: "\u{1F4E5} Ingest Now", callback_data: "ingest" },
+            { text: "\u{1F9F9} Prune", callback_data: "prune" }
+          ],
+          [
+            { text: "\u{1F4CA} Stats", callback_data: "memory_stats" },
+            { text: "\u25C0\uFE0F Menu", callback_data: "menu" }
+          ]
+        ]
+      );
+      break;
+    case "memory_stats": {
+      const out = run("rex prune --stats", 1e4);
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u{1F4CA} *Memory Stats*
+\`\`\`
+${strip(out)}
+\`\`\``,
+        backButton()
+      );
+      break;
+    }
+    case "switch_mode":
+      state.mode = state.mode === "qwen" ? "claude" : "qwen";
+      state.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+      saveState(state);
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u{1F916} Mode switched to *${state.mode === "qwen" ? "Qwen (local LLM)" : "Claude (CLI)"}*`,
+        mainMenu()
+      );
+      break;
+    case "wake_mac": {
+      await editMessage(token, chatId, messageId, "\u{1F4A4} _Sending wake signal..._");
+      const result = await wakeMac();
+      await new Promise((r) => setTimeout(r, 3e3));
+      const status = await checkMacStatus();
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u{1F4A4} *Wake Mac*
+${result}
+
+\u{1F50C} ${status.online ? "\u{1F7E2} Online" : "\u{1F534} Offline"}
+\`${status.details}\``,
+        [[
+          { text: "\u{1F504} Check Again", callback_data: "mac_status" },
+          { text: "\u25C0\uFE0F Menu", callback_data: "menu" }
+        ]]
+      );
+      break;
+    }
+    case "mac_status": {
+      await editMessage(token, chatId, messageId, "\u{1F50C} _Checking Mac..._");
+      const status = await checkMacStatus();
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u{1F50C} *Mac Status*
+${status.online ? "\u{1F7E2} Online" : "\u{1F534} Offline"}
+\`\`\`
+${status.details}
+\`\`\``,
+        [[
+          { text: "\u{1F4A4} Wake", callback_data: "wake_mac" },
+          { text: "\u{1F504} Refresh", callback_data: "mac_status" },
+          { text: "\u25C0\uFE0F Menu", callback_data: "menu" }
+        ]]
+      );
+      break;
+    }
+    case "sessions": {
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u{1F4CB} *Claude Sessions*
+Mode: *${state.mode}*
+Sessions: ${state.sessionsCount}
+Last: ${state.lastActivity}`,
+        claudeMenu()
+      );
+      break;
+    }
+    case "claude_new":
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        "\u{1F4AC} *New Claude Session*\nEnvoie ta question/tache en texte. Claude va la traiter en mode session.",
+        backButton()
+      );
+      break;
+    case "claude_continue": {
+      await editMessage(token, chatId, messageId, "\u{1F4C2} _Continuing last session..._");
+      const out = await claudeSession(token, chatId, messageId, "Continue the previous task. What was I working on?", true);
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u{1F4C2} *Session Continued*
+${out}`,
+        [[
+          { text: "\u{1F4AC} Reply", callback_data: "claude_new" },
+          { text: "\u25C0\uFE0F Menu", callback_data: "menu" }
+        ]]
+      );
+      break;
+    }
+    case "claude_sessions": {
+      const sessions = run("ls -lt ~/.claude/projects/ 2>/dev/null | head -10");
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u{1F4CB} *Recent Sessions*
+\`\`\`
+${strip(sessions)}
+\`\`\``,
+        claudeMenu()
+      );
+      break;
+    }
+    case "claude_resume": {
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        "\u{1F504} *Resume Session*\nEnvoie le chemin du projet pour reprendre la session.",
+        backButton()
+      );
+      break;
+    }
+    case "advanced_menu":
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        "\u{1F9ED} *Advanced*\nAgents autonomes, registry MCP et audit.",
+        advancedMenu()
+      );
+      break;
+    case "audit": {
+      await editMessage(token, chatId, messageId, "\u{1F9EA} _Running strict audit..._");
+      const out = truncate(strip(run("rex audit --strict", 12e4)), 3500);
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u{1F9EA} *Audit*
+\`\`\`
+${out}
+\`\`\``,
+        advancedMenu()
+      );
+      break;
+    }
+    case "agents_menu":
+      await editMessage(token, chatId, messageId, renderAgentsSummary(), agentsMenu());
+      break;
+    case "agents_profiles": {
+      const parsed = runRexJson(["agents", "profiles", "--json"], 15e3);
+      const rows = Array.isArray(parsed?.profiles) ? parsed.profiles : [];
+      const body = rows.length ? rows.slice(0, 8).map((p) => `\u2022 ${p.name} \u2022 model=${p.model} \u2022 every=${p.intervalSec}s`).join("\n") : "No profile data.";
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u{1F4E6} *Agent Profiles*
+${body}`,
+        agentsMenu()
+      );
+      break;
+    }
+    case "agents_create_read": {
+      const out = truncate(strip(runRex(["agents", "create", "read"], 2e4)), 3e3);
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u2795 *Agent Created (read)*
+\`\`\`
+${out}
+\`\`\``,
+        agentsMenu()
+      );
+      break;
+    }
+    case "agents_create_review": {
+      const out = truncate(strip(runRex(["agents", "create", "code-review"], 2e4)), 3e3);
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u2795 *Agent Created (code-review)*
+\`\`\`
+${out}
+\`\`\``,
+        agentsMenu()
+      );
+      break;
+    }
+    case "agents_start_all": {
+      const targets = loadAgents().filter((a) => a.enabled);
+      if (targets.length === 0) {
+        await editMessage(token, chatId, messageId, "\u{1F9E0} *Agents*\nNo enabled agents to start.", agentsMenu());
+        break;
+      }
+      const lines = targets.slice(0, 10).map((a) => {
+        const out = runRex(["agents", "run", a.id], 2e4);
+        const ok = out.includes('"ok"') || out.includes("alreadyRunning");
+        return `${ok ? "\u2705" : "\u26A0\uFE0F"} ${a.id}`;
+      });
+      const more = targets.length > 10 ? `
+... +${targets.length - 10} more` : "";
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u25B6\uFE0F *Start enabled agents*
+${lines.join("\n")}${more}`,
+        agentsMenu()
+      );
+      break;
+    }
+    case "agents_stop_all": {
+      const targets = loadAgents().filter((a) => a.running);
+      if (targets.length === 0) {
+        await editMessage(token, chatId, messageId, "\u{1F9E0} *Agents*\nNo running agents to stop.", agentsMenu());
+        break;
+      }
+      const lines = targets.slice(0, 10).map((a) => {
+        const out = runRex(["agents", "stop", a.id], 2e4);
+        const ok = out.includes('"ok"') || out.includes('"stopped"');
+        return `${ok ? "\u2705" : "\u26A0\uFE0F"} ${a.id}`;
+      });
+      const more = targets.length > 10 ? `
+... +${targets.length - 10} more` : "";
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u23F9 *Stop running agents*
+${lines.join("\n")}${more}`,
+        agentsMenu()
+      );
+      break;
+    }
+    case "mcp_menu":
+      await editMessage(token, chatId, messageId, renderMcpSummary(), mcpMenu());
+      break;
+    case "mcp_sync": {
+      const out = truncate(strip(runRex(["mcp", "sync-claude"], 2e4)), 3e3);
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u{1F501} *MCP Sync Claude*
+\`\`\`
+${out}
+\`\`\``,
+        mcpMenu()
+      );
+      break;
+    }
+    case "mcp_check_enabled": {
+      const servers = loadMcpServers().filter((s) => s.enabled);
+      if (servers.length === 0) {
+        await editMessage(token, chatId, messageId, "\u{1F50C} *MCP*\nNo enabled servers to check.", mcpMenu());
+        break;
+      }
+      const lines = servers.slice(0, 8).map((s) => {
+        const checked = runRexJson(["mcp", "check", s.id], 15e3);
+        return `${checked?.ok ? "\u2705" : "\u274C"} ${s.id} (${s.type})`;
+      });
+      const more = servers.length > 8 ? `
+... +${servers.length - 8} more` : "";
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u2705 *MCP check (enabled)*
+${lines.join("\n")}${more}`,
+        mcpMenu()
+      );
+      break;
+    }
+    case "mcp_export": {
+      const out = truncate(strip(runRex(["mcp", "export"], 15e3)), 3e3);
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u{1F4E4} *MCP Export*
+\`\`\`
+${out}
+\`\`\``,
+        mcpMenu()
+      );
+      break;
+    }
+    case "files_menu":
+      await editMessage(token, chatId, messageId, renderUploadsList(chatId), filesMenu());
+      break;
+    case "files_list":
+      await editMessage(token, chatId, messageId, renderUploadsList(chatId), filesMenu());
+      break;
+    case "file_last": {
+      const upload = latestUpload(chatId);
+      if (!upload) {
+        await editMessage(token, chatId, messageId, "\u{1F4CE} *Files*\nNo uploaded file found yet.", filesMenu());
+        break;
+      }
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u{1F4CE} *Last File*
+\`\`\`
+${renderUpload(upload)}
+\`\`\``,
+        filesMenu()
+      );
+      break;
+    }
+    case "file_analyze_claude": {
+      const upload = latestUpload(chatId);
+      if (!upload) {
+        await editMessage(token, chatId, messageId, "\u{1F4CE} *Files*\nNo uploaded file found yet.", filesMenu());
+        break;
+      }
+      await editMessage(token, chatId, messageId, "\u{1F916} _Analyzing latest file with Claude..._");
+      const out = await analyzeUpload(upload, "Summarize the file and propose engineering actions.", "claude");
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u{1F916} *Claude file analysis*
+${truncate(out, 3200)}`,
+        filesMenu()
+      );
+      break;
+    }
+    case "file_analyze_qwen": {
+      const upload = latestUpload(chatId);
+      if (!upload) {
+        await editMessage(token, chatId, messageId, "\u{1F4CE} *Files*\nNo uploaded file found yet.", filesMenu());
+        break;
+      }
+      await editMessage(token, chatId, messageId, "\u{1F9E0} _Analyzing latest file with Qwen..._");
+      const out = await analyzeUpload(upload, "Summarize the file and propose engineering actions.", "qwen");
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u{1F9E0} *Qwen file analysis*
+${truncate(out, 3200)}`,
+        filesMenu()
+      );
+      break;
+    }
+    case "logs": {
+      let logs = "No logs yet";
+      try {
+        if (existsSync(LOG_FILE)) {
+          logs = run(`tail -20 "${LOG_FILE}"`);
+        }
+      } catch {
+      }
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u{1F4DD} *Recent Logs*
+\`\`\`
+${truncate(strip(logs), 3e3)}
+\`\`\``,
+        backButton()
+      );
+      break;
+    }
+    case "models_menu": {
+      await editMessage(
+        token,
+        chatId,
+        messageId,
+        `\u{1F39B} *Mod\xE8les actifs*
+\u{1F9E0} Local: \`${state.localModel || "auto"}\`
+\u{1F916} Claude: \`${state.claudeModel || "sonnet-4-6 (d\xE9faut)"}\``,
+        modelsMenu()
+      );
+      break;
+    }
+    case "notifs": {
+      const { text: t, buttons } = buildNotifsMessage(null, 0);
+      await editMessage(token, chatId, messageId, t, buttons);
+      break;
+    }
+    default: {
+      if (data.startsWith("set_local_")) {
+        const model = data.replace("set_local_", "");
+        state.localModel = model === "auto" ? null : model;
+        saveState(state);
+        await editMessage(
+          token,
+          chatId,
+          messageId,
+          `\u{1F9E0} Mod\xE8le local \u2192 \`${state.localModel || "auto-detect"}\``,
+          modelsMenu()
+        );
+        break;
+      }
+      if (data.startsWith("set_claude_")) {
+        const model = data.replace("set_claude_", "");
+        state.claudeModel = model;
+        saveState(state);
+        await editMessage(
+          token,
+          chatId,
+          messageId,
+          `\u{1F916} Mod\xE8le Claude \u2192 \`${model}\``,
+          modelsMenu()
+        );
+        break;
+      }
+      if (data.startsWith("notif_filter_")) {
+        const proj = data.replace("notif_filter_", "");
+        const { text: t, buttons } = buildNotifsMessage(proj === "all" ? null : proj, 0);
+        await editMessage(token, chatId, messageId, t, buttons);
+        break;
+      }
+      if (data.startsWith("notif_page_")) {
+        const parts = data.replace("notif_page_", "").split("_");
+        const page = parseInt(parts[0], 10) || 0;
+        const proj = parts.slice(1).join("_") || null;
+        const { text: t, buttons } = buildNotifsMessage(proj === "all" ? null : proj, page);
+        await editMessage(token, chatId, messageId, t, buttons);
+        break;
+      }
+      if (data.startsWith("notif_markall_")) {
+        const proj = data.replace("notif_markall_", "");
+        const notifs = loadNotifications();
+        for (const n of notifs) {
+          if (proj === "all" || n.project === proj) n.read = true;
+        }
+        saveNotifications(notifs);
+        const { text: t, buttons } = buildNotifsMessage(proj === "all" ? null : proj, 0);
+        await editMessage(token, chatId, messageId, t, buttons);
+        break;
+      }
+      break;
+    }
+  }
+}
+var BLOCKED_COMMANDS = [
+  "rm -rf",
+  "rm -r /",
+  "mkfs",
+  "dd if=",
+  ":(){",
+  "chmod -R 777",
+  "git push --force main",
+  "git push --force master",
+  "sudo rm",
+  "sudo chmod",
+  "eval ",
+  "curl | sh",
+  "curl | bash",
+  "wget | sh",
+  "> /dev/sd",
+  "shutdown",
+  "reboot",
+  "init 0"
+];
+async function handleText(token, chatId, text, from) {
+  const cmd = text.trim().toLowerCase();
+  if (cmd === "/start" || cmd === "/menu" || cmd === "/help" || cmd === "/h") {
+    await send(token, chatId, "\u{1F996} *REX Gateway v3*\nChoisis une action :", mainMenu());
+    logCommand(from, cmd, "menu");
+    return;
+  }
+  if (cmd === "/status" || cmd === "/s") {
+    const out = strip(run("rex status"));
+    await send(token, chatId, `\u{1F4CA} ${out}`, backButton());
+    logCommand(from, "/status", out);
+    return;
+  }
+  if (cmd === "/wake" || cmd === "/w") {
+    await send(token, chatId, "\u{1F4A4} _Sending wake signal..._");
+    const result = await wakeMac();
+    await send(token, chatId, result, backButton());
+    logCommand(from, "/wake", result);
+    return;
+  }
+  if (cmd === "/doctor" || cmd === "/d") {
+    await send(token, chatId, "\u{1FA7A} _Running diagnostics..._");
+    const out = truncate(strip(run("rex doctor")));
+    await send(token, chatId, `\u{1FA7A}
+\`\`\`
+${out}
+\`\`\``, backButton());
+    logCommand(from, "/doctor", "done");
+    return;
+  }
+  if (cmd === "/ingest" || cmd === "/i") {
+    await send(token, chatId, "\u{1F4E5} _Ingesting..._");
+    const out = truncate(strip(run("rex ingest", 12e4)));
+    await send(token, chatId, `\u{1F4E5}
+\`\`\`
+${out}
+\`\`\``, backButton());
+    logCommand(from, "/ingest", "done");
+    return;
+  }
+  if (cmd === "/prune") {
+    await send(token, chatId, "\u{1F9F9} _Pruning..._");
+    const out = truncate(strip(run("rex prune", 6e4)));
+    await send(token, chatId, `\u{1F9F9}
+\`\`\`
+${out}
+\`\`\``, backButton());
+    logCommand(from, "/prune", "done");
+    return;
+  }
+  if (cmd === "/notifs" || cmd === "/notif" || cmd.startsWith("/notifs ")) {
+    const filter = cmd.startsWith("/notifs ") ? text.replace(/^\/notifs\s+/i, "").trim() : null;
+    const { text: t, buttons } = buildNotifsMessage(filter || null, 0);
+    await send(token, chatId, t, buttons);
+    logCommand(from, "/notifs", filter || "all");
+    return;
+  }
+  if (cmd.startsWith("/notify ")) {
+    const raw = text.replace(/^\/notify\s+/i, "");
+    const parts = raw.match(/(?:-p\s+(\S+))?\s*(?:-P\s+(\S+))?\s*(.*)/i) || [];
+    let project = "general";
+    let priority = "normal";
+    let rest = raw;
+    const pMatch = raw.match(/-p\s+(\S+)/);
+    const PMatch = raw.match(/-P\s+(urgent|high|normal|low)/i);
+    if (pMatch) {
+      project = pMatch[1];
+      rest = rest.replace(pMatch[0], "").trim();
+    }
+    if (PMatch) {
+      priority = PMatch[1].toLowerCase();
+      rest = rest.replace(PMatch[0], "").trim();
+    }
+    const [title = rest, ...msgParts] = rest.split("|");
+    const message = msgParts.join("|").trim();
+    addNotification(project, title.trim(), message, priority);
+    const emoji = priorityEmoji(priority);
+    await send(
+      token,
+      chatId,
+      `${emoji} *Notification enregistr\xE9e*
+*Projet:* ${project}
+*Titre:* ${title.trim()}${message ? `
+*D\xE9tail:* ${message}` : ""}`,
+      [[{ text: "\u{1F514} Voir notifs", callback_data: "notifs" }, { text: "\u25C0\uFE0F Menu", callback_data: "menu" }]]
+    );
+    logCommand(from, "/notify", `${project}: ${title.trim()}`);
+    return;
+  }
+  if (cmd.startsWith("/search ") || cmd.startsWith("/q ")) {
+    const query = text.replace(/^\/(search|q)\s+/i, "");
+    if (!query) {
+      await send(token, chatId, "Usage: /search <query>");
+      return;
+    }
+    const out = runRex(["search", query]);
+    await send(
+      token,
+      chatId,
+      out ? `\u{1F50D} *Search:* ${query}
+\`\`\`
+${truncate(out, 3e3)}
+\`\`\`` : "No results",
+      backButton()
+    );
+    logCommand(from, `/search ${query}`, out ? "found" : "empty");
+    return;
+  }
+  if (cmd.startsWith("/sh ") || cmd.startsWith("/run ")) {
+    const shellCmd = text.replace(/^\/(sh|run)\s+/i, "");
+    if (BLOCKED_COMMANDS.some((b) => shellCmd.toLowerCase().includes(b))) {
+      await send(token, chatId, "\u{1F6AB} Blocked: dangerous command");
+      logCommand(from, `/sh ${shellCmd}`, "BLOCKED");
+      return;
+    }
+    const out = run(shellCmd);
+    await send(token, chatId, `\`$ ${shellCmd}\`
+\`\`\`
+${truncate(out, 3500)}
+\`\`\``, backButton());
+    logCommand(from, `/sh ${shellCmd}`, out.slice(0, 100));
+    return;
+  }
+  if (cmd.startsWith("/mode")) {
+    state.mode = state.mode === "qwen" ? "claude" : "qwen";
+    state.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+    saveState(state);
+    await send(
+      token,
+      chatId,
+      `\u{1F916} Switched to *${state.mode === "qwen" ? "Qwen (local)" : "Claude"}*`,
+      mainMenu()
+    );
+    logCommand(from, "/mode", state.mode);
+    return;
+  }
+  if (cmd === "/claude" || cmd === "/c") {
+    await send(token, chatId, "\u{1F916} *Claude Remote*\nGere tes sessions Claude a distance :", claudeMenu());
+    return;
+  }
+  if (cmd.startsWith("/claude ") || cmd.startsWith("/c ")) {
+    const prompt = text.replace(/^\/(claude|c)\s+/i, "");
+    const initMsg = await send(token, chatId, "\u{1F916} _Claude is thinking..._");
+    const thinkMsgId = initMsg?.result?.message_id;
+    const out = thinkMsgId ? await claudeSession(token, chatId, thinkMsgId, prompt) : await askClaude(prompt);
+    await send(token, chatId, out, [
+      [
+        { text: "\u{1F4AC} Continue", callback_data: "claude_continue" },
+        { text: "\u25C0\uFE0F Menu", callback_data: "menu" }
+      ]
+    ]);
+    logCommand(from, `/claude ${prompt.slice(0, 50)}`, out.slice(0, 100));
+    return;
+  }
+  if (cmd === "/advanced" || cmd === "/adv") {
+    await send(token, chatId, "\u{1F9ED} *Advanced*\nAgents autonomes, MCP et audit.", advancedMenu());
+    logCommand(from, "/advanced", "menu");
+    return;
+  }
+  if (cmd === "/audit") {
+    await send(token, chatId, "\u{1F9EA} _Running strict audit..._");
+    const out = truncate(strip(run("rex audit --strict", 12e4)), 3500);
+    await send(token, chatId, `\u{1F9EA}
+\`\`\`
+${out}
+\`\`\``, advancedMenu());
+    logCommand(from, "/audit", "done");
+    return;
+  }
+  if (cmd === "/agents") {
+    await send(token, chatId, renderAgentsSummary(), agentsMenu());
+    logCommand(from, "/agents", "listed");
+    return;
+  }
+  if (cmd.startsWith("/agent_create ")) {
+    const parts = text.trim().split(/\s+/);
+    const profile = sanitizeToken(parts[1] || "");
+    const name = sanitizeToken(parts[2] || "");
+    if (!profile) {
+      await send(token, chatId, "Usage: `/agent_create <read|analysis|code-review|advanced|ultimate> [name]`");
+      return;
+    }
+    const args = ["agents", "create", profile];
+    if (name) args.push(name);
+    const out = truncate(strip(runRex(args, 2e4)), 3200);
+    await send(token, chatId, `\u2795 Agent created
+\`\`\`
+${out}
+\`\`\``, agentsMenu());
+    logCommand(from, `/agent_create ${profile}`, "done");
+    return;
+  }
+  if (cmd.startsWith("/agent_start ")) {
+    const id = sanitizeToken(text.replace(/^\/agent_start\s+/i, ""));
+    if (!id) {
+      await send(token, chatId, "Usage: `/agent_start <id>`");
+      return;
+    }
+    const out = truncate(strip(runRex(["agents", "run", id], 2e4)), 3200);
+    await send(token, chatId, `\u25B6\uFE0F
+\`\`\`
+${out}
+\`\`\``, agentsMenu());
+    logCommand(from, `/agent_start ${id}`, out.slice(0, 80));
+    return;
+  }
+  if (cmd.startsWith("/agent_run ")) {
+    const id = sanitizeToken(text.replace(/^\/agent_run\s+/i, ""));
+    if (!id) {
+      await send(token, chatId, "Usage: `/agent_run <id>`");
+      return;
+    }
+    await send(token, chatId, "\u25B6\uFE0F _Running one cycle..._");
+    const out = truncate(strip(runRex(["agents", "run", id, "--once"], 9e4)), 3200);
+    await send(token, chatId, `\u25B6\uFE0F One cycle done
+\`\`\`
+${out}
+\`\`\``, agentsMenu());
+    logCommand(from, `/agent_run ${id}`, "once");
+    return;
+  }
+  if (cmd.startsWith("/agent_stop ")) {
+    const id = sanitizeToken(text.replace(/^\/agent_stop\s+/i, ""));
+    if (!id) {
+      await send(token, chatId, "Usage: `/agent_stop <id>`");
+      return;
+    }
+    const out = truncate(strip(runRex(["agents", "stop", id], 2e4)), 3200);
+    await send(token, chatId, `\u23F9
+\`\`\`
+${out}
+\`\`\``, agentsMenu());
+    logCommand(from, `/agent_stop ${id}`, out.slice(0, 80));
+    return;
+  }
+  if (cmd.startsWith("/agent_enable ")) {
+    const id = sanitizeToken(text.replace(/^\/agent_enable\s+/i, ""));
+    if (!id) {
+      await send(token, chatId, "Usage: `/agent_enable <id>`");
+      return;
+    }
+    const out = truncate(strip(runRex(["agents", "enable", id], 2e4)), 3200);
+    await send(token, chatId, `\u2705
+\`\`\`
+${out}
+\`\`\``, agentsMenu());
+    logCommand(from, `/agent_enable ${id}`, out.slice(0, 80));
+    return;
+  }
+  if (cmd.startsWith("/agent_disable ")) {
+    const id = sanitizeToken(text.replace(/^\/agent_disable\s+/i, ""));
+    if (!id) {
+      await send(token, chatId, "Usage: `/agent_disable <id>`");
+      return;
+    }
+    const out = truncate(strip(runRex(["agents", "disable", id], 2e4)), 3200);
+    await send(token, chatId, `\u26AB\uFE0F
+\`\`\`
+${out}
+\`\`\``, agentsMenu());
+    logCommand(from, `/agent_disable ${id}`, out.slice(0, 80));
+    return;
+  }
+  if (cmd.startsWith("/agent_delete ")) {
+    const id = sanitizeToken(text.replace(/^\/agent_delete\s+/i, ""));
+    if (!id) {
+      await send(token, chatId, "Usage: `/agent_delete <id>`");
+      return;
+    }
+    const out = truncate(strip(runRex(["agents", "delete", id], 2e4)), 3200);
+    await send(token, chatId, `\u{1F5D1}
+\`\`\`
+${out}
+\`\`\``, agentsMenu());
+    logCommand(from, `/agent_delete ${id}`, out.slice(0, 80));
+    return;
+  }
+  if (cmd.startsWith("/agent_logs ")) {
+    const id = sanitizeToken(text.replace(/^\/agent_logs\s+/i, ""));
+    if (!id) {
+      await send(token, chatId, "Usage: `/agent_logs <id>`");
+      return;
+    }
+    const out = truncate(strip(runRex(["agents", "logs", id, "--tail", "25"], 2e4)), 3200);
+    await send(token, chatId, `\u{1F4DD} Agent logs
+\`\`\`
+${out}
+\`\`\``, agentsMenu());
+    logCommand(from, `/agent_logs ${id}`, "done");
+    return;
+  }
+  if (cmd.startsWith("/mcp_check ")) {
+    const id = sanitizeToken(text.replace(/^\/mcp_check\s+/i, ""));
+    if (!id) {
+      await send(token, chatId, "Usage: `/mcp_check <id>`");
+      return;
+    }
+    const out = truncate(strip(runRex(["mcp", "check", id], 2e4)), 3200);
+    await send(token, chatId, `\u2705 MCP check
+\`\`\`
+${out}
+\`\`\``, mcpMenu());
+    logCommand(from, `/mcp_check ${id}`, out.slice(0, 80));
+    return;
+  }
+  if (cmd.startsWith("/mcp_enable ")) {
+    const id = sanitizeToken(text.replace(/^\/mcp_enable\s+/i, ""));
+    if (!id) {
+      await send(token, chatId, "Usage: `/mcp_enable <id>`");
+      return;
+    }
+    const out = truncate(strip(runRex(["mcp", "enable", id], 2e4)), 3200);
+    await send(token, chatId, `\u{1F7E2} MCP enabled
+\`\`\`
+${out}
+\`\`\``, mcpMenu());
+    logCommand(from, `/mcp_enable ${id}`, out.slice(0, 80));
+    return;
+  }
+  if (cmd.startsWith("/mcp_disable ")) {
+    const id = sanitizeToken(text.replace(/^\/mcp_disable\s+/i, ""));
+    if (!id) {
+      await send(token, chatId, "Usage: `/mcp_disable <id>`");
+      return;
+    }
+    const out = truncate(strip(runRex(["mcp", "disable", id], 2e4)), 3200);
+    await send(token, chatId, `\u26AB\uFE0F MCP disabled
+\`\`\`
+${out}
+\`\`\``, mcpMenu());
+    logCommand(from, `/mcp_disable ${id}`, out.slice(0, 80));
+    return;
+  }
+  if (cmd.startsWith("/mcp_remove ")) {
+    const id = sanitizeToken(text.replace(/^\/mcp_remove\s+/i, ""));
+    if (!id) {
+      await send(token, chatId, "Usage: `/mcp_remove <id>`");
+      return;
+    }
+    const out = truncate(strip(runRex(["mcp", "remove", id], 2e4)), 3200);
+    await send(token, chatId, `\u{1F5D1} MCP removed
+\`\`\`
+${out}
+\`\`\``, mcpMenu());
+    logCommand(from, `/mcp_remove ${id}`, out.slice(0, 80));
+    return;
+  }
+  if (cmd === "/mcp_sync") {
+    const out = truncate(strip(runRex(["mcp", "sync-claude"], 2e4)), 3200);
+    await send(token, chatId, `\u{1F501} MCP synced
+\`\`\`
+${out}
+\`\`\``, mcpMenu());
+    logCommand(from, "/mcp_sync", "done");
+    return;
+  }
+  if (cmd === "/mcp_export") {
+    const out = truncate(strip(runRex(["mcp", "export"], 2e4)), 3200);
+    await send(token, chatId, `\u{1F4E4} MCP export
+\`\`\`
+${out}
+\`\`\``, mcpMenu());
+    logCommand(from, "/mcp_export", "done");
+    return;
+  }
+  if (cmd.startsWith("/chat ")) {
+    const userMsg = text.replace(/^\/chat\s+/i, "").trim();
+    if (!userMsg) {
+      await send(token, chatId, "Usage: `/chat <message>` \u2014 Talk to the REX Orchestrator");
+      return;
+    }
+    await send(token, chatId, "\u{1F9E0} _Orchestrator thinking..._");
+    try {
+      const out = truncate(strip(runRex(["agents", "run", "orchestrator", "--task", userMsg, "--once"], 18e4)), 3500);
+      await send(token, chatId, `\u{1F9E0} *Orchestrator*
+${out}`, [
+        [{ text: "\u{1F4AC} Continue", callback_data: "menu" }]
+      ]);
+    } catch {
+      const fbMsg = await send(token, chatId, "\u{1F916} _Claude thinking..._");
+      const fbMsgId = fbMsg?.result?.message_id;
+      const response = fbMsgId ? await claudeSession(token, chatId, fbMsgId, userMsg) : await askClaude(userMsg);
+      await send(token, chatId, `\u{1F916} *Claude*
+${response}`, [
+        [{ text: "\u{1F4AC} Continue", callback_data: "menu" }]
+      ]);
+    }
+    logCommand(from, `/chat ${userMsg.slice(0, 50)}`, "orchestrator");
+    return;
+  }
+  if (cmd === "/mcp") {
+    await send(token, chatId, renderMcpSummary(), mcpMenu());
+    logCommand(from, "/mcp", "listed");
+    return;
+  }
+  if (cmd === "/files" || cmd === "/file_list") {
+    await send(token, chatId, renderUploadsList(chatId), filesMenu());
+    logCommand(from, "/files", "listed");
+    return;
+  }
+  if (cmd === "/file_last") {
+    const upload = latestUpload(chatId);
+    if (!upload) {
+      await send(token, chatId, "\u{1F4CE} No uploaded file found yet.", filesMenu());
+      return;
+    }
+    await send(token, chatId, `\u{1F4CE} *Last File*
+\`\`\`
+${renderUpload(upload)}
+\`\`\``, filesMenu());
+    return;
+  }
+  if (cmd.startsWith("/file_analyze")) {
+    const upload = latestUpload(chatId);
+    if (!upload) {
+      await send(token, chatId, "\u{1F4CE} No uploaded file found yet.", filesMenu());
+      return;
+    }
+    const raw = text.replace(/^\/file_analyze\s*/i, "").trim();
+    let mode;
+    let task = raw;
+    if (raw.toLowerCase().startsWith("qwen ")) {
+      mode = "qwen";
+      task = raw.slice(5).trim();
+    } else if (raw.toLowerCase().startsWith("claude ")) {
+      mode = "claude";
+      task = raw.slice(7).trim();
+    }
+    if (!task) task = "Summarize this file and propose concrete next engineering actions.";
+    const runMode = mode || state.mode;
+    await send(token, chatId, `${runMode === "claude" ? "\u{1F916}" : "\u{1F9E0}"} _Analyzing latest file..._`);
+    const out = await analyzeUpload(upload, task, runMode);
+    await send(token, chatId, truncate(out, 3200), filesMenu());
+    logCommand(from, `/file_analyze ${runMode}`, out.slice(0, 120));
+    return;
+  }
+  if (text.length > 2) {
+    state = loadState();
+    state.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+    saveState(state);
+    let response;
+    if (state.mode === "qwen") {
+      response = await askQwenStream(token, chatId, text);
+    } else {
+      const thinkMsg = await send(token, chatId, "\u{1F916} Claude _thinking..._");
+      const thinkId = thinkMsg?.result?.message_id;
+      response = thinkId ? await claudeSession(token, chatId, thinkId, text) : await askClaude(text);
+      await send(token, chatId, response, [
+        [
+          { text: "Mode: claude", callback_data: "switch_mode" },
+          { text: "\u{1F4AC} Continue", callback_data: "claude_continue" }
+        ]
+      ]);
+    }
+    logCommand(from, text.slice(0, 80), response.slice(0, 100));
+    return;
+  }
+  await send(token, chatId, "\u{1F996} *REX*\nEnvoie un message ou appuie sur Menu :", mainMenu());
+}
+var processedUpdateIds = /* @__PURE__ */ new Set();
+var MAX_PROCESSED_IDS = 500;
+function markProcessed(updateId) {
+  if (processedUpdateIds.has(updateId)) return false;
+  processedUpdateIds.add(updateId);
+  if (processedUpdateIds.size > MAX_PROCESSED_IDS) {
+    const oldest = processedUpdateIds.values().next().value;
+    if (oldest !== void 0) processedUpdateIds.delete(oldest);
+  }
+  return true;
+}
+async function gateway() {
+  const creds = getCredentials();
+  if (!creds) {
+    console.error(`${COLORS.red}No Telegram credentials found.${COLORS.reset}`);
+    console.error(`Run ${COLORS.cyan}rex setup${COLORS.reset} to configure Telegram gateway.`);
+    process.exit(1);
+  }
+  const { token, chatId } = creds;
+  config = loadConfig();
+  state = loadState();
+  cleanupOldUploads();
+  if (!acquireLock()) {
+    console.error(`${COLORS.red}Another REX Gateway instance is already running.${COLORS.reset}`);
+    console.error(`Remove ${LOCK_FILE} if this is stale, or stop the other instance first.`);
+    process.exit(1);
+  }
+  console.log(`${COLORS.bold}REX Gateway v3${COLORS.reset} \u2014 Interactive Telegram bot`);
+  console.log(`${COLORS.dim}Chat: ${chatId} | Mode: ${state.mode} | Sessions: ${state.sessionsCount}${COLORS.reset}`);
+  console.log(`${COLORS.dim}Auth: restricted to chat_id ${chatId}${COLORS.reset}`);
+  console.log(`${COLORS.dim}Ctrl+C to stop${COLORS.reset}
+`);
+  let offset = 0;
+  try {
+    const flush = await fetch(`https://api.telegram.org/bot${token}/getUpdates?offset=-1`);
+    const flushData = await flush.json();
+    if (flushData.result?.length) {
+      offset = flushData.result[flushData.result.length - 1].update_id + 1;
+    }
+  } catch {
+  }
+  await send(token, chatId, `\u{1F7E2} *REX Gateway v3* started
+Mode: ${state.mode} | Sessions: ${state.sessionsCount}`, mainMenu());
+  const shutdown = (signal) => async () => {
+    console.log(`
+${COLORS.dim}Shutting down (${signal})...${COLORS.reset}`);
+    activeStreamController?.abort();
+    state.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+    saveState(state);
+    releaseLock();
+    await send(token, chatId, `\u{1F534} *REX Gateway* stopped (${signal})`).catch(() => {
+    });
+    process.exit(signal === "SIGINT" ? 0 : 1);
+  };
+  process.on("SIGINT", shutdown("SIGINT"));
+  process.on("SIGTERM", shutdown("SIGTERM"));
+  process.on("uncaughtException", (err) => {
+    console.error(`${COLORS.red}Uncaught exception:${COLORS.reset} ${err.message}`);
+    releaseLock();
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    console.error(`${COLORS.red}Unhandled rejection:${COLORS.reset} ${reason}`);
+    releaseLock();
+    process.exit(1);
+  });
+  while (true) {
+    try {
+      const pollController = new AbortController();
+      const pollTimer = setTimeout(() => pollController.abort(), (config.pollTimeout + 15) * 1e3);
+      let res;
+      try {
+        res = await fetch(
+          `https://api.telegram.org/bot${token}/getUpdates?offset=${offset}&timeout=${config.pollTimeout}&allowed_updates=["message","callback_query"]`,
+          { signal: pollController.signal }
+        );
+      } finally {
+        clearTimeout(pollTimer);
+      }
+      const data = await res.json();
+      if (!data.ok || !data.result?.length) continue;
+      for (const update of data.result) {
+        offset = update.update_id + 1;
+        if (!markProcessed(update.update_id)) continue;
+        if (update.callback_query) {
+          const cb = update.callback_query;
+          const cbChatId = String(cb.message?.chat?.id);
+          if (!isAuthorized(cbChatId, chatId)) {
+            await answerCallback(token, cb.id, "\u{1F6AB} Unauthorized");
+            continue;
+          }
+          const from2 = cb.from?.username ?? "?";
+          console.log(`${COLORS.cyan}@${from2}${COLORS.reset} [btn] ${cb.data}`);
+          if (!cb.message?.message_id || !cb.data) {
+            await answerCallback(token, cb.id, "\u26A0\uFE0F Stale button");
+            continue;
+          }
+          await handleCallback(token, chatId, cb.message.message_id, cb.id, cb.data, from2);
+          continue;
+        }
+        const msg = update.message;
+        if (!msg) continue;
+        if (!isAuthorized(msg.chat.id, chatId)) {
+          await send(token, String(msg.chat.id), "\u{1F6AB} Unauthorized. This REX instance is private.");
+          continue;
+        }
+        const from = msg.from?.username ?? "?";
+        const attachment = pickAttachment(msg);
+        if (attachment) {
+          console.log(`${COLORS.cyan}@${from}${COLORS.reset}: [upload] ${attachment.kind} ${attachment.fileName}`);
+          await send(token, chatId, "\u{1F4E5} _Downloading attachment..._");
+          try {
+            const response = await handleAttachment(token, chatId, msg, from);
+            await send(token, chatId, response, filesMenu());
+          } catch (e) {
+            const err = e instanceof Error ? e.message : String(e);
+            await send(token, chatId, `\u26A0\uFE0F Upload processing failed: ${err}`, filesMenu());
+            logCommand(from, "[upload]", `error: ${err}`);
+          }
+          if (!msg.text) continue;
+        }
+        if (msg.text) {
+          console.log(`${COLORS.cyan}@${from}${COLORS.reset}: ${msg.text}`);
+          await handleText(token, chatId, msg.text, from);
+        }
+      }
+    } catch (err) {
+      console.error(`${COLORS.red}Poll error:${COLORS.reset} ${err.message}`);
+      await new Promise((r) => setTimeout(r, 5e3));
+    }
+  }
+}
+export {
+  gateway
+};