loom-agent 1.2.0

package/src/core/subagent-log.js

@@ -0,0 +1,134 @@
+// Subagent run log — append-only JSON store of completed subagent runs so the
+// /subagents panel (and future analytics) can show history across sessions.
+//
+// File: <LOOM_CONFIG_DIR or ~/.loom>/subagents.json — a JSON array of entries
+// (one per completed run). Pruned to a sliding window so the file stays small.
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const FILE_NAME = 'subagents.json';
+// Cap the on-disk log so the file doesn't grow unbounded; pruning drops the
+// oldest entries first when this threshold is exceeded.
+const MAX_ENTRIES = 500;
+// Default age window: drop anything older than this many ms (30 days).
+const DEFAULT_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000;
+
+function subagentLogDir() {
+  return process.env.LOOM_CONFIG_DIR || path.join(os.homedir(), '.loom');
+}
+
+function subagentLogPath() {
+  return path.join(subagentLogDir(), FILE_NAME);
+}
+
+function ensureDir() {
+  try { fs.mkdirSync(subagentLogDir(), { recursive: true }); } catch {}
+}
+
+// Read-modify-write: safe for concurrent appends within a single process
+// (the TUI is the only writer). External writers can corrupt the file but
+// that matches the pattern used by keybinds/theme tui.json.
+function readAll() {
+  try {
+    const raw = fs.readFileSync(subagentLogPath(), 'utf8');
+    const arr = JSON.parse(raw);
+    return Array.isArray(arr) ? arr : [];
+  } catch {
+    return [];
+  }
+}
+
+function writeAll(entries) {
+  ensureDir();
+  try {
+    fs.writeFileSync(subagentLogPath(), JSON.stringify(entries, null, 0));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Append a completed subagent run to the log.
+ * @param {object} entry
+ * @param {string} entry.runId
+ * @param {string} entry.agent          display name
+ * @param {string} entry.agentId        id (e.g. 'general')
+ * @param {string} entry.prompt         delegated instruction
+ * @param {'done'|'error'|'cancelled'} entry.status
+ * @param {number} entry.startTime      ms since epoch
+ * @param {number} entry.endTime        ms since epoch
+ * @param {number} entry.durationMs
+ * @param {number} entry.tokensIn
+ * @param {number} entry.tokensOut
+ * @param {number} entry.costUsd
+ * @param {boolean} [entry.interrupted]
+ * @param {string} [entry.content]      final answer
+ * @param {string[]} [entry.toolLog]
+ * @param {string} [entry.sessionId]    parent conversation id
+ * @returns {boolean} true if written
+ */
+function saveSubagentRun(entry) {
+  if (!entry || !entry.runId) return false;
+  const all = readAll();
+  all.push(entry);
+  // Cap the log size — drop oldest first.
+  if (all.length > MAX_ENTRIES) all.splice(0, all.length - MAX_ENTRIES);
+  return writeAll(all);
+}
+
+/**
+ * Load subagent runs. Optional filters narrow the result.
+ * @param {object} [opts]
+ * @param {number} [opts.since]        only entries with startTime >= since
+ * @param {string} [opts.sessionId]    only entries from this parent session
+ * @param {number} [opts.limit]        cap on returned entries (newest first)
+ * @returns {Array<object>}            newest first
+ */
+function loadSubagentRuns(opts) {
+  const all = readAll();
+  let out = all;
+  if (opts && opts.since != null) {
+    const since = Number(opts.since);
+    out = out.filter(e => e && Number(e.startTime) >= since);
+  }
+  if (opts && opts.sessionId) {
+    out = out.filter(e => e && e.sessionId === opts.sessionId);
+  }
+  // Newest first.
+  out.sort((a, b) => Number(b.startTime) - Number(a.startTime));
+  if (opts && opts.limit != null && opts.limit > 0) {
+    out = out.slice(0, opts.limit);
+  }
+  return out;
+}
+
+/**
+ * Drop entries older than maxAgeMs (default 30 days). Rewrites the file.
+ * @param {number} [maxAgeMs]
+ * @returns {number} count of remaining entries
+ */
+function pruneSubagentRuns(maxAgeMs) {
+  const cutoff = Date.now() - (maxAgeMs || DEFAULT_MAX_AGE_MS);
+  const all = readAll();
+  const kept = all.filter(e => e && Number(e.startTime) >= cutoff);
+  writeAll(kept);
+  return kept.length;
+}
+
+/** Test helper — wipe the log entirely. */
+function clearSubagentRuns() {
+  return writeAll([]);
+}
+
+module.exports = {
+  subagentLogPath,
+  loadSubagentRuns,
+  saveSubagentRun,
+  pruneSubagentRuns,
+  clearSubagentRuns,
+  // Exposed for tests / callers that want the window.
+  MAX_ENTRIES,
+  DEFAULT_MAX_AGE_MS,
+};

package/src/core/tokens.js

@@ -0,0 +1,31 @@
+const { encoding_for_model, get_encoding } = require('tiktoken');
+
+const FALLBACK = 'cl100k_base';
+
+function getEncoder(modelId) {
+  try {
+    if (modelId && modelId.indexOf('claude') >= 0) return get_encoding(FALLBACK);
+    if (modelId) return encoding_for_model(modelId);
+    return get_encoding(FALLBACK);
+  } catch (e) {
+    return get_encoding(FALLBACK);
+  }
+}
+
+function countTokens(text, modelId) {
+  if (!text) return 0;
+  const enc = getEncoder(modelId);
+  return enc.encode(text).length;
+}
+
+function countMessages(messages, modelId) {
+  let total = 0;
+  for (const m of messages) {
+    const text = (m.content || '') + '';
+    if (text) total += countTokens(text, modelId);
+  }
+  total += messages.length * 3;
+  return total;
+}
+
+module.exports = { countTokens, countMessages };

package/src/core/update.js

@@ -0,0 +1,6 @@
+async function updateCheck() {
+  if (process.env.LOOM_NO_UPDATE_CHECK) return;
+  return;
+}
+
+module.exports = { updateCheck };

package/src/core/usage.js

@@ -0,0 +1,166 @@
+// Usage & billing tracker -- persists cumulative token/cost stats to ~/.loom/usage.json.
+// Overridable via LOOM_USAGE_FILE env var (used by tests). The env var is read
+// lazily on each load/save so tests can redirect the ledger at any time.
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const USAGE_FILE = process.env.LOOM_USAGE_FILE || path.join(os.homedir(), '.loom', 'usage.json');
+function usageFile() { return process.env.LOOM_USAGE_FILE || USAGE_FILE; }
+
+function monthKey(d) {
+  return d.getFullYear() + '-' + String(d.getMonth() + 1).padStart(2, '0');
+}
+
+function dayKey(d) {
+  return d.getFullYear() + '-' + String(d.getMonth() + 1).padStart(2, '0') + '-' + String(d.getDate()).padStart(2, '0');
+}
+
+function load() {
+  try { return JSON.parse(fs.readFileSync(usageFile(), 'utf8')); } catch { return {}; }
+}
+
+function save(data) {
+  try {
+    fs.mkdirSync(path.dirname(usageFile()), { recursive: true });
+    fs.writeFileSync(usageFile(), JSON.stringify(data, null, 2));
+  } catch {}
+}
+
+function normalize(data) {
+  const totals = data.totals || { inputTokens: 0, outputTokens: 0, costUsd: 0 };
+  const months = data.months || {};
+  const days = data.days || {};
+  const key = monthKey(new Date());
+  const dkey = dayKey(new Date());
+  const month = months[key] || { inputTokens: 0, outputTokens: 0, costUsd: 0 };
+  const day = days[dkey] || { costUsd: 0 };
+  return {
+    totals,
+    months,
+    days,
+    month,
+    day,
+    key,
+    dkey,
+    budgetUsd: typeof data.budgetUsd === 'number' ? data.budgetUsd : 25,
+    dailyAlertUsd: typeof data.dailyAlertUsd === 'number' ? data.dailyAlertUsd : 0,
+    override: data.override || null,
+  };
+}
+
+// Add a usage record (tokens + cost in USD) to the lifetime totals, current
+// month, and current day.
+function recordUsage({ inputTokens = 0, outputTokens = 0, costUsd = 0 } = {}) {
+  const data = normalize(load());
+  data.totals.inputTokens += inputTokens;
+  data.totals.outputTokens += outputTokens;
+  data.totals.costUsd += costUsd;
+  data.months[data.key] = data.month;
+  data.months[data.key].inputTokens += inputTokens;
+  data.months[data.key].outputTokens += outputTokens;
+  data.months[data.key].costUsd += costUsd;
+  data.days[data.dkey] = data.day;
+  data.days[data.dkey].costUsd += costUsd;
+  save({ totals: data.totals, months: data.months, days: data.days, budgetUsd: data.budgetUsd, dailyAlertUsd: data.dailyAlertUsd, override: data.override });
+}
+
+function getUsage() {
+  const data = normalize(load());
+  return {
+    totals: data.totals,
+    month: data.month,
+    monthKey: data.key,
+    budgetUsd: data.budgetUsd,
+    totalTokens: data.totals.inputTokens + data.totals.outputTokens,
+    monthTokens: data.month.inputTokens + data.month.outputTokens,
+    day: {
+      key: data.dkey,
+      costUsd: data.day.costUsd,
+      alertUsd: data.dailyAlertUsd,
+      alert: data.dailyAlertUsd > 0 && data.day.costUsd >= data.dailyAlertUsd,
+    },
+  };
+}
+
+function setMonthlyBudget(usd) {
+  const data = normalize(load());
+  // 0 is a valid value — it disables enforcement. Only fall back to 25 when
+  // the input isn't a finite non-negative number (NaN, Infinity, negative).
+  const n = Number(usd);
+  data.budgetUsd = Number.isFinite(n) && n >= 0 ? n : 25;
+  save({ totals: data.totals, months: data.months, days: data.days, budgetUsd: data.budgetUsd, dailyAlertUsd: data.dailyAlertUsd, override: data.override });
+}
+
+// Set the daily spend alert threshold in USD. 0 disables alerts. The alert is
+// advisory (footer/status warning) — it never blocks a turn.
+function setDailyAlert(usd) {
+  const data = normalize(load());
+  const n = Number(usd);
+  data.dailyAlertUsd = Number.isFinite(n) && n >= 0 ? n : 0;
+  save({ totals: data.totals, months: data.months, days: data.days, budgetUsd: data.budgetUsd, dailyAlertUsd: data.dailyAlertUsd, override: data.override });
+}
+
+function dayStatus() {
+  const data = normalize(load());
+  return {
+    dayKey: data.dkey,
+    dayCostUsd: data.day.costUsd || 0,
+    alertUsd: data.dailyAlertUsd,
+    alert: data.dailyAlertUsd > 0 && (data.day.costUsd || 0) >= data.dailyAlertUsd,
+  };
+}
+
+// Where we stand against the monthly spend cap. `over` is true once the
+// month's cost has reached the cap — sessions use this to hard-block paid
+// turns. A cap of 0 disables enforcement (treated as unlimited).
+// `overrideUsed` is true when the user explicitly confirmed a one-shot
+// override for the current month (/budget override) that has not been
+// consumed yet.
+function budgetStatus() {
+  const data = normalize(load());
+  const usd = data.month.costUsd || 0;
+  const cap = data.budgetUsd;
+  const overrideUsed = !!(data.override && data.override.month === data.key && !data.override.consumed);
+  return {
+    monthCostUsd: usd,
+    budgetUsd: cap,
+    pct: cap > 0 ? (usd / cap) * 100 : 0,
+    over: cap > 0 && usd >= cap,
+    overrideUsed,
+  };
+}
+
+// One-shot confirmation: lets exactly one paid turn through after the cap is
+// reached. Consumed the first time a paid turn actually proceeds.
+function requestOverride() {
+  const data = normalize(load());
+  data.override = { month: data.key, consumed: false };
+  save({ totals: data.totals, months: data.months, days: data.days, budgetUsd: data.budgetUsd, dailyAlertUsd: data.dailyAlertUsd, override: data.override });
+  return true;
+}
+
+function consumeOverride() {
+  const data = normalize(load());
+  if (!(data.override && data.override.month === data.key && !data.override.consumed)) return false;
+  data.override.consumed = true;
+  save({ totals: data.totals, months: data.months, days: data.days, budgetUsd: data.budgetUsd, dailyAlertUsd: data.dailyAlertUsd, override: data.override });
+  return true;
+}
+
+// 37283 -> "37.3K", 1500000 -> "1.5M", 512 -> "512"
+function formatTokens(n) {
+  const v = Number(n) || 0;
+  if (v >= 1e9) return (v / 1e9).toFixed(2).replace(/\.?0+$/, '') + 'B';
+  if (v >= 1e6) return (v / 1e6).toFixed(1).replace(/\.0$/, '') + 'M';
+  if (v >= 1e3) return (v / 1e3).toFixed(1).replace(/\.0$/, '') + 'K';
+  return String(v);
+}
+
+// 4.843 -> "$4.84", 0.14 -> "$0.14", 120 -> "$120"
+function formatUsd(n) {
+  const v = Number(n) || 0;
+  return '$' + (v >= 100 ? v.toFixed(0) : v.toFixed(2));
+}
+
+module.exports = { recordUsage, getUsage, setMonthlyBudget, setDailyAlert, dayStatus, budgetStatus, requestOverride, consumeOverride, formatTokens, formatUsd, usageFile, USAGE_FILE };

package/src/index.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+require('dotenv').config();
+const path = require('path');
+const fs = require('fs');
+
+const localEnv = path.join(process.cwd(), '.env');
+if (fs.existsSync(localEnv)) {
+  require('dotenv').config({ path: localEnv, override: false });
+}
+
+const { main } = require('./core/cli');
+const { updateCheck } = require('./core/update');
+const { LoomError } = require('./core/errors');
+
+process.title = 'loom-code';
+
+process.on('uncaughtException', (err) => {
+  if (err instanceof LoomError) {
+    console.error(`\n[Loom Error] ${err.message}`);
+    process.exit(1);
+  }
+  console.error(`\n[Unexpected Error] ${err.message}`);
+  if (process.env.LOOM_DEBUG) console.error(err.stack);
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (reason) => {
+  console.error(`\n[Unhandled Promise]`, reason);
+  if (process.env.LOOM_DEBUG) console.error(reason?.stack);
+  process.exit(1);
+});
+
+(async () => {
+  try {
+    await updateCheck();
+    await main();
+  } catch (err) {
+    console.error(err?.message || err);
+    process.exit(1);
+  }
+})();

package/src/mcp/mcp-client.js

@@ -0,0 +1,201 @@
+const { spawn } = require('child_process');
+const { loadServers } = require('./mcp-manager');
+
+let toolCachePromise = null;
+
+// Kill the whole process tree. On Windows, spawn kill leaves grandchildren
+// (npx -> node) running as orphans that hold ports and memory. On POSIX the
+// child is spawned detached as a process-group leader, so killing the group
+// (-pid) takes down every descendant.
+function killTree(child) {
+  if (!child || child.killed) return;
+  if (process.platform === 'win32') {
+    try {
+      const { execSync } = require('child_process');
+      execSync('taskkill /PID ' + child.pid + ' /T /F', { stdio: 'ignore', windowsHide: true });
+      return;
+    } catch {}
+  }
+  try { process.kill(-child.pid, 'SIGKILL'); } catch {}
+  child.kill('SIGKILL');
+}
+
+function connectToJson(cfg, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cfg.command, cfg.args || [], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: Object.assign({}, process.env, cfg.env || {}),
+      // No console window for stdio MCP servers: on Windows spawn() would
+      // otherwise pop a flashing console up and down while chats happen.
+      windowsHide: true,
+      // POSIX only: make the server a process-group leader so killTree can
+      // kill the whole tree (npx + its node child) with one -pid signal.
+      detached: process.platform !== 'win32',
+    });
+    // A server that dies mid-conversation can emit EPIPE on stdin — without
+    // a listener that 'error' would crash the whole app.
+    child.stdin.on('error', () => {});
+    const timeout = setTimeout(() => {
+      killTree(child);
+      reject(new Error('Timed out connecting to ' + (cfg.command || '') + ' (is it installed?)'));
+    }, timeoutMs || 8000);
+    child.on('error', (e) => {
+      clearTimeout(timeout);
+      reject(e);
+    });
+    child.once('spawn', () => {
+      clearTimeout(timeout);
+      resolve(child);
+    });
+  });
+}
+
+let rpcSeq = 0;
+const DEFAULT_RPC_TIMEOUT = 60000;
+
+function callRpc(child, method, params, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const id = (rpcSeq += 1);
+    let buf = '';
+    let timer = null;
+    let settled = false;
+    const onStderr = () => {};
+    const cleanup = () => {
+      if (timer) clearTimeout(timer);
+      child.stdout.off('data', onData);
+      child.stderr.off('data', onStderr);
+      child.off('close', onClose);
+      child.off('error', onChildError);
+    };
+    const onClose = (code, signal) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(new Error('MCP server exited (code ' + code + (signal ? ', signal ' + signal : '') + ') during ' + method));
+    };
+    const onChildError = (e) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(e);
+    };
+    const onData = (chunk) => {
+      if (settled) return; // safely ignore anything after resolve/reject
+      let text = chunk.toString();
+      // Some Windows stdio servers emit a UTF-8 BOM on the first line, which
+      // would break JSON.parse and stall the RPC until timeout.
+      if (!buf) text = text.replace(/^/, '');
+      buf += text;
+      let idx;
+      while ((idx = buf.indexOf('\n')) >= 0) {
+        const line = buf.slice(0, idx).trim();
+        buf = buf.slice(idx + 1);
+        if (!line) continue;
+        let msg;
+        try { msg = JSON.parse(line); } catch { continue; }
+        // Some servers (or broken MCP packages) send non-object lines like
+        // `null`, `[]`, or strings — never crash on them.
+        if (msg && typeof msg === 'object' && msg.id === id) {
+          settled = true;
+          cleanup();
+          if (msg.error) reject(new Error((msg.error && msg.error.message) || 'MCP error'));
+          else resolve(msg.result);
+        }
+      }
+    };
+    timer = setTimeout(() => {
+      settled = true;
+      cleanup();
+      reject(new Error('MCP RPC timed out: ' + method));
+    }, timeoutMs || DEFAULT_RPC_TIMEOUT);
+    child.stdout.on('data', onData);
+    child.stderr.on('data', onStderr);
+    child.once('close', onClose);
+    child.once('error', onChildError);
+    try {
+      child.stdin.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n');
+    } catch (e) {
+      settled = true;
+      cleanup();
+      reject(e);
+    }
+  });
+}
+
+function notify(child, method, params) {
+  try {
+    child.stdin.write(JSON.stringify({ jsonrpc: '2.0', method, params }) + '\n');
+  } catch {}
+}
+
+async function getTools() {
+  const { servers } = loadServers();
+  const out = [];
+  const failed = [];
+  for (const [name, cfg] of Object.entries(servers)) {
+    if (cfg.enabled === false) continue;
+    const entry = { server: name };
+    let child;
+    try {
+      child = await connectToJson(cfg, 8000);
+      await callRpc(child, 'initialize', { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'loom', version: '1.0.0' } }, 10000).catch(() => ({}));
+      notify(child, 'notifications/initialized', {});
+      const toolsRes = await callRpc(child, 'tools/list', {}, 10000).catch(() => ({ tools: [] }));
+      entry.tools = (toolsRes && toolsRes.tools) || [];
+    } catch (e) {
+      entry.error = e.message;
+      failed.push({ server: name, error: e.message });
+    } finally {
+      killTree(child);
+    }
+    out.push(entry);
+  }
+  if (failed.length) {
+    try { require('../core/events').emit('mcp:failed', { servers: failed }); } catch {}
+  }
+  return out;
+}
+
+async function callTool(server, toolName, input) {
+  const cfg = loadServers().servers[server];
+  if (!cfg) return { error: 'MCP server not found: ' + server };
+  let child;
+  try {
+    child = await connectToJson(cfg, 8000);
+    await callRpc(child, 'initialize', { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'loom', version: '1.0.0' } }, 10000).catch(() => ({}));
+    notify(child, 'notifications/initialized', {});
+    const res = await callRpc(child, 'tools/call', { name: toolName, arguments: input }, DEFAULT_RPC_TIMEOUT).catch(() => ({ isError: true, content: [] }));
+    if (res === undefined || res.isError) {
+      const text = ((res && res.content) || []).filter((c) => c.type === 'text').map((c) => c.text).join('\n');
+      return { error: text || 'MCP tool error' };
+    }
+    const text = ((res && res.content) || []).map((c) => (c.type === 'text' ? c.text : JSON.stringify(c))).join('\n');
+    return { result: text || '(empty result)' };
+  } catch (e) {
+    return { error: e.message };
+  } finally {
+    killTree(child);
+  }
+}
+
+function clearCache() {
+  toolCachePromise = null;
+}
+
+// Kick off tool discovery in the background (spawning servers can take seconds
+// on first run). The first turn awaits it with a deadline via getAllToolDefinitions.
+function warm() {
+  if (process.env.LOOM_MCP_NO_WARM) return Promise.resolve([]);
+  if (!toolCachePromise) toolCachePromise = getTools();
+  return toolCachePromise;
+}
+
+function buildToolName(server, tool) {
+  return 'mcp__' + server + '__' + tool;
+}
+
+function getCachedTools() {
+  return warm();
+}
+
+module.exports = { getTools, getCachedTools, clearCache, buildToolName, callTool, warm, callRpc, killTree };