mslxdff 0.1.2 → 0.1.3

package/src/daemon.js

@@ -1,63 +1,63 @@
-import { spawn } from "node:child_process";
-import { existsSync, mkdirSync, openSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
-import { join, dirname } from "node:path";
-import os from "node:os";
-import { fileURLToPath } from "node:url";
-
-export function daemonDir() {
-  return process.env.MSLXDFF_DAEMON_DIR || join(os.homedir(), ".config", "mslxdff");
-}
-
-export function pidFile() {
-  return join(daemonDir(), "daemon.pid");
-}
-
-export function logFile() {
-  return join(daemonDir(), "daemon.log");
-}
-
-export function startDaemon(args = []) {
-  const here = fileURLToPath(import.meta.url);
-  const entry = here.endsWith("bin/mslxdff.js")
-    ? here
-    : join(dirname(here), "..", "bin", "mslxdff.js");
-  const dir = daemonDir();
-  mkdirSync(dir, { recursive: true });
-  const logFd = openSync(logFile(), "a", 0o600);
-  const child = spawn(process.execPath, [entry, ...args, "--daemon"], {
-    detached: true,
-    stdio: ["ignore", logFd, logFd],
-    env: { ...process.env, MSLXDFF_DAEMON: "1" },
-  });
-  child.unref();
-  return child.pid;
-}
-
-export function writePid(pid) {
-  const dir = daemonDir();
-  mkdirSync(dir, { recursive: true });
-  writeFileSync(pidFile(), String(pid), { mode: 0o600 });
-}
-
-export function readPid() {
-  if (!existsSync(pidFile())) return null;
-  const raw = readFileSync(pidFile(), "utf8").trim();
-  const n = Number(raw);
-  return Number.isInteger(n) && n > 0 ? n : null;
-}
-
-export function stopDaemon() {
-  const pid = readPid();
-  if (!pid) return { stopped: false, reason: "no pid file" };
-  try {
-    process.kill(pid, "SIGTERM");
-  } catch (err) {
-    if (err.code !== "ESRCH") throw err;
-  }
-  try {
-    unlinkSync(pidFile());
-  } catch {
-    // already gone
-  }
-  return { stopped: true, pid };
-}
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, openSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
+import { join, dirname } from "node:path";
+import os from "node:os";
+import { fileURLToPath } from "node:url";
+
+export function daemonDir() {
+  return process.env.MSLXDFF_DAEMON_DIR || join(os.homedir(), ".config", "mslxdff");
+}
+
+export function pidFile() {
+  return join(daemonDir(), "daemon.pid");
+}
+
+export function logFile() {
+  return join(daemonDir(), "daemon.log");
+}
+
+export function startDaemon(args = []) {
+  const here = fileURLToPath(import.meta.url);
+  const entry = here.endsWith("bin/mslxdff.js")
+    ? here
+    : join(dirname(here), "..", "bin", "mslxdff.js");
+  const dir = daemonDir();
+  mkdirSync(dir, { recursive: true });
+  const logFd = openSync(logFile(), "a", 0o600);
+  const child = spawn(process.execPath, [entry, ...args, "--daemon"], {
+    detached: true,
+    stdio: ["ignore", logFd, logFd],
+    env: { ...process.env, MSLXDFF_DAEMON: "1" },
+  });
+  child.unref();
+  return child.pid;
+}
+
+export function writePid(pid) {
+  const dir = daemonDir();
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(pidFile(), String(pid), { mode: 0o600 });
+}
+
+export function readPid() {
+  if (!existsSync(pidFile())) return null;
+  const raw = readFileSync(pidFile(), "utf8").trim();
+  const n = Number(raw);
+  return Number.isInteger(n) && n > 0 ? n : null;
+}
+
+export function stopDaemon() {
+  const pid = readPid();
+  if (!pid) return { stopped: false, reason: "no pid file" };
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch (err) {
+    if (err.code !== "ESRCH") throw err;
+  }
+  try {
+    unlinkSync(pidFile());
+  } catch {
+    // already gone
+  }
+  return { stopped: true, pid };
+}

package/src/groups.js

@@ -0,0 +1,189 @@
+import { timingSafeEqual, createHash } from "node:crypto";
+import { loadGroups, saveGroups, loadBans, saveBans } from "./state.js";
+import { normalizePeerUrl } from "./peers.js";
+
+export const DEFAULT_GROUP_SYNC_MS = 60_000;
+export const DEFAULT_BAN_WINDOW_MS = 48 * 60 * 60 * 1000;
+export const DEFAULT_BAN_THRESHOLD = 5;
+const SYNC_TIMEOUT_MS = 15_000;
+
+function digestKey(key) {
+  return createHash("sha256").update(String(key || "")).digest();
+}
+
+export function verifyGroupKey(provided, expected) {
+  if (typeof provided !== "string" || typeof expected !== "string") return false;
+  return timingSafeEqual(digestKey(provided), digestKey(expected));
+}
+
+// Leader side: create a group. The group name IS the password — anyone who
+// knows the name can join, so pick something unguessable.
+export function createGroup(name, { file, key = name } = {}) {
+  if (!name) throw new Error("group name is required");
+  const groups = loadGroups(file ? { file } : {});
+  if (groups[name]) return { name, key: groups[name].key, created: false };
+  groups[name] = { key, members: {} };
+  saveGroups(groups, file ? { file } : {});
+  return { name, key, created: true };
+}
+
+// Leader side: add a member after verifying the join key.
+export function addGroupMember(name, { key, memberName, url, token, file } = {}) {
+  const groups = loadGroups(file ? { file } : {});
+  const group = groups[name];
+  if (!group) throw new Error(`group "${name}" not found on this node`);
+  if (!verifyGroupKey(key, group.key)) throw new Error("invalid group key");
+  if (!url) throw new Error("member url is required");
+  const id = memberName || url;
+  group.members[id] = { url, token: token || "" };
+  saveGroups(groups, file ? { file } : {});
+  return group.members;
+}
+
+// Leader side: upsert a member without key verification (used by the sync
+// path after the member's bearer token has already been validated).
+export function upsertMember(name, { memberName, url, token, file } = {}) {
+  const groups = loadGroups(file ? { file } : {});
+  const group = groups[name];
+  if (!group) return null;
+  if (!url) throw new Error("member url is required");
+  const id = memberName || url;
+  group.members[id] = { url, token: token || "" };
+  saveGroups(groups, file ? { file } : {});
+  return group.members;
+}
+
+// Leader side: confirm a bearer token matches a registered member, then return
+// the member list. Used by the sync path (registered members re-registering).
+export function membersForToken(name, providedToken, { file } = {}) {
+  if (typeof providedToken !== "string" || !providedToken) return null;
+  const groups = loadGroups(file ? { file } : {});
+  const group = groups[name];
+  if (!group) return null;
+  const hit = Object.entries(group.members || {}).find(([, m]) =>
+    typeof m.token === "string" && m.token.length > 0 &&
+    timingSafeEqual(digestKey(m.token), digestKey(providedToken)));
+  return hit ? { member: hit[1], members: group.members } : null;
+}
+
+// Leader side: list members (requires the join key).
+export function listGroupMembers(name, { key, file } = {}) {
+  const groups = loadGroups(file ? { file } : {});
+  const group = groups[name];
+  if (!group) throw new Error(`group "${name}" not found on this node`);
+  if (!verifyGroupKey(key, group.key)) throw new Error("invalid group key");
+  return group.members;
+}
+
+export function listGroups({ file } = {}) {
+  return loadGroups(file ? { file } : {});
+}
+
+export function createGroupsService({ file } = {}) {
+  const opts = (o = {}) => (file ? { ...o, file } : o);
+  return {
+    create: (name, o = {}) => createGroup(name, opts(o)),
+    addMember: (name, o = {}) => addGroupMember(name, opts(o)),
+    upsertMember: (name, o = {}) => upsertMember(name, opts(o)),
+    listMembers: (name, o = {}) => listGroupMembers(name, opts(o)),
+    membersForToken: (name, token) => membersForToken(name, token, opts()),
+    list: () => listGroups(opts()),
+  };
+}
+
+// Re-register with the leader (join is idempotent) and return the fresh member list.
+// No key is needed once registered: the leader verifies our bearer token.
+export async function refreshGroupMembers(name, { leaderUrl, memberName, url, token, fetchImpl = fetch } = {}) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), SYNC_TIMEOUT_MS);
+  try {
+    const res = await fetchImpl(`${leaderUrl}/v1/groups/join`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${token}`,
+      },
+      body: JSON.stringify({ name, memberName, url, token }),
+      signal: controller.signal,
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`group sync failed (HTTP ${res.status}): ${text}`);
+    }
+    const data = await res.json();
+    return data.members || {};
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// Merge a member map into the local peer list, replacing the previous snapshot
+// of this group and skipping ourselves. Used by both leaders (local groups) and
+// members (leader-pulled members).
+export function syncPeersFromMembers({ peers, members, myUrl, group, skipIds = [] }) {
+  const self = normalizePeerUrl(myUrl);
+  const skip = new Set(skipIds);
+  const removed = peers.removeByGroup(group);
+  let added = 0;
+  for (const [id, m] of Object.entries(members || {})) {
+    if (skip.has(id)) continue;
+    const url = normalizePeerUrl(m?.url);
+    if (!url || url === self) continue;
+    if (peers.add({ name: id, url, token: m?.token || "", group })) added++;
+  }
+  return { removed, added, total: Object.keys(members || {}).length };
+}
+
+// ---- join-failure bans (per source IP) ----
+
+export function createBansService({ file, now = () => Date.now(), windowMs = DEFAULT_BAN_WINDOW_MS, threshold = DEFAULT_BAN_THRESHOLD } = {}) {
+  let bans = loadBans(file ? { file } : {});
+
+  function prune() {
+    let changed = false;
+    for (const [ip, b] of Object.entries(bans)) {
+      if (b.bannedAt !== undefined && now() - b.bannedAt >= windowMs) {
+        delete bans[ip];
+        changed = true;
+      }
+    }
+    if (changed) saveBans(bans, file ? { file } : {});
+  }
+
+  function isBanned(ip) {
+    if (!ip) return false;
+    prune();
+    const b = bans[ip];
+    if (b?.bannedAt === undefined) return false;
+    return { bannedAt: b.bannedAt, until: b.bannedAt + windowMs };
+  }
+
+  function recordFailure(ip) {
+    if (!ip) return null;
+    prune();
+    const b = (bans[ip] = bans[ip] || { fails: 0 });
+    b.fails = (b.fails || 0) + 1;
+    if (b.fails >= threshold) {
+      b.bannedAt = now();
+      b.fails = 0;
+    }
+    saveBans(bans, file ? { file } : {});
+    return b.bannedAt !== undefined ? b : null;
+  }
+
+  function clear(ip) {
+    if (ip) {
+      delete bans[ip];
+    } else {
+      bans = {};
+    }
+    saveBans(bans, file ? { file } : {});
+  }
+
+  function list() {
+    prune();
+    return { ...bans };
+  }
+
+  return { isBanned, recordFailure, clear, list, windowMs, threshold };
+}

package/src/logs.js

@@ -0,0 +1,80 @@
+import { appendFileSync, readFileSync, mkdirSync, existsSync, writeFileSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import os from "node:os";
+import { defaultStateFile } from "./state.js";
+
+const MAX_CALLS = 500;
+const MAX_ERRORS = 200;
+const MAX_BYTES = 1024 * 1024;
+
+export function logDir() {
+  return process.env.MSLXDFF_DAEMON_DIR || dirname(defaultStateFile());
+}
+
+export function callsFile() {
+  return join(logDir(), "calls.log");
+}
+
+export function errorsFile() {
+  return join(logDir(), "errors.log");
+}
+
+function ensureDir(dir) {
+  mkdirSync(dir, { recursive: true });
+}
+
+function trimIfOversized(file, maxBytes = MAX_BYTES) {
+  try {
+    const st = statSync(file);
+    if (st.size <= maxBytes) return;
+    const text = readFileSync(file, "utf8");
+    const lines = text.split("\n");
+    const keep = lines.slice(-100);
+    writeFileSync(file, keep.join("\n"));
+  } catch {
+    // ignore
+  }
+}
+
+function appendLine(file, entry) {
+  ensureDir(dirname(file));
+  appendFileSync(file, JSON.stringify({ ts: new Date().toISOString(), ...entry }) + "\n");
+  trimIfOversized(file);
+}
+
+export function appendCall(entry, { file = callsFile() } = {}) {
+  appendLine(file, entry);
+}
+
+export function appendError(entry, { file = errorsFile() } = {}) {
+  appendLine(file, entry);
+}
+
+function readLines(file) {
+  try {
+    if (!existsSync(file)) return [];
+    const text = readFileSync(file, "utf8");
+    return text.split("\n").filter(Boolean).map((l) => {
+      try {
+        return JSON.parse(l);
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+export function recentCalls(n = 5, { file = callsFile() } = {}) {
+  return readLines(file).slice(-n);
+}
+
+export function lastError({ file = errorsFile() } = {}) {
+  const lines = readLines(file);
+  return lines.length ? lines[lines.length - 1] : null;
+}
+
+export function recentErrors(n = 5, { file = errorsFile() } = {}) {
+  return readLines(file).slice(-n);
+}

package/src/models.js

@@ -1,92 +1,128 @@
-const KNOWN_FREE_OPENCODE_MODELS = ["big-pickle"];
-const CACHE_TTL_MS = 10 * 60 * 1000;
-
-export function isFreeModel(id) {
-  return (typeof id === "string" && id.endsWith("-free")) ||
-    KNOWN_FREE_OPENCODE_MODELS.includes(id);
-}
-
-export function filterFreeModels(list) {
-  const seen = new Set();
-  const out = [];
-  for (const m of list || []) {
-    if (!(m && m.id)) continue;
-    if (!isFreeModel(m.id)) continue;
-    if (seen.has(m.id)) continue;
-    seen.add(m.id);
-    out.push(m);
-  }
-  return out;
-}
-
-export function createModelsService({ baseUrl, headers, ttlMs = CACHE_TTL_MS } = {}) {
-  let cache = null;
-  let fetchedAt = 0;
-  let inflight = null;
-
-  async function get() {
-    const now = Date.now();
-    if (cache && now - fetchedAt < ttlMs) return cache;
-    if (inflight) return inflight;
-
-    inflight = (async () => {
-      try {
-        const data = await fetchUpstreamModels({ baseUrl, headers });
-        cache = data;
-        fetchedAt = Date.now();
-        return data;
-      } catch (err) {
-        // serve stale on failure if we have it, else rethrow
-        if (cache) return cache;
-        throw err;
-      } finally {
-        inflight = null;
-      }
-    })();
-    return inflight;
-  }
-
-  return { get };
-}
-
-async function fetchUpstreamModels({ baseUrl, headers, connectTimeoutMs = 30_000 }) {
-  const url = `${baseUrl}/zen/v1/models`;
-  for (let attempt = 0; ; attempt++) {
-    const res = await attemptFetch(url, headers, connectTimeoutMs);
-    if (res instanceof Error) {
-      if (attempt < NETWORK_RETRIES) continue;
-      throw res;
-    }
-    if (isRetryable(res.status) && attempt < STATUS_RETRIES) {
-      await sleep(2000);
-      continue;
-    }
-    if (!res.ok) throw new Error(`models fetch failed: HTTP ${res.status}`);
-    const json = await res.json().catch(() => ({}));
-    const raw = Array.isArray(json) ? json : json.data ?? json.models ?? [];
-    return { object: "list", data: filterFreeModels(raw) };
-  }
-}
-
-async function attemptFetch(url, headers, connectTimeoutMs) {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), connectTimeoutMs);
-  try {
-    return await fetch(url, { headers, signal: controller.signal });
-  } catch (err) {
-    return err;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-function isRetryable(status) {
-  return status === 429 || status === 502 || status === 503 || status === 504;
-}
-
-function sleep(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-
-const NETWORK_RETRIES = 2;
+const KNOWN_FREE_OPENCODE_MODELS = ["big-pickle"];
+const CACHE_TTL_MS = 2 * 60 * 60 * 1000;
+const DEFAULT_REFRESH_MS = 2 * 60 * 60 * 1000;
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+
+export function isFreeModel(id) {
+  return (typeof id === "string" && id.endsWith("-free")) ||
+    KNOWN_FREE_OPENCODE_MODELS.includes(id);
+}
+
+export function filterFreeModels(list) {
+  const seen = new Set();
+  const out = [];
+  for (const m of list || []) {
+    if (!(m && m.id)) continue;
+    if (!isFreeModel(m.id)) continue;
+    if (seen.has(m.id)) continue;
+    seen.add(m.id);
+    out.push(m);
+  }
+  return out;
+}
+
+export function createModelsService({ baseUrl, headers, ttlMs = CACHE_TTL_MS, refreshMs = DEFAULT_REFRESH_MS, cacheFile } = {}) {
+  let cache = null;
+  let fetchedAt = 0;
+  let inflight = null;
+  let timer = null;
+
+  async function load() {
+    const data = await fetchUpstreamModels({ baseUrl, headers });
+    cache = data;
+    fetchedAt = Date.now();
+    if (cacheFile) persistModels(data, cacheFile);
+    return data;
+  }
+
+  async function get() {
+    const now = Date.now();
+    if (cache && now - fetchedAt < ttlMs) return cache;
+    if (inflight) return inflight;
+
+    inflight = (async () => {
+      try {
+        return await load();
+      } catch (err) {
+        // serve stale on failure if we have it, else rethrow
+        if (cache) return cache;
+        throw err;
+      } finally {
+        inflight = null;
+      }
+    })();
+    return inflight;
+  }
+
+  function startAutoRefresh(intervalMs = refreshMs) {
+    if (timer) return stopAutoRefresh;
+    timer = setInterval(() => {
+      void load().catch(() => {
+        // keep serving stale cache on background refresh failure
+      });
+    }, intervalMs);
+    timer.unref?.();
+    return stopAutoRefresh;
+  }
+
+  function stopAutoRefresh() {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  }
+
+  return { get, startAutoRefresh, stopAutoRefresh };
+}
+
+async function fetchUpstreamModels({ baseUrl, headers, connectTimeoutMs = 30_000 }) {
+  const url = `${baseUrl}/zen/v1/models`;
+  for (let attempt = 0; ; attempt++) {
+    const res = await attemptFetch(url, headers, connectTimeoutMs);
+    if (res instanceof Error) {
+      if (attempt < NETWORK_RETRIES) continue;
+      throw res;
+    }
+    if (isRetryable(res.status) && attempt < STATUS_RETRIES) {
+      await sleep(2000);
+      continue;
+    }
+    if (!res.ok) throw new Error(`models fetch failed: HTTP ${res.status}`);
+    const json = await res.json().catch(() => ({}));
+    const raw = Array.isArray(json) ? json : json.data ?? json.models ?? [];
+    return { object: "list", data: filterFreeModels(raw) };
+  }
+}
+
+async function attemptFetch(url, headers, connectTimeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), connectTimeoutMs);
+  try {
+    return await fetch(url, { headers, signal: controller.signal });
+  } catch (err) {
+    return err;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function isRetryable(status) {
+  return status === 429 || status === 502 || status === 503 || status === 504;
+}
+
+function persistModels(data, cacheFile) {
+  try {
+    mkdirSync(dirname(cacheFile), { recursive: true });
+    writeFileSync(cacheFile, JSON.stringify({ cachedAt: Date.now(), ...data }));
+  } catch {
+    // persistence is best-effort
+  }
+}
+
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+const NETWORK_RETRIES = 2;
 const STATUS_RETRIES = 2;