whats-mcp 0.1.0

package/src/admin/service.js

@@ -0,0 +1,271 @@
+/**
+ * whats-mcp — shared admin helpers.
+ */
+
+"use strict";
+
+const { spawn } = require("child_process");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const { loadConfig } = require("../config");
+const { getConnectionInfo } = require("../connection");
+
+function stateDir() {
+  const cfg = loadConfig();
+  return (cfg.server?.state_directory || "~/.mcps/whatsapp").replace(/^~/, os.homedir());
+}
+
+function authDir() {
+  return path.join(stateDir(), "auth");
+}
+
+function pidFile() {
+  return path.join(stateDir(), "whats-mcp.pid");
+}
+
+function logFile() {
+  return path.join(stateDir(), "whats-mcp.log");
+}
+
+function appendAdminLog(message) {
+  fs.mkdirSync(stateDir(), { recursive: true });
+  const line = `${new Date().toISOString()} ${message}\n`;
+  fs.appendFileSync(logFile(), line, "utf-8");
+}
+
+function authExists() {
+  const dir = authDir();
+  return fs.existsSync(dir) && fs.readdirSync(dir).length > 0;
+}
+
+function readPid() {
+  try {
+    return parseInt(fs.readFileSync(pidFile(), "utf-8").trim(), 10);
+  } catch {
+    return null;
+  }
+}
+
+function isRunning(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function authSummary() {
+  return {
+    state_directory: stateDir(),
+    auth_directory: authDir(),
+    auth_present: authExists(),
+    pid: readPid(),
+    running: isRunning(readPid()),
+    connection: getConnectionInfo(),
+  };
+}
+
+const PAIRING_RUNTIME = {
+  active: false,
+  phone: null,
+  started_at: null,
+  pairing_code: null,
+  last_error: null,
+};
+
+function statusSummaryText(overrides = {}) {
+  const cfg = loadConfig();
+  const summary = authSummary();
+  const pid = overrides.pid ?? summary.pid;
+  const running = overrides.running ?? summary.running;
+  const connectionState = overrides.connection_state ?? summary.connection.state;
+  const user = overrides.user ?? summary.connection.user;
+  const lines = [
+    "whats-admin status",
+    `- service: ${cfg.server.name} ${cfg.server.version}`,
+    `- state directory: ${summary.state_directory}`,
+    `- auth persisted: ${summary.auth_present ? "yes" : "no"}`,
+    `- server running: ${running ? `yes (pid ${pid})` : "no"}`,
+    `- connection state: ${connectionState}`,
+  ];
+  if (user) {
+    lines.push(`- account: ${user.name || "?"} (${user.phone || "?"})`);
+  }
+  return lines.join("\n");
+}
+
+function healthSummaryText() {
+  const cfg = loadConfig();
+  return [
+    "whats-mcp health",
+    `- public: ${cfg.server.public_base_url}`,
+    `- fallback: ${cfg.server.fallback_base_url}`,
+    `- mcp: ${cfg.server.public_base_url}${cfg.server.http_mcp_path}`,
+    `- local port: ${cfg.server.http_port}`,
+  ].join("\n");
+}
+
+function urlsSummary() {
+  const cfg = loadConfig();
+  return [
+    "whats-mcp URLs",
+    `- public: ${cfg.server.public_base_url}`,
+    `- fallback: ${cfg.server.fallback_base_url}`,
+    `- mcp: ${cfg.server.public_base_url}${cfg.server.http_mcp_path}`,
+    `- health: ${cfg.server.public_base_url}/health`,
+    `- admin status: ${cfg.server.public_base_url}/admin/status`,
+    `- admin help: ${cfg.server.public_base_url}/admin/help`,
+  ].join("\n");
+}
+
+function adminHelpText() {
+  return [
+    "whats-admin capabilities",
+    "- CLI:",
+    "  - whats-admin status",
+    "  - whats-admin guide",
+    "  - whats-admin login [--code] [--phone N]",
+    "  - whats-admin logout [-f]",
+    "  - whats-admin server status|stop|restart|reconnect|pid|test",
+    "  - whats-admin config show|edit|reset|path",
+    "  - whats-admin logs show|tail|clean|path",
+    "- HTTP:",
+    "  - GET /health",
+    "  - GET /admin/status",
+    "  - GET /admin/help",
+    "  - POST /admin/reconnect",
+    "  - POST /admin/pair-code {\"phone\":\"33612345678\"}",
+    "- Telegram:",
+    "  - /start",
+    "  - /help",
+    "  - /status",
+    "  - /health",
+    "  - /urls",
+    "  - /logs [lines]",
+    "  - /pair_code <phone>",
+    "  - /reconnect",
+    "  - /restart",
+  ].join("\n");
+}
+
+function normalizePhoneNumber(raw) {
+  return String(raw || "").replace(/[^\d]/g, "");
+}
+
+function pairingRuntimeStatus() {
+  return { ...PAIRING_RUNTIME };
+}
+
+function requestPairingCode(phone) {
+  const normalizedPhone = normalizePhoneNumber(phone);
+  if (!normalizedPhone || !/^\d{8,15}$/.test(normalizedPhone)) {
+    throw new Error("Invalid phone number. Use country code; separators are allowed and will be stripped.");
+  }
+  if (PAIRING_RUNTIME.active) {
+    const activeFor = PAIRING_RUNTIME.phone || "another number";
+    throw new Error(`A pairing flow is already active for ${activeFor}. Finish or wait for it to time out.`);
+  }
+
+  return new Promise((resolve, reject) => {
+    const cliEntry = path.join(__dirname, "..", "admin.js");
+    const child = spawn(
+      process.execPath,
+      [cliEntry, "login", "--code", "--phone", normalizedPhone, "--force"],
+      {
+        cwd: path.resolve(__dirname, ".."),
+        env: { ...process.env, NO_COLOR: "1" },
+        stdio: ["ignore", "pipe", "pipe"],
+      },
+    );
+
+    PAIRING_RUNTIME.active = true;
+    PAIRING_RUNTIME.phone = normalizedPhone;
+    PAIRING_RUNTIME.started_at = Math.floor(Date.now() / 1000);
+    PAIRING_RUNTIME.pairing_code = null;
+    PAIRING_RUNTIME.last_error = null;
+
+    const cleanup = (errorMessage = null) => {
+      PAIRING_RUNTIME.active = false;
+      PAIRING_RUNTIME.phone = null;
+      PAIRING_RUNTIME.started_at = null;
+      if (errorMessage) {
+        PAIRING_RUNTIME.last_error = errorMessage;
+      }
+    };
+
+    let settled = false;
+    const handleChunk = (chunk) => {
+      const text = String(chunk || "");
+      const plainText = text.replace(/\x1B\[[0-9;]*m/g, "");
+      const match = plainText.match(/Pairing Code:\s*([A-Z0-9-]+)/i);
+      if (!match || settled) return;
+      settled = true;
+      const code = match[1];
+      PAIRING_RUNTIME.pairing_code = code;
+      appendAdminLog(`pairing code generated for ${normalizedPhone}`);
+      resolve({
+        phone: normalizedPhone,
+        code,
+      });
+    };
+
+    child.stdout.on("data", handleChunk);
+    child.stderr.on("data", handleChunk);
+
+    child.on("error", (error) => {
+      cleanup(error.message || String(error));
+      if (!settled) {
+        settled = true;
+        reject(error);
+      }
+    });
+
+    child.on("exit", (code, signal) => {
+      const errorMessage =
+        code === 0 && !signal
+          ? null
+          : `pairing helper exited with code=${code ?? "null"} signal=${signal ?? "null"}`;
+      cleanup(errorMessage);
+      if (!settled) {
+        settled = true;
+        reject(new Error(PAIRING_RUNTIME.last_error || "Pairing flow ended before a code was produced."));
+      }
+    });
+  });
+}
+
+function getLogsText(limit = 50) {
+  const file = logFile();
+  if (!fs.existsSync(file)) {
+    return "No admin log lines available.";
+  }
+  const lines = fs.readFileSync(file, "utf-8").split(/\r?\n/).filter(Boolean);
+  if (lines.length === 0) {
+    return "No admin log lines available.";
+  }
+  return lines.slice(-Math.max(1, limit)).join("\n");
+}
+
+module.exports = {
+  adminHelpText,
+  authDir,
+  authExists,
+  authSummary,
+  appendAdminLog,
+  getLogsText,
+  healthSummaryText,
+  isRunning,
+  logFile,
+  normalizePhoneNumber,
+  pairingRuntimeStatus,
+  pidFile,
+  requestPairingCode,
+  readPid,
+  stateDir,
+  statusSummaryText,
+  urlsSummary,
+};

package/src/admin/telegram.js

@@ -0,0 +1,178 @@
+/**
+ * whats-mcp — Telegram admin bridge.
+ */
+
+"use strict";
+
+const {
+  adminHelpText,
+  appendAdminLog,
+  getLogsText,
+  healthSummaryText,
+  requestPairingCode,
+  statusSummaryText,
+  urlsSummary,
+} = require("./service");
+
+const TELEGRAM_RUNTIME = {
+  enabled: false,
+  started: false,
+  thread_alive: false,
+  allowed_chat_ids: [],
+  allowed_chat_count: 0,
+  started_at: null,
+  last_poll_at: null,
+  last_success_at: null,
+  last_update_id: null,
+  last_chat_id: null,
+  last_command: null,
+  last_reply_preview: null,
+  last_error: null,
+};
+
+let pollerHandle = null;
+
+function telegramAdminEnabled() {
+  return Boolean(process.env.TELEGRAM_WHATS_HOMELAB_TOKEN && process.env.TELEGRAM_CHAT_IDS);
+}
+
+function telegramAdminRuntimeStatus() {
+  return { ...TELEGRAM_RUNTIME };
+}
+
+async function apiCall(method, body) {
+  const token = process.env.TELEGRAM_WHATS_HOMELAB_TOKEN;
+  const response = await fetch(`https://api.telegram.org/bot${token}/${method}`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  const payload = await response.json();
+  if (!payload.ok) {
+    throw new Error(payload.description || `Telegram API call failed: ${method}`);
+  }
+  return payload.result;
+}
+
+async function sendMessage(chatId, text) {
+  await apiCall("sendMessage", { chat_id: chatId, text });
+}
+
+function parseAllowedChatIds() {
+  return String(process.env.TELEGRAM_CHAT_IDS || "")
+    .split(",")
+    .map((value) => value.trim())
+    .filter(Boolean);
+}
+
+async function dispatchTelegramCommand(command, args, handlers = {}) {
+  const onReconnect = handlers.onReconnect || null;
+  const onRestart = handlers.onRestart || null;
+  if (command === "/start" || command === "/help") return adminHelpText();
+  if (command === "/status") return statusSummaryText();
+  if (command === "/health") return healthSummaryText();
+  if (command === "/urls") return urlsSummary();
+  if (command === "/logs") {
+    const limit = Number.parseInt(args[0] || "20", 10);
+    return getLogsText(Number.isNaN(limit) ? 20 : limit);
+  }
+  if (command === "/pair_code") {
+    if (!args[0]) {
+      return "Usage: /pair_code <phone>";
+    }
+    const pairing = await requestPairingCode(args[0]);
+    return [
+      "whats-mcp pairing code",
+      `- phone: ${pairing.phone}`,
+      `- code: ${pairing.code}`,
+      "- go to WhatsApp → Linked Devices → Link with Phone Number",
+      "- enter the code on your phone before it expires",
+    ].join("\n");
+  }
+  if (command === "/reconnect") {
+    if (onReconnect) {
+      await onReconnect();
+    }
+    return "whats-mcp reconnect requested";
+  }
+  if (command === "/restart") {
+    if (onRestart) {
+      setTimeout(() => onRestart(), 1000);
+    }
+    return "whats-mcp restart requested";
+  }
+  return "Unknown command. Use /help.";
+}
+
+function startTelegramAdmin(handlers = {}) {
+  if (pollerHandle || !telegramAdminEnabled()) {
+    return;
+  }
+  const allowedChatIds = parseAllowedChatIds();
+  TELEGRAM_RUNTIME.enabled = true;
+  TELEGRAM_RUNTIME.started = true;
+  TELEGRAM_RUNTIME.thread_alive = true;
+  TELEGRAM_RUNTIME.allowed_chat_ids = allowedChatIds;
+  TELEGRAM_RUNTIME.allowed_chat_count = allowedChatIds.length;
+  TELEGRAM_RUNTIME.started_at = Math.floor(Date.now() / 1000);
+
+  let offset = 0;
+
+  const pollOnce = async ({ discardBacklog = false } = {}) => {
+    TELEGRAM_RUNTIME.last_poll_at = Math.floor(Date.now() / 1000);
+    const updates = await apiCall("getUpdates", {
+      timeout: 0,
+      offset,
+      allowed_updates: ["message"],
+    });
+    TELEGRAM_RUNTIME.last_success_at = Math.floor(Date.now() / 1000);
+    if (discardBacklog) {
+      if (updates.length > 0) {
+        const latestUpdate = updates[updates.length - 1];
+        offset = latestUpdate.update_id + 1;
+        TELEGRAM_RUNTIME.last_update_id = latestUpdate.update_id;
+        appendAdminLog(`telegram backlog discarded count=${updates.length} last_update_id=${latestUpdate.update_id}`);
+      }
+      TELEGRAM_RUNTIME.last_error = null;
+      return;
+    }
+    for (const update of updates) {
+      offset = update.update_id + 1;
+      TELEGRAM_RUNTIME.last_update_id = update.update_id;
+      const message = update.message;
+      if (!message || !message.text) continue;
+      const chatId = String(message.chat.id);
+      TELEGRAM_RUNTIME.last_chat_id = chatId;
+      if (!allowedChatIds.includes(chatId)) continue;
+      const [command, ...args] = message.text.trim().split(/\s+/);
+      TELEGRAM_RUNTIME.last_command = command;
+      const reply = await dispatchTelegramCommand(command, args, handlers);
+      TELEGRAM_RUNTIME.last_reply_preview = reply.slice(0, 120);
+      appendAdminLog(`telegram command chat=${chatId} command=${command}`);
+      await sendMessage(chatId, reply);
+      appendAdminLog(`telegram reply chat=${chatId} preview=${reply.slice(0, 120)}`);
+    }
+    TELEGRAM_RUNTIME.last_error = null;
+  };
+
+  pollOnce({ discardBacklog: true }).catch((error) => {
+    TELEGRAM_RUNTIME.last_error = error.message || String(error);
+    appendAdminLog(`telegram bootstrap error ${TELEGRAM_RUNTIME.last_error}`);
+  });
+
+  pollerHandle = setInterval(async () => {
+    try {
+      await pollOnce();
+    } catch (error) {
+      TELEGRAM_RUNTIME.last_error = error.message || String(error);
+      appendAdminLog(`telegram error ${TELEGRAM_RUNTIME.last_error}`);
+    }
+  }, 5000);
+}
+
+module.exports = {
+  dispatchTelegramCommand,
+  startTelegramAdmin,
+  telegramAdminEnabled,
+  telegramAdminRuntimeStatus,
+};

package/src/admin.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+"use strict";
+
+const { program } = require("./admin/cli");
+
+if (require.main === module) {
+  program.parse(process.argv);
+}
+
+module.exports = {
+  program,
+};

package/src/config.js

@@ -0,0 +1,147 @@
+/**
+ * whats-mcp — Configuration loader.
+ *
+ * Loads package-internal .env defaults, then config.json, then
+ * environment variable overrides.
+ */
+
+"use strict";
+
+const fs   = require("fs");
+const path = require("path");
+
+const CONFIG_FILE = path.join(__dirname, "..", "config.json");
+const PACKAGE_JSON = require(path.join(__dirname, "..", "package.json"));
+const ENV_FILE = path.join(__dirname, ".env");
+
+const DEFAULTS = {
+  server: {
+    state_directory: "~/.mcps/whatsapp",
+    http_host: "127.0.0.1",
+    http_port: 8092,
+    http_mcp_path: "/mcp",
+    public_base_url: "https://whats.kpihx-labs.com",
+    fallback_base_url: "https://whats.homelab",
+  },
+  connection: {
+    print_qr_in_terminal: true,
+    reconnect_interval_ms: 3000,
+    max_reconnect_attempts: 10,
+    mark_online_on_connect: false,
+    sync_full_history: true,
+    refresh_app_state_on_open: true,
+  },
+  store: {
+    max_messages_per_chat: 5000,
+    max_chats: 1000,
+    persist: true,
+  },
+  logging: {
+    level: "error",
+  },
+  watchlists: {},
+};
+
+/**
+ * Deep-merge b into a (b wins). Mutates a.
+ */
+function _merge(a, b) {
+  for (const key of Object.keys(b)) {
+    if (
+      a[key] &&
+      typeof a[key] === "object" &&
+      !Array.isArray(a[key]) &&
+      typeof b[key] === "object" &&
+      !Array.isArray(b[key])
+    ) {
+      _merge(a[key], b[key]);
+    } else {
+      a[key] = b[key];
+    }
+  }
+  return a;
+}
+
+function _loadEnvDefaults() {
+  if (!fs.existsSync(ENV_FILE)) {
+    return;
+  }
+  const raw = fs.readFileSync(ENV_FILE, "utf-8");
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const idx = trimmed.indexOf("=");
+    if (idx === -1) {
+      continue;
+    }
+    const key = trimmed.slice(0, idx).trim();
+    const value = trimmed.slice(idx + 1);
+    if (!process.env[key]) {
+      process.env[key] = value;
+    }
+  }
+}
+
+/**
+ * Load and return the merged configuration.
+ */
+function loadConfig() {
+  _loadEnvDefaults();
+  const config = JSON.parse(JSON.stringify(DEFAULTS));
+  config.server.name = PACKAGE_JSON.name;
+  config.server.version = PACKAGE_JSON.version;
+
+  // Load config.json if it exists
+  if (fs.existsSync(CONFIG_FILE)) {
+    const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
+    const fileConfig = JSON.parse(raw);
+    _merge(config, fileConfig);
+  }
+
+  // Environment variable overrides
+  if (process.env.WHATSAPP_STATE_DIR) {
+    config.server.state_directory = process.env.WHATSAPP_STATE_DIR;
+  }
+  if (process.env.WHATSAPP_LOG_LEVEL) {
+    config.logging.level = process.env.WHATSAPP_LOG_LEVEL;
+  }
+  if (process.env.WHATSAPP_MAX_RECONNECT) {
+    config.connection.max_reconnect_attempts = parseInt(process.env.WHATSAPP_MAX_RECONNECT, 10);
+  }
+  if (process.env.WHATSAPP_PRINT_QR !== undefined) {
+    config.connection.print_qr_in_terminal = process.env.WHATSAPP_PRINT_QR !== "false";
+  }
+  if (process.env.WHATSAPP_SYNC_FULL_HISTORY !== undefined) {
+    config.connection.sync_full_history = process.env.WHATSAPP_SYNC_FULL_HISTORY !== "false";
+  }
+  if (process.env.WHATSAPP_REFRESH_APP_STATE !== undefined) {
+    config.connection.refresh_app_state_on_open = process.env.WHATSAPP_REFRESH_APP_STATE !== "false";
+  }
+  if (process.env.WHATSAPP_PERSIST_STORE !== undefined) {
+    config.store.persist = process.env.WHATSAPP_PERSIST_STORE !== "false";
+  }
+  if (process.env.WHATSAPP_MAX_MESSAGES_PER_CHAT) {
+    config.store.max_messages_per_chat = parseInt(process.env.WHATSAPP_MAX_MESSAGES_PER_CHAT, 10);
+  }
+  if (process.env.WHATS_MCP_HTTP_HOST) {
+    config.server.http_host = process.env.WHATS_MCP_HTTP_HOST;
+  }
+  if (process.env.WHATS_MCP_HTTP_PORT) {
+    config.server.http_port = parseInt(process.env.WHATS_MCP_HTTP_PORT, 10);
+  }
+  if (process.env.WHATS_MCP_HTTP_MCP_PATH) {
+    config.server.http_mcp_path = process.env.WHATS_MCP_HTTP_MCP_PATH;
+  }
+  if (process.env.WHATS_MCP_PUBLIC_BASE_URL) {
+    config.server.public_base_url = process.env.WHATS_MCP_PUBLIC_BASE_URL;
+  }
+  if (process.env.WHATS_MCP_FALLBACK_BASE_URL) {
+    config.server.fallback_base_url = process.env.WHATS_MCP_FALLBACK_BASE_URL;
+  }
+
+  return config;
+}
+
+module.exports = { loadConfig, DEFAULTS };