crewswarm 0.8.1-beta

package/lib/runtime/spending.mjs

@@ -0,0 +1,204 @@
+/**
+ * Spending caps + token usage accumulator — extracted from gateway-bridge.mjs
+ * Inject: initSpending({ resolveConfig, resolveTelegramBridgeConfig })
+ */
+
+import fs   from "fs";
+import path from "path";
+import os   from "os";
+
+const SPENDING_FILE    = path.join(os.homedir(), ".crewswarm", "spending.json");
+const TOKEN_USAGE_FILE = path.join(os.homedir(), ".crewswarm", "token-usage.json");
+
+// Lazy path resolvers — in test mode, redirect to /tmp to avoid corrupting live data
+function getSpendingFile() {
+  if (process.env.CREWSWARM_TEST_MODE) {
+    const dir = path.join(os.tmpdir(), `crewswarm-test-${process.pid}`);
+    fs.mkdirSync(dir, { recursive: true });
+    return path.join(dir, "spending.json");
+  }
+  return SPENDING_FILE;
+}
+
+function getTokenUsageFile() {
+  if (process.env.CREWSWARM_TEST_MODE) {
+    const dir = path.join(os.tmpdir(), `crewswarm-test-${process.pid}`);
+    fs.mkdirSync(dir, { recursive: true });
+    return path.join(dir, "token-usage.json");
+  }
+  return TOKEN_USAGE_FILE;
+}
+
+// Cost per 1M tokens per provider (USD) — input / output / cached
+// Cached pricing: Gemini=free, Anthropic=90% off, Grok=50% off, others=same as input
+const PRICING = {
+  groq:       { input: 0.05,  output: 0.05,  cached: 0.025 },  // 50% off
+  anthropic:  { input: 3.00,  output: 15.00, cached: 0.30 },   // 90% off
+  openai:     { input: 5.00,  output: 15.00, cached: 2.50 },   // 50% off
+  perplexity: { input: 1.00,  output: 1.00,  cached: 1.00 },   // no discount
+  mistral:    { input: 0.70,  output: 2.00,  cached: 0.70 },   // no discount
+  google:     { input: 0.075, output: 0.30,  cached: 0.00 },   // FREE!
+  xai:        { input: 5.00,  output: 15.00, cached: 2.50 },   // 50% off (Grok)
+  deepseek:   { input: 0.27,  output: 1.10,  cached: 0.135 },  // 50% off
+  nvidia:     { input: 1.00,  output: 1.00,  cached: 1.00 },   // no discount
+  cerebras:   { input: 0.10,  output: 0.10,  cached: 0.10 },   // no discount
+};
+
+// Legacy fallback for old code using COST_PER_1M
+const COST_PER_1M = { groq:0.05, anthropic:3.00, openai:5.00, perplexity:1.00, mistral:0.70, google:0.15, xai:2.00, deepseek:0.27, nvidia:1.00, cerebras:0.10 };
+
+let _resolveConfig               = () => ({});
+let _resolveTelegramBridgeConfig = () => ({});
+
+export function initSpending({ resolveConfig, resolveTelegramBridgeConfig } = {}) {
+  if (resolveConfig)               _resolveConfig               = resolveConfig;
+  if (resolveTelegramBridgeConfig) _resolveTelegramBridgeConfig = resolveTelegramBridgeConfig;
+}
+
+// ── Spending caps ─────────────────────────────────────────────────────────────
+
+export function loadSpending() {
+  const today = new Date().toISOString().slice(0, 10);
+  try {
+    const d = JSON.parse(fs.readFileSync(getSpendingFile(), "utf8"));
+    if (d.date === today) return d;
+  } catch {}
+  return { date: today, global: { tokens: 0, costUSD: 0 }, agents: {} };
+}
+
+export function saveSpending(s) {
+  try { 
+    const file = getSpendingFile();
+    fs.mkdirSync(path.dirname(file), { recursive: true }); 
+    fs.writeFileSync(file, JSON.stringify(s, null, 2)); 
+  } catch {}
+}
+
+export function addAgentSpend(agentId, tokens, costUSD) {
+  const s = loadSpending();
+  s.global.tokens  += tokens;
+  s.global.costUSD += costUSD;
+  if (!s.agents[agentId]) s.agents[agentId] = { tokens: 0, costUSD: 0 };
+  s.agents[agentId].tokens  += tokens;
+  s.agents[agentId].costUSD += costUSD;
+  saveSpending(s);
+}
+
+export function checkSpendingCap(agentId, providerKey) {
+  try {
+    const csw = JSON.parse(fs.readFileSync(getCrewswarmConfigPath(), "utf8"));
+    const s   = loadSpending();
+    const gl  = csw.globalSpendingCaps || {};
+    if (gl.dailyTokenLimit && s.global.tokens >= gl.dailyTokenLimit)
+      return { exceeded: true, action: "stop", message: `Global daily token limit ${gl.dailyTokenLimit.toLocaleString()} reached` };
+    if (gl.dailyCostLimitUSD && s.global.costUSD >= gl.dailyCostLimitUSD)
+      return { exceeded: true, action: "stop", message: `Global daily cost limit $${gl.dailyCostLimitUSD} reached` };
+    const agent    = (csw.agents || []).find(a => a.id === agentId);
+    const agentCap = agent?.spending;
+    if (agentCap) {
+      const used = s.agents[agentId] || { tokens: 0, costUSD: 0 };
+      if (agentCap.dailyTokenLimit && used.tokens >= agentCap.dailyTokenLimit)
+        return { exceeded: true, action: agentCap.onExceed || "notify", message: `${agentId} daily token limit ${agentCap.dailyTokenLimit.toLocaleString()} reached` };
+      if (agentCap.dailyCostLimitUSD && used.costUSD >= agentCap.dailyCostLimitUSD)
+        return { exceeded: true, action: agentCap.onExceed || "notify", message: `${agentId} daily cost limit $${agentCap.dailyCostLimitUSD} reached` };
+    }
+  } catch {}
+  return { exceeded: false };
+}
+
+export async function notifyTelegramSpending(message) {
+  const cfg      = _resolveConfig();
+  const tgBridge = _resolveTelegramBridgeConfig();
+  const botToken = process.env.TELEGRAM_BOT_TOKEN || cfg?.env?.TELEGRAM_BOT_TOKEN || cfg?.TELEGRAM_BOT_TOKEN || tgBridge.token || "";
+  const chatId   = process.env.TELEGRAM_CHAT_ID   || cfg?.env?.TELEGRAM_CHAT_ID   || cfg?.TELEGRAM_CHAT_ID
+    || (Array.isArray(tgBridge.allowedChatIds) && tgBridge.allowedChatIds.length ? String(tgBridge.allowedChatIds[0]) : "") || tgBridge.defaultChatId || "";
+  const chatIdVal = chatId.trim();
+  if (!botToken || !chatIdVal) return;
+  await fetch(`https://api.telegram.org/bot${botToken}/sendMessage`, {
+    method: "POST", headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ chat_id: chatIdVal, text: `💸 Spending alert: ${message}`, parse_mode: "Markdown" }),
+    signal: AbortSignal.timeout(5000),
+  }).catch(() => {});
+}
+
+// ── Token/cost accumulator ────────────────────────────────────────────────────
+
+let _tokenUsage = null;
+export function getTokenUsage() {
+  if (!_tokenUsage) {
+    try { _tokenUsage = JSON.parse(fs.readFileSync(getTokenUsageFile(), "utf8")); } catch {}
+    if (!_tokenUsage) _tokenUsage = { calls: 0, prompt: 0, completion: 0, byModel: {}, sessionStart: new Date().toISOString() };
+  }
+  return _tokenUsage;
+}
+// Backward-compat: existing code references `tokenUsage` directly
+export const tokenUsage = new Proxy({}, {
+  get(_, prop) { return getTokenUsage()[prop]; },
+  set(_, prop, val) { getTokenUsage()[prop] = val; return true; },
+});
+
+export function recordTokenUsage(modelId, usage, agentId) {
+  if (!usage) return;
+  const p = Number(usage.prompt_tokens || usage.input_tokens || 0);
+  const c = Number(usage.completion_tokens || usage.output_tokens || 0);
+  if (!p && !c) return;
+  const cached = Number(
+    usage.prompt_tokens_details?.cached_tokens  // OpenAI / xAI / Groq
+    || usage.prompt_cache_hit_tokens            // DeepSeek
+    || usage.cache_read_input_tokens            // Anthropic
+    || 0
+  );
+  if (cached > 0) {
+    const pct = p > 0 ? Math.round(cached / p * 100) : 0;
+    console.log(`[bridge:${agentId || modelId}] cache hit: ${cached}/${p} tokens cached (${pct}%) — ${modelId}`);
+  }
+  const today = new Date().toISOString().slice(0, 10);
+  tokenUsage.calls++;
+  tokenUsage.prompt     += p;
+  tokenUsage.completion += c;
+  if (!tokenUsage.cached) tokenUsage.cached = 0;
+  tokenUsage.cached += cached;
+  if (!tokenUsage.byModel[modelId]) tokenUsage.byModel[modelId] = { calls: 0, prompt: 0, completion: 0, cached: 0 };
+  tokenUsage.byModel[modelId].calls++;
+  tokenUsage.byModel[modelId].prompt     += p;
+  tokenUsage.byModel[modelId].completion += c;
+  tokenUsage.byModel[modelId].cached     += cached;
+  if (!tokenUsage.byDay) tokenUsage.byDay = {};
+  if (!tokenUsage.byDay[today]) tokenUsage.byDay[today] = { calls: 0, prompt: 0, completion: 0, cached: 0, byModel: {} };
+  tokenUsage.byDay[today].calls++;
+  tokenUsage.byDay[today].prompt     += p;
+  tokenUsage.byDay[today].completion += c;
+  tokenUsage.byDay[today].cached     += cached;
+  if (!tokenUsage.byDay[today].byModel[modelId]) tokenUsage.byDay[today].byModel[modelId] = { calls: 0, prompt: 0, completion: 0, cached: 0 };
+  tokenUsage.byDay[today].byModel[modelId].calls++;
+  tokenUsage.byDay[today].byModel[modelId].prompt     += p;
+  tokenUsage.byDay[today].byModel[modelId].completion += c;
+  tokenUsage.byDay[today].byModel[modelId].cached     += cached;
+  if (tokenUsage.calls % 5 === 0) {
+    try {
+      const file = getTokenUsageFile();
+      fs.mkdirSync(path.dirname(file), { recursive: true });
+      fs.writeFileSync(file, JSON.stringify(tokenUsage, null, 2));
+    } catch {}
+  }
+  if (agentId) {
+    const providerKey = modelId.split("/")[0] || "unknown";
+    const pricing = PRICING[providerKey] || { input: 1.0, output: 1.0, cached: 1.0 };
+    
+    // Calculate cost with cache discount
+    const uncachedInput = Math.max(0, p - cached);
+    const inputCost  = (uncachedInput / 1_000_000) * pricing.input;
+    const cachedCost = (cached / 1_000_000) * pricing.cached;
+    const outputCost = (c / 1_000_000) * pricing.output;
+    const costUSD = inputCost + cachedCost + outputCost;
+    
+    // Log cache savings for high cache hit rates
+    if (cached > 0 && cached / p > 0.5) {
+      const savings = ((uncachedInput / 1_000_000) * pricing.input) - cachedCost;
+      console.log(`[spending:${agentId}] cache saved $${savings.toFixed(4)} on ${cached.toLocaleString()} tokens`);
+    }
+    
+    const total = p + c; // Total tokens (for cap checking)
+    addAgentSpend(agentId, total, costUSD);
+  }
+}

package/lib/runtime/startup-guard.mjs

@@ -0,0 +1,291 @@
+/**
+ * Startup guard — Ensures only one instance of a service runs
+ * Prevents port conflicts and duplicate processes
+ */
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { execSync } from "node:child_process";
+
+function isWritableDir(dir) {
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    const probe = path.join(dir, `.pid-write-test-${process.pid}`);
+    fs.writeFileSync(probe, "ok");
+    fs.unlinkSync(probe);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function resolvePidDir() {
+  const configured = process.env.CREWSWARM_PID_DIR;
+  const homePidDir = path.join(os.homedir(), ".crewswarm", "pids");
+  const tmpPidDir = path.join(
+    os.tmpdir(),
+    `crewswarm-pids-${process.getuid?.() ?? "user"}`,
+  );
+
+  const candidates = [configured, homePidDir, tmpPidDir].filter(Boolean);
+  for (const dir of candidates) {
+    if (isWritableDir(dir)) {
+      if (dir !== homePidDir) {
+        console.warn(`[startup-guard] Using fallback PID directory: ${dir}`);
+      }
+      return dir;
+    }
+  }
+
+  throw new Error(
+    `[startup-guard] No writable PID directory found. Tried: ${candidates.join(", ")}`,
+  );
+}
+
+const PID_DIR = resolvePidDir();
+
+/**
+ * Check if a process is alive
+ */
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0); // Signal 0 just checks if process exists
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if a port is in use
+ */
+function isPortInUse(port) {
+  try {
+    execSync(`lsof -ti :${port}`, {
+      encoding: "utf8",
+      timeout: 2000,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get PID using port
+ */
+function getPidOnPort(port) {
+  try {
+    const out = execSync(`lsof -ti :${port}`, {
+      encoding: "utf8",
+      timeout: 2000,
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+    const pids = out
+      .split("\n")
+      .filter(Boolean)
+      .map((p) => parseInt(p, 10));
+    return pids.length > 0 ? pids[0] : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Remove a pid file without crashing startup on permission issues.
+ */
+function tryRemovePidFile(pidFile, serviceName, context) {
+  try {
+    fs.unlinkSync(pidFile);
+    return true;
+  } catch (err) {
+    console.warn(
+      `[startup-guard] Failed to remove ${context} PID file for ${serviceName}: ${err.message}`,
+    );
+    return false;
+  }
+}
+
+/**
+ * Acquire startup lock for a service
+ * Returns: { ok: true, pid } if lock acquired
+ *          { ok: false, runningPid, message } if already running
+ */
+export function acquireStartupLock(serviceName, options = {}) {
+  const {
+    port = null,
+    killStale = true,
+    maxRetries = 6,
+    pidFile: pidFileOverride = null,
+  } = options;
+  const pidFile =
+    pidFileOverride ?? path.join(PID_DIR, `${serviceName}.pid`);
+  if (pidFileOverride) {
+    try {
+      fs.mkdirSync(path.dirname(pidFile), { recursive: true });
+    } catch {
+      // write below may still succeed
+    }
+  }
+  const myPid = process.pid;
+
+  // Check if PID file exists
+  if (fs.existsSync(pidFile)) {
+    try {
+      const savedPid = parseInt(fs.readFileSync(pidFile, "utf8").trim(), 10);
+      if (!Number.isFinite(savedPid) || savedPid < 1) {
+        console.log(
+          `[startup-guard] Removing invalid PID file for ${serviceName} (not a positive integer)`,
+        );
+        if (!tryRemovePidFile(pidFile, serviceName, "invalid")) {
+          return {
+            ok: false,
+            message: `Cannot remove invalid PID file for ${serviceName}: ${pidFile}`,
+          };
+        }
+      } else if (isProcessAlive(savedPid)) {
+        // Process is alive - check if it's really the right service
+        if (port && !isPortInUse(port)) {
+          // PID exists but port is free - stale PID file
+          console.log(
+            `[startup-guard] Stale PID ${savedPid} for ${serviceName} (port ${port} free) - removing`,
+          );
+          if (!tryRemovePidFile(pidFile, serviceName, "stale")) {
+            return {
+              ok: false,
+              runningPid: savedPid,
+              message: `Cannot remove stale PID file for ${serviceName}: ${pidFile}`,
+            };
+          }
+        } else {
+          return {
+            ok: false,
+            runningPid: savedPid,
+            message: `${serviceName} already running (pid ${savedPid})${port ? ` on port ${port}` : ""}`,
+          };
+        }
+      } else {
+        // Stale PID file (process exited)
+        console.log(
+          `[startup-guard] Removing stale PID file for ${serviceName} (pid ${savedPid} dead)`,
+        );
+        if (!tryRemovePidFile(pidFile, serviceName, "stale")) {
+          return {
+            ok: false,
+            runningPid: savedPid,
+            message: `Cannot remove stale PID file for ${serviceName}: ${pidFile}`,
+          };
+        }
+      }
+    } catch (err) {
+      // Corrupted PID file
+      console.log(
+        `[startup-guard] Removing corrupted PID file for ${serviceName}: ${err.message}`,
+      );
+      if (!tryRemovePidFile(pidFile, serviceName, "corrupted")) {
+        return {
+          ok: false,
+          message: `Cannot remove corrupted PID file for ${serviceName}: ${pidFile}`,
+        };
+      }
+    }
+  }
+
+  // Check port conflict
+  if (port) {
+    const portPid = getPidOnPort(port);
+    if (portPid && portPid !== myPid) {
+      if (killStale) {
+        console.log(
+          `[startup-guard] Port ${port} occupied by PID ${portPid} - killing stale process`,
+        );
+        try {
+          process.kill(portPid, 9);
+          // Wait for port to be released
+          for (let i = 0; i < maxRetries; i++) {
+            if (!isPortInUse(port)) break;
+            const wait = (i + 1) * 1000;
+            console.log(
+              `[startup-guard] Port ${port} in use — retry ${i + 1}/${maxRetries} in ${wait}ms`,
+            );
+            execSync(`sleep ${wait / 1000}`, { stdio: "ignore" });
+          }
+          if (isPortInUse(port)) {
+            return {
+              ok: false,
+              runningPid: portPid,
+              message: `Port ${port} still in use after killing stale process ${portPid}`,
+            };
+          }
+        } catch (err) {
+          return {
+            ok: false,
+            runningPid: portPid,
+            message: `Failed to kill stale process ${portPid} on port ${port}: ${err.message}`,
+          };
+        }
+      } else {
+        return {
+          ok: false,
+          runningPid: portPid,
+          message: `Port ${port} already in use by process ${portPid}`,
+        };
+      }
+    }
+  }
+
+  // Acquire lock by writing PID file
+  try {
+    fs.writeFileSync(pidFile, String(myPid));
+    console.log(
+      `[startup-guard] Acquired lock for ${serviceName} (pid ${myPid})${port ? ` on port ${port}` : ""}`,
+    );
+
+    // Clean up PID file on exit
+    const cleanup = () => {
+      try {
+        const current = fs.existsSync(pidFile)
+          ? fs.readFileSync(pidFile, "utf8").trim()
+          : null;
+        if (current === String(myPid)) {
+          fs.unlinkSync(pidFile);
+          console.log(
+            `[startup-guard] Released lock for ${serviceName} (pid ${myPid})`,
+          );
+        }
+      } catch {}
+    };
+
+    process.on("exit", cleanup);
+    process.on("SIGINT", () => {
+      cleanup();
+      process.exit(130);
+    });
+    process.on("SIGTERM", () => {
+      cleanup();
+      process.exit(143);
+    });
+
+    return { ok: true, pid: myPid };
+  } catch (err) {
+    return {
+      ok: false,
+      message: `Failed to write PID file for ${serviceName}: ${err.message}`,
+    };
+  }
+}
+
+/**
+ * Release startup lock (usually automatic via process.on('exit'))
+ */
+export function releaseStartupLock(serviceName) {
+  const pidFile = path.join(PID_DIR, `${serviceName}.pid`);
+  try {
+    const savedPid = parseInt(fs.readFileSync(pidFile, "utf8").trim(), 10);
+    if (savedPid === process.pid) {
+      fs.unlinkSync(pidFile);
+      console.log(`[startup-guard] Released lock for ${serviceName}`);
+    }
+  } catch {}
+}