@chrysb/alphaclaw 0.2.2 → 0.3.0

package/lib/server/watchdog-db.js

@@ -0,0 +1,148 @@
+const fs = require("fs");
+const path = require("path");
+const { DatabaseSync } = require("node:sqlite");
+
+let db = null;
+let pruneTimer = null;
+
+const kDefaultLimit = 20;
+const kMaxLimit = 200;
+const kPruneIntervalMs = 12 * 60 * 60 * 1000;
+
+const ensureDb = () => {
+  if (!db) throw new Error("Watchdog DB not initialized");
+  return db;
+};
+
+const createSchema = (database) => {
+  database.exec(`
+    CREATE TABLE IF NOT EXISTS watchdog_events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      event_type TEXT NOT NULL,
+      source TEXT NOT NULL,
+      status TEXT NOT NULL,
+      details TEXT,
+      correlation_id TEXT,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now'))
+    );
+  `);
+  database.exec(`
+    CREATE INDEX IF NOT EXISTS idx_watchdog_events_ts
+    ON watchdog_events(created_at DESC);
+  `);
+};
+
+const initWatchdogDb = ({ rootDir, pruneDays = 30 }) => {
+  const dbDir = path.join(rootDir, "db");
+  fs.mkdirSync(dbDir, { recursive: true });
+  const dbPath = path.join(dbDir, "watchdog.db");
+  db = new DatabaseSync(dbPath);
+  createSchema(db);
+  pruneWatchdogEvents(pruneDays);
+  if (pruneTimer) clearInterval(pruneTimer);
+  pruneTimer = setInterval(() => {
+    try {
+      pruneWatchdogEvents(pruneDays);
+    } catch (err) {
+      console.error(`[watchdog-db] prune error: ${err.message}`);
+    }
+  }, kPruneIntervalMs);
+  if (typeof pruneTimer.unref === "function") pruneTimer.unref();
+  return { path: dbPath };
+};
+
+const insertWatchdogEvent = ({
+  eventType,
+  source,
+  status,
+  details = null,
+  correlationId = "",
+}) => {
+  const database = ensureDb();
+  const stmt = database.prepare(`
+    INSERT INTO watchdog_events (
+      event_type,
+      source,
+      status,
+      details,
+      correlation_id
+    ) VALUES (
+      $event_type,
+      $source,
+      $status,
+      $details,
+      $correlation_id
+    )
+  `);
+  const result = stmt.run({
+    $event_type: String(eventType || ""),
+    $source: String(source || ""),
+    $status: String(status || "failed"),
+    $details:
+      details == null
+        ? null
+        : typeof details === "string"
+          ? details
+          : JSON.stringify(details),
+    $correlation_id: String(correlationId || ""),
+  });
+  return Number(result.lastInsertRowid || 0);
+};
+
+const getRecentEvents = ({ limit = kDefaultLimit, includeRoutine = false } = {}) => {
+  const database = ensureDb();
+  const safeLimit = Math.max(
+    1,
+    Math.min(Number.parseInt(String(limit || kDefaultLimit), 10) || kDefaultLimit, kMaxLimit),
+  );
+  const whereClause = includeRoutine
+    ? ""
+    : "WHERE NOT (event_type = 'health_check' AND status = 'ok')";
+  const rows = database
+    .prepare(`
+      SELECT id, event_type, source, status, details, correlation_id, created_at
+      FROM watchdog_events
+      ${whereClause}
+      ORDER BY created_at DESC
+      LIMIT $limit
+    `)
+    .all({ $limit: safeLimit });
+  const mapped = rows.map((row) => {
+    let parsedDetails = row.details;
+    if (typeof row.details === "string" && row.details) {
+      try {
+        parsedDetails = JSON.parse(row.details);
+      } catch {}
+    }
+    return {
+      id: row.id,
+      eventType: row.event_type,
+      source: row.source,
+      status: row.status,
+      details: parsedDetails,
+      correlationId: row.correlation_id || "",
+      createdAt: row.created_at,
+    };
+  });
+  return mapped;
+};
+
+const pruneWatchdogEvents = (days = 30) => {
+  const database = ensureDb();
+  const safeDays = Math.max(1, Number.parseInt(String(days || 30), 10) || 30);
+  const modifier = `-${safeDays} days`;
+  const result = database
+    .prepare(`
+      DELETE FROM watchdog_events
+      WHERE created_at < strftime('%Y-%m-%dT%H:%M:%fZ', 'now', $modifier)
+    `)
+    .run({ $modifier: modifier });
+  return Number(result.changes || 0);
+};
+
+module.exports = {
+  initWatchdogDb,
+  insertWatchdogEvent,
+  getRecentEvents,
+  pruneWatchdogEvents,
+};

package/lib/server/watchdog-notify.js

@@ -0,0 +1,93 @@
+const fs = require("fs");
+const path = require("path");
+const { OPENCLAW_DIR } = require("./constants");
+
+const getPairedIds = (channel) => {
+  const safeChannel = String(channel || "").trim().toLowerCase();
+  if (!safeChannel) return [];
+  const credentialsDir = path.join(OPENCLAW_DIR, "credentials");
+  if (!fs.existsSync(credentialsDir)) return [];
+  const ids = new Set();
+  try {
+    const files = fs
+      .readdirSync(credentialsDir)
+      .filter(
+        (fileName) =>
+          fileName.startsWith(`${safeChannel}-`) && fileName.endsWith("-allowFrom.json"),
+      );
+    for (const fileName of files) {
+      const filePath = path.join(credentialsDir, fileName);
+      const raw = fs.readFileSync(filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      const allowFrom = Array.isArray(parsed?.allowFrom) ? parsed.allowFrom : [];
+      for (const id of allowFrom) {
+        if (id == null) continue;
+        const value = String(id).trim();
+        if (!value) continue;
+        ids.add(value);
+      }
+    }
+  } catch (err) {
+    console.error(`[watchdog] could not resolve ${safeChannel} allowFrom IDs: ${err.message}`);
+  }
+  return Array.from(ids);
+};
+
+const formatDiscordMessage = (message) => String(message || "");
+
+const createWatchdogNotifier = ({ telegramApi, discordApi }) => {
+  const notify = async (message) => {
+    const summary = {
+      telegram: { sent: 0, failed: 0, skipped: false, targets: 0 },
+      discord: { sent: 0, failed: 0, skipped: false, targets: 0 },
+    };
+    const telegramTargets = getPairedIds("telegram");
+    summary.telegram.targets = telegramTargets.length;
+    if (!telegramApi?.sendMessage || !process.env.TELEGRAM_BOT_TOKEN || telegramTargets.length === 0) {
+      summary.telegram.skipped = true;
+    } else {
+      for (const chatId of telegramTargets) {
+        try {
+          await telegramApi.sendMessage(chatId, String(message || ""), {
+            parseMode: "Markdown",
+          });
+          summary.telegram.sent += 1;
+        } catch (err) {
+          summary.telegram.failed += 1;
+          console.error(`[watchdog] telegram notification failed for ${chatId}: ${err.message}`);
+        }
+      }
+    }
+
+    const discordTargets = getPairedIds("discord");
+    summary.discord.targets = discordTargets.length;
+    if (!discordApi?.sendDirectMessage || !process.env.DISCORD_BOT_TOKEN || discordTargets.length === 0) {
+      summary.discord.skipped = true;
+    } else {
+      const discordMessage = formatDiscordMessage(message);
+      for (const userId of discordTargets) {
+        try {
+          await discordApi.sendDirectMessage(userId, discordMessage);
+          summary.discord.sent += 1;
+        } catch (err) {
+          summary.discord.failed += 1;
+          console.error(`[watchdog] discord notification failed for ${userId}: ${err.message}`);
+        }
+      }
+    }
+
+    const sent = summary.telegram.sent + summary.discord.sent;
+    const failed = summary.telegram.failed + summary.discord.failed;
+    return {
+      ok: sent > 0,
+      sent,
+      failed,
+      channels: summary,
+      ...(sent === 0 ? { reason: "no_channels_delivered" } : {}),
+    };
+  };
+
+  return { notify };
+};
+
+module.exports = { createWatchdogNotifier };