rex-claude 3.0.0 → 4.0.0

package/dist/gateway-EKMU5D7J.js

@@ -0,0 +1,784 @@
+#!/usr/bin/env node
+
+// src/gateway.ts
+import { homedir } from "os";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { execSync } from "child_process";
+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");
+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)) {
+      return JSON.parse(readFileSync(STATE_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return { mode: "qwen", lastActivity: (/* @__PURE__ */ new Date()).toISOString(), sessionsCount: 0 };
+}
+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();
+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)
+    });
+    return await res.json();
+  } catch {
+    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" }
+    ]
+  ];
+}
+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 run(cmd, timeout = 3e4) {
+  try {
+    return execSync(cmd, { timeout, encoding: "utf-8" }).trim();
+  } catch (e) {
+    return e.stderr?.trim() || e.message || "Command failed";
+  }
+}
+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)";
+}
+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 = run(`rex llm "${prompt.replace(/"/g, '\\"').replace(/`/g, "\\`")}"`, 6e4);
+  if (!out || out.includes("rex-claude") || out.includes("Commands:")) {
+    return "\u26A0\uFE0F LLM returned no useful response";
+  }
+  return truncate(out);
+}
+async function askClaude(prompt) {
+  try {
+    const escapedPrompt = prompt.replace(/"/g, '\\"').replace(/`/g, "\\`");
+    const out = run(`claude -p "${escapedPrompt}" 2>/dev/null`, 12e4);
+    if (out) return truncate(out);
+    return "\u26A0\uFE0F Claude CLI not available or returned empty";
+  } catch {
+    return "\u26A0\uFE0F Claude CLI error";
+  }
+}
+async function claudeSession(prompt, resume) {
+  try {
+    const flag = resume ? "--continue" : "";
+    const escapedPrompt = prompt.replace(/"/g, '\\"').replace(/`/g, "\\`");
+    const out = run(`claude ${flag} -p "${escapedPrompt}" 2>/dev/null`, 18e4);
+    state.sessionsCount++;
+    saveState(state);
+    if (out) return truncate(out);
+    return "\u26A0\uFE0F No response from Claude session";
+  } catch {
+    return "\u26A0\uFE0F Claude session error";
+  }
+}
+async function handleCallback(token, chatId, messageId, callbackId, data, from) {
+  await answerCallback(token, callbackId);
+  logCommand(from, `[btn] ${data}`, "ok");
+  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("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 "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;
+    }
+  }
+}
+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.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 = run(`rex 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, "");
+    await send(token, chatId, "\u{1F916} _Claude is thinking..._");
+    const out = await claudeSession(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 (text.length > 2) {
+    const modeLabel = state.mode === "qwen" ? "\u{1F9E0} Qwen" : "\u{1F916} Claude";
+    await send(token, chatId, `${modeLabel} _thinking..._`);
+    state.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+    saveState(state);
+    let response;
+    if (state.mode === "claude") {
+      response = await claudeSession(text);
+    } else {
+      response = await askLLM(text);
+    }
+    await send(token, chatId, response, [
+      [
+        { text: `Mode: ${state.mode}`, callback_data: "switch_mode" },
+        { text: state.mode === "claude" ? "\u{1F4AC} Continue" : "\u25C0\uFE0F Menu", callback_data: state.mode === "claude" ? "claude_continue" : "menu" }
+      ]
+    ]);
+    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());
+}
+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();
+  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());
+  process.on("SIGINT", async () => {
+    console.log(`
+${COLORS.dim}Shutting down...${COLORS.reset}`);
+    state.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+    saveState(state);
+    await send(token, chatId, "\u{1F534} *REX Gateway* stopped");
+    process.exit(0);
+  });
+  process.on("SIGTERM", async () => {
+    state.lastActivity = (/* @__PURE__ */ new Date()).toISOString();
+    saveState(state);
+    await send(token, chatId, "\u{1F534} *REX Gateway* stopped (SIGTERM)");
+    process.exit(0);
+  });
+  while (true) {
+    try {
+      const res = await fetch(
+        `https://api.telegram.org/bot${token}/getUpdates?offset=${offset}&timeout=${config.pollTimeout}&allowed_updates=["message","callback_query"]`
+      );
+      const data = await res.json();
+      if (!data.ok || !data.result?.length) continue;
+      for (const update of data.result) {
+        offset = update.update_id + 1;
+        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}`);
+          await handleCallback(token, chatId, cb.message.message_id, cb.id, cb.data, from2);
+          continue;
+        }
+        const msg = update.message;
+        if (!msg?.text) 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 ?? "?";
+        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
+};

package/dist/index.js

@@ -371,7 +371,7 @@ async function main() {
       break;
     }
     case "init": {
-      const { init } = await import("./init-W3XGDQ6D.js");
+      const { init } = await import("./init-DLFEGD6O.js");
       await init();
       break;
     }
@@ -416,6 +416,12 @@ async function main() {
       await optimize(applyFlag);
       break;
     }
+    case "prune": {
+      const { prune } = await import("./prune-2PPIVDXK.js");
+      const statsFlag = process.argv.includes("--stats");
+      await prune(statsFlag);
+      break;
+    }
     case "setup": {
       const { setup } = await import("./setup-AO3MW46W.js");
       await setup();
@@ -439,23 +445,23 @@ async function main() {
       break;
     }
     case "gateway": {
-      const { gateway } = await import("./gateway-EOVQXRON.js");
+      const { gateway } = await import("./gateway-EKMU5D7J.js");
       await gateway();
       break;
     }
     case "startup": {
-      const { installStartup } = await import("./init-W3XGDQ6D.js");
+      const { installStartup } = await import("./init-DLFEGD6O.js");
       installStartup();
       break;
     }
     case "startup-remove": {
-      const { uninstallStartup } = await import("./init-W3XGDQ6D.js");
+      const { uninstallStartup } = await import("./init-DLFEGD6O.js");
       uninstallStartup();
       break;
     }
     case "--version":
     case "-v":
-      console.log("rex-claude v3.0.0");
+      console.log("rex-claude v4.0.0");
       break;
     case "help":
     default:
@@ -474,6 +480,8 @@ ${COLORS.bold}Memory (requires Ollama):${COLORS.reset}
   rex search <query>   Semantic search across past sessions
   rex optimize         Analyze CLAUDE.md with local LLM
   rex optimize --apply Apply optimizations (with backup)
+  rex prune            Cleanup old/duplicate memories
+  rex prune --stats    Show memory database stats
 
 ${COLORS.bold}LLM & Context:${COLORS.reset}
   rex setup            Install Ollama + models + Telegram gateway

package/dist/{init-W3XGDQ6D.js → init-DLFEGD6O.js}

@@ -213,7 +213,7 @@ function uninstallGatewayAgent() {
 function installApp() {
   if (process.platform !== "darwin") return;
   const thisDir = new URL(".", import.meta.url).pathname;
-  const buildApp = join(thisDir, "..", "..", "app", "src-tauri", "target", "release", "bundle", "macos", "REX.app");
+  const buildApp = join(thisDir, "..", "..", "flutter_app", "build", "macos", "Build", "Products", "Release", "rex_app.app");
   const installedApp = "/Applications/REX.app";
   if (existsSync(installedApp)) {
     skip("REX.app already in /Applications");

package/dist/prune-2PPIVDXK.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+
+// src/prune.ts
+import { existsSync, statSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var COLORS = {
+  reset: "\x1B[0m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m"
+};
+var DB_PATH = join(homedir(), ".rex-memory", "db", "rex.sqlite");
+var MAX_AGE_DAYS = 180;
+var MAX_DB_SIZE_MB = 50;
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+async function prune(statsOnly = false) {
+  const line = "\u2550".repeat(45);
+  console.log(`
+${line}`);
+  console.log(`${COLORS.bold}        REX ${statsOnly ? "MEMORY STATS" : "PRUNE"}${COLORS.reset}`);
+  console.log(`${line}
+`);
+  if (!existsSync(DB_PATH)) {
+    console.log(`  ${COLORS.yellow}No memory database found.${COLORS.reset}`);
+    console.log(`  Run ${COLORS.cyan}rex ingest${COLORS.reset} first.
+`);
+    return;
+  }
+  let Database;
+  let sqliteVec;
+  try {
+    Database = (await import("better-sqlite3")).default;
+    sqliteVec = await import("sqlite-vec");
+  } catch {
+    const memDir = join(homedir(), ".rex-memory");
+    if (!existsSync(join(memDir, "node_modules", "better-sqlite3"))) {
+      console.log(`  ${COLORS.yellow}better-sqlite3 not available.${COLORS.reset}`);
+      console.log(`  Ensure @rex/memory is installed: ${COLORS.cyan}cd ~/.rex-memory && npm install${COLORS.reset}
+`);
+      return;
+    }
+    try {
+      Database = (await import(join(memDir, "node_modules", "better-sqlite3", "lib", "index.js"))).default;
+      sqliteVec = await import(join(memDir, "node_modules", "sqlite-vec", "src", "index.js"));
+    } catch (err) {
+      console.log(`  ${COLORS.red}Cannot load database modules:${COLORS.reset} ${err.message}
+`);
+      return;
+    }
+  }
+  const db = new Database(DB_PATH);
+  try {
+    sqliteVec.load(db);
+  } catch {
+  }
+  db.pragma("journal_mode = WAL");
+  const totalMemories = db.prepare("SELECT COUNT(*) as c FROM memories").get().c;
+  const categories = db.prepare("SELECT category, COUNT(*) as c FROM memories GROUP BY category ORDER BY c DESC").all();
+  const projects = db.prepare("SELECT project, COUNT(*) as c FROM memories GROUP BY project ORDER BY c DESC LIMIT 10").all();
+  const ingestFiles = db.prepare("SELECT COUNT(*) as c FROM ingest_log").get().c;
+  const dbSize = statSync(DB_PATH).size;
+  console.log(`  ${COLORS.bold}Database:${COLORS.reset} ${formatSize(dbSize)}`);
+  console.log(`  ${COLORS.bold}Total memories:${COLORS.reset} ${totalMemories}`);
+  console.log(`  ${COLORS.bold}Ingested files:${COLORS.reset} ${ingestFiles}`);
+  console.log();
+  console.log(`  ${COLORS.bold}By category:${COLORS.reset}`);
+  for (const cat of categories) {
+    console.log(`    ${COLORS.cyan}${cat.category}${COLORS.reset}: ${cat.c}`);
+  }
+  console.log();
+  console.log(`  ${COLORS.bold}Top projects:${COLORS.reset}`);
+  for (const proj of projects) {
+    console.log(`    ${COLORS.dim}${proj.project || "(none)"}${COLORS.reset}: ${proj.c}`);
+  }
+  if (statsOnly) {
+    console.log();
+    db.close();
+    return;
+  }
+  const cutoffDate = /* @__PURE__ */ new Date();
+  cutoffDate.setDate(cutoffDate.getDate() - MAX_AGE_DAYS);
+  const cutoff = cutoffDate.toISOString();
+  const oldCount = db.prepare("SELECT COUNT(*) as c FROM memories WHERE created_at < ?").get(cutoff).c;
+  if (oldCount === 0 && dbSize < MAX_DB_SIZE_MB * 1024 * 1024) {
+    console.log(`
+  ${COLORS.green}\u2713${COLORS.reset} Nothing to prune (all memories < ${MAX_AGE_DAYS} days, DB < ${MAX_DB_SIZE_MB}MB)`);
+    db.close();
+    console.log();
+    return;
+  }
+  console.log(`
+  ${COLORS.bold}Pruning:${COLORS.reset}`);
+  if (oldCount > 0) {
+    const oldIds = db.prepare("SELECT id FROM memories WHERE created_at < ?").all(cutoff);
+    const deleteVec = db.prepare("DELETE FROM memory_vec WHERE rowid = ?");
+    const deleteMem = db.prepare("DELETE FROM memories WHERE id = ?");
+    const tx = db.transaction(() => {
+      for (const row of oldIds) {
+        try {
+          deleteVec.run(row.id);
+        } catch {
+        }
+        deleteMem.run(row.id);
+      }
+    });
+    tx();
+    console.log(`    ${COLORS.green}\u2713${COLORS.reset} Removed ${oldCount} memories older than ${MAX_AGE_DAYS} days`);
+  }
+  const dupes = db.prepare(`
+    SELECT id FROM memories WHERE id NOT IN (
+      SELECT MIN(id) FROM memories GROUP BY content
+    )
+  `).all();
+  if (dupes.length > 0) {
+    const deleteVec = db.prepare("DELETE FROM memory_vec WHERE rowid = ?");
+    const deleteMem = db.prepare("DELETE FROM memories WHERE id = ?");
+    const tx = db.transaction(() => {
+      for (const row of dupes) {
+        try {
+          deleteVec.run(row.id);
+        } catch {
+        }
+        deleteMem.run(row.id);
+      }
+    });
+    tx();
+    console.log(`    ${COLORS.green}\u2713${COLORS.reset} Removed ${dupes.length} duplicate memories`);
+  }
+  try {
+    db.exec("VACUUM");
+    const newSize = statSync(DB_PATH).size;
+    console.log(`    ${COLORS.green}\u2713${COLORS.reset} Compacted: ${formatSize(dbSize)} -> ${formatSize(newSize)}`);
+  } catch {
+  }
+  const remaining = db.prepare("SELECT COUNT(*) as c FROM memories").get().c;
+  console.log(`
+  ${COLORS.bold}Remaining:${COLORS.reset} ${remaining} memories`);
+  db.close();
+  console.log();
+}
+export {
+  prune
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rex-claude",
-  "version": "3.0.0",
+  "version": "4.0.0",
   "description": "Claude Code sous steroides — guards, health checks, memory RAG",
   "type": "module",
   "bin": {

package/dist/gateway-EOVQXRON.js

@@ -1,198 +0,0 @@
-#!/usr/bin/env node
-
-// src/gateway.ts
-import { homedir } from "os";
-import { readFileSync } from "fs";
-import { join } from "path";
-import { execSync } from "child_process";
-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 sendMessage(token, chatId, text, parseMode = "Markdown") {
-  try {
-    await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ chat_id: chatId, text, parse_mode: parseMode })
-    });
-  } catch {
-  }
-}
-function runCommand(cmd) {
-  try {
-    return execSync(cmd, { timeout: 3e4, encoding: "utf-8" }).trim();
-  } catch (e) {
-    return e.stderr?.trim() || e.message || "Command failed";
-  }
-}
-async function handleCommand(text) {
-  const cmd = text.trim().toLowerCase();
-  if (cmd === "/status" || cmd === "/s") {
-    const out = runCommand("rex status");
-    return out || "REX status unavailable";
-  }
-  if (cmd === "/doctor" || cmd === "/d") {
-    const out = runCommand("rex doctor");
-    return out.replace(/\x1b\[[0-9;]*m/g, "").slice(0, 4e3);
-  }
-  if (cmd === "/ingest" || cmd === "/i") {
-    const out = runCommand("rex ingest");
-    return `*Ingest*
-\`\`\`
-${out.slice(0, 3e3)}
-\`\`\``;
-  }
-  if (cmd.startsWith("/search ") || cmd.startsWith("/q ")) {
-    const query = text.replace(/^\/(search|q)\s+/i, "");
-    if (!query) return "Usage: /search <query>";
-    const out = runCommand(`rex search ${query}`);
-    return out ? `*Search:* ${query}
-\`\`\`
-${out.slice(0, 3e3)}
-\`\`\`` : "No results";
-  }
-  if (cmd.startsWith("/llm ") || cmd.startsWith("/ask ")) {
-    const prompt = text.replace(/^\/(llm|ask)\s+/i, "");
-    if (!prompt) return "Usage: /llm <prompt>";
-    const out = runCommand(`rex llm "${prompt.replace(/"/g, '\\"')}"`);
-    return out.slice(0, 4e3);
-  }
-  if (cmd === "/optimize" || cmd === "/o") {
-    const out = runCommand("rex optimize");
-    return `*Optimize*
-\`\`\`
-${out.replace(/\x1b\[[0-9;]*m/g, "").slice(0, 3e3)}
-\`\`\``;
-  }
-  if (cmd === "/git" || cmd === "/g") {
-    const branch = runCommand('git branch --show-current 2>/dev/null || echo "n/a"');
-    const status = runCommand("git status --short 2>/dev/null | head -15");
-    const lastCommit = runCommand('git log -1 --format="%s" 2>/dev/null || echo "n/a"');
-    return `*Git*
-Branch: \`${branch}\`
-Last: ${lastCommit}
-\`\`\`
-${status || "Clean"}
-\`\`\``;
-  }
-  if (cmd.startsWith("/sh ") || cmd.startsWith("/run ")) {
-    const shellCmd = text.replace(/^\/(sh|run)\s+/i, "");
-    const blocked = ["rm -rf", "rm -r /", "mkfs", "dd if=", ":(){", "chmod -R 777", "git push --force main", "git push --force master"];
-    if (blocked.some((b) => shellCmd.toLowerCase().includes(b))) {
-      return "Blocked: dangerous command";
-    }
-    const out = runCommand(shellCmd);
-    return `\`$ ${shellCmd}\`
-\`\`\`
-${out.slice(0, 3500)}
-\`\`\``;
-  }
-  if (cmd === "/help" || cmd === "/start" || cmd === "/h") {
-    return `*REX Gateway*
-\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
-/status \u2014 Quick health check
-/doctor \u2014 Full diagnostics
-/ingest \u2014 Sync sessions to memory
-/search <q> \u2014 Semantic search
-/llm <prompt> \u2014 Ask local LLM
-/optimize \u2014 Analyze CLAUDE.md
-/git \u2014 Git status
-/sh <cmd> \u2014 Run shell command
-/help \u2014 This message`;
-  }
-  if (text.length > 3) {
-    try {
-      const check = await fetch("http://localhost:11434/api/tags");
-      if (check.ok) {
-        const out = runCommand(`rex llm "${text.replace(/"/g, '\\"')}"`);
-        if (out && !out.includes("rex-claude") && !out.includes("Commands:")) {
-          return out.slice(0, 4e3);
-        }
-      }
-    } catch {
-    }
-    return `Unknown command: "${text.slice(0, 50)}"
-Send /help for available commands.`;
-  }
-  return "Send /help for available commands.";
-}
-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;
-  console.log(`${COLORS.bold}REX Gateway${COLORS.reset} \u2014 Telegram long-polling active`);
-  console.log(`${COLORS.dim}Bot token: ...${token.slice(-8)}${COLORS.reset}`);
-  console.log(`${COLORS.dim}Chat ID: ${chatId}${COLORS.reset}`);
-  console.log(`${COLORS.dim}Press 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 sendMessage(token, chatId, "\u{1F7E2} *REX Gateway* started\nSend /help for commands.");
-  const POLL_TIMEOUT = 30;
-  process.on("SIGINT", async () => {
-    console.log(`
-${COLORS.dim}Shutting down...${COLORS.reset}`);
-    await sendMessage(token, chatId, "\u{1F534} *REX Gateway* stopped");
-    process.exit(0);
-  });
-  while (true) {
-    try {
-      const res = await fetch(
-        `https://api.telegram.org/bot${token}/getUpdates?offset=${offset}&timeout=${POLL_TIMEOUT}&allowed_updates=["message"]`
-      );
-      const data = await res.json();
-      if (!data.ok || !data.result?.length) continue;
-      for (const update of data.result) {
-        offset = update.update_id + 1;
-        const msg = update.message;
-        if (!msg?.text) continue;
-        if (String(msg.chat.id) !== chatId) {
-          console.log(`${COLORS.yellow}Ignored message from chat ${msg.chat.id}${COLORS.reset}`);
-          continue;
-        }
-        const from = msg.from?.username ?? "?";
-        console.log(`${COLORS.cyan}@${from}${COLORS.reset}: ${msg.text}`);
-        const reply = await handleCommand(msg.text);
-        await sendMessage(token, chatId, reply);
-        console.log(`${COLORS.green}\u2192${COLORS.reset} ${reply.slice(0, 80)}...`);
-      }
-    } catch (err) {
-      console.error(`${COLORS.red}Poll error:${COLORS.reset} ${err.message}`);
-      await new Promise((r) => setTimeout(r, 5e3));
-    }
-  }
-}
-export {
-  gateway
-};