@askexenow/exe-os 0.9.274 → 0.9.276

package/dist/chunk-GTYRLDPF.js

@@ -0,0 +1,128 @@
+// src/lib/tool-telemetry.ts
+var _toolCalls = /* @__PURE__ */ new Map();
+var _sessionStartedAt = Date.now();
+var _flushTimer = null;
+function recordCall(toolName, action, isError) {
+  let record = _toolCalls.get(toolName);
+  if (!record) {
+    record = { count: 0, actions: /* @__PURE__ */ new Map(), lastCalledAt: 0, errors: 0 };
+    _toolCalls.set(toolName, record);
+  }
+  record.count++;
+  record.lastCalledAt = Date.now();
+  if (isError) record.errors++;
+  if (action) {
+    record.actions.set(action, (record.actions.get(action) ?? 0) + 1);
+  }
+}
+function wrapServerWithTelemetry(server) {
+  const originalRegisterTool = server.registerTool.bind(server);
+  server.registerTool = (name, config, handler) => {
+    const wrappedHandler = async (input, extra) => {
+      const action = input.action;
+      try {
+        const result = await handler(input, extra);
+        const isError = result?.isError === true;
+        recordCall(name, action, isError);
+        return result;
+      } catch (err) {
+        recordCall(name, action, true);
+        throw err;
+      }
+    };
+    return originalRegisterTool(name, config, wrappedHandler);
+  };
+  return server;
+}
+function getToolUsageStats() {
+  let totalCalls = 0;
+  let totalErrors = 0;
+  const tools = {};
+  for (const [name, record] of _toolCalls) {
+    totalCalls += record.count;
+    totalErrors += record.errors;
+    const entry = {
+      calls: record.count,
+      errors: record.errors,
+      lastCalledAt: new Date(record.lastCalledAt).toISOString()
+    };
+    if (record.actions.size > 0) {
+      entry.actions = Object.fromEntries(record.actions);
+    }
+    tools[name] = entry;
+  }
+  return {
+    sessionStartedAt: new Date(_sessionStartedAt).toISOString(),
+    uptimeMs: Date.now() - _sessionStartedAt,
+    totalCalls,
+    totalErrors,
+    tools
+  };
+}
+function resetToolUsageStats() {
+  _toolCalls.clear();
+  _sessionStartedAt = Date.now();
+}
+var FLUSH_INTERVAL_MS = 5 * 60 * 1e3;
+var _lastFlushedAt = 0;
+async function flushToMemory() {
+  const stats = getToolUsageStats();
+  if (stats.totalCalls === 0) return;
+  if (stats.totalCalls === _lastFlushedAt) return;
+  try {
+    const { getClient, isInitialized } = await import("./lib/database.js");
+    if (!isInitialized()) return;
+    const client = getClient();
+    const toolSummary = Object.entries(stats.tools).sort((a, b) => b[1].calls - a[1].calls).map(([name, t]) => {
+      const actionStr = t.actions ? ` (${Object.entries(t.actions).sort((a, b) => b[1] - a[1]).map(([a, c]) => `${a}:${c}`).join(", ")})` : "";
+      return `${name}: ${t.calls} calls${t.errors > 0 ? ` (${t.errors} errors)` : ""}${actionStr}`;
+    }).join("\n");
+    const raw_text = `Tool usage since ${stats.sessionStartedAt} (${Math.round(stats.uptimeMs / 6e4)}min):
+Total: ${stats.totalCalls} calls, ${stats.totalErrors} errors
+
+${toolSummary}`;
+    await client.execute({
+      sql: `INSERT INTO memories (id, agent_id, raw_text, memory_type, project_name, importance, created_at, updated_at, session_scope)
+            VALUES (?, 'system', ?, 'telemetry', 'exe-os', 2, datetime('now'), datetime('now'), NULL)`,
+      args: [
+        `telemetry-tools-${Date.now()}`,
+        raw_text
+      ]
+    });
+    _lastFlushedAt = stats.totalCalls;
+  } catch {
+  }
+}
+function startToolTelemetryFlush() {
+  if (_flushTimer) return;
+  _sessionStartedAt = Date.now();
+  _flushTimer = setInterval(() => void flushToMemory(), FLUSH_INTERVAL_MS);
+  _flushTimer.unref();
+}
+async function stopToolTelemetryFlush() {
+  if (_flushTimer) {
+    clearInterval(_flushTimer);
+    _flushTimer = null;
+  }
+  await flushToMemory();
+}
+function getToolUsageSummary() {
+  const summary = {};
+  for (const [tool, record] of _toolCalls) {
+    summary[tool] = {
+      count: record.count,
+      errors: record.errors,
+      actions: Object.fromEntries(record.actions)
+    };
+  }
+  return summary;
+}
+
+export {
+  wrapServerWithTelemetry,
+  getToolUsageStats,
+  resetToolUsageStats,
+  startToolTelemetryFlush,
+  stopToolTelemetryFlush,
+  getToolUsageSummary
+};

package/dist/chunk-H3YWMLS4.js

@@ -0,0 +1,132 @@
+import {
+  DEFAULT_RUNTIME,
+  RUNTIME_TABLE
+} from "./chunk-NGP6LSV2.js";
+import {
+  EXE_AI_DIR
+} from "./chunk-DOHKUD26.js";
+import {
+  atomicWriteJsonSync,
+  ensurePrivateDirSync
+} from "./chunk-LYH5HE24.js";
+
+// src/lib/agent-config.ts
+import { readFileSync, existsSync } from "fs";
+import path from "path";
+var AGENT_CONFIG_PATH = path.join(EXE_AI_DIR, "agent-config.json");
+var KNOWN_RUNTIMES = {
+  claude: ["claude-opus-4.6", "claude-opus-4", "claude-sonnet-4.6", "claude-sonnet-4", "claude-haiku-4.5", "claude-fable-5"],
+  codex: ["gpt-5.4", "gpt-5.5", "gpt-5.3-codex-spark", "o3", "o4-mini"],
+  opencode: ["anthropic/claude-sonnet-4-6", "openai/gpt-5.4", "google/gemini-2.5-pro", "deepseek/deepseek-r3", "minimax/minimax-m2.5"]
+};
+var MODEL_ALIASES = {
+  claude: {
+    fable: "claude-fable-5"
+  }
+};
+var RUNTIME_LABELS = {
+  claude: "Claude Code (Anthropic)",
+  codex: "Codex (OpenAI)",
+  opencode: "OpenCode (open source)"
+};
+var DEFAULT_MODELS = {
+  claude: "claude-opus-4.6",
+  codex: RUNTIME_TABLE.codex?.defaultModel ?? "gpt-5.4",
+  opencode: RUNTIME_TABLE.opencode?.defaultModel ?? "anthropic/claude-sonnet-4-6"
+};
+function loadAgentConfig() {
+  if (!existsSync(AGENT_CONFIG_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync(AGENT_CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveAgentConfig(config) {
+  const dir = path.dirname(AGENT_CONFIG_PATH);
+  ensurePrivateDirSync(dir);
+  atomicWriteJsonSync(AGENT_CONFIG_PATH, config);
+}
+function getAgentRuntime(agentId) {
+  const config = loadAgentConfig();
+  const entry = config[agentId];
+  if (entry) return entry;
+  const orgDefault = config["default"];
+  if (orgDefault) return orgDefault;
+  return { runtime: DEFAULT_RUNTIME, model: DEFAULT_MODELS[DEFAULT_RUNTIME] };
+}
+function normalizeCcModelName(model) {
+  let ccModel = model.replace(/(\d+)\.(\d+)/g, "$1-$2");
+  if (/claude-(opus|sonnet)-4-[6-9]/.test(ccModel) && !ccModel.includes("[1m]")) {
+    ccModel += "[1m]";
+  }
+  return ccModel;
+}
+function normalizeRuntimeModel(runtime, model) {
+  return MODEL_ALIASES[runtime]?.[model] ?? model;
+}
+function validateRuntimeModel(runtime, model) {
+  const knownModels = KNOWN_RUNTIMES[runtime];
+  if (!knownModels) {
+    return {
+      ok: false,
+      error: `Unknown runtime "${runtime}". Valid: ${Object.keys(KNOWN_RUNTIMES).join(", ")}`
+    };
+  }
+  const normalizedModel = normalizeRuntimeModel(runtime, model);
+  if (!knownModels.includes(normalizedModel)) {
+    const aliases = Object.keys(MODEL_ALIASES[runtime] ?? {});
+    const valid = aliases.length > 0 ? `${knownModels.join(", ")} (aliases: ${aliases.join(", ")})` : knownModels.join(", ");
+    return {
+      ok: false,
+      error: `Unknown model "${model}" for runtime "${runtime}". Valid: ${valid}`
+    };
+  }
+  return { ok: true, model: normalizedModel };
+}
+function setAgentRuntime(agentId, runtime, model, reasoning_effort, mcps) {
+  const validated = validateRuntimeModel(runtime, model);
+  if (!validated.ok) return validated;
+  const config = loadAgentConfig();
+  const existing = config[agentId];
+  const entry = { runtime, model: validated.model };
+  if (reasoning_effort) entry.reasoning_effort = reasoning_effort;
+  if (mcps !== void 0) {
+    entry.mcps = mcps.includes("exe-os") ? mcps : ["exe-os", ...mcps];
+  } else if (existing?.mcps) {
+    entry.mcps = existing.mcps;
+  }
+  config[agentId] = entry;
+  saveAgentConfig(config);
+  return { ok: true };
+}
+function setAgentMcps(agentId, mcps) {
+  const config = loadAgentConfig();
+  const existing = config[agentId] ?? getAgentRuntime(agentId);
+  existing.mcps = mcps.includes("exe-os") ? mcps : ["exe-os", ...mcps];
+  config[agentId] = existing;
+  saveAgentConfig(config);
+  return { ok: true };
+}
+function clearAgentRuntime(agentId) {
+  const config = loadAgentConfig();
+  delete config[agentId];
+  saveAgentConfig(config);
+}
+
+export {
+  AGENT_CONFIG_PATH,
+  KNOWN_RUNTIMES,
+  MODEL_ALIASES,
+  RUNTIME_LABELS,
+  DEFAULT_MODELS,
+  loadAgentConfig,
+  saveAgentConfig,
+  getAgentRuntime,
+  normalizeCcModelName,
+  normalizeRuntimeModel,
+  validateRuntimeModel,
+  setAgentRuntime,
+  setAgentMcps,
+  clearAgentRuntime
+};

package/dist/chunk-H4SQZEKD.js

@@ -0,0 +1,41 @@
+import {
+  checkLicense,
+  loadLicense
+} from "./chunk-WREI3KQR.js";
+
+// src/lib/license-gate.ts
+var _cachedLicense = null;
+var _hasLicenseKey = false;
+async function initLicenseGate() {
+  const key = loadLicense();
+  _hasLicenseKey = key !== null && key.length > 0;
+  if (_hasLicenseKey) {
+    try {
+      _cachedLicense = await checkLicense();
+    } catch {
+      _cachedLicense = null;
+    }
+    return { license: _cachedLicense, hasKey: true };
+  }
+  return { license: null, hasKey: false };
+}
+function getCachedLicenseGate() {
+  if (!_hasLicenseKey) {
+    const key = loadLicense();
+    if (key && key.length > 0) {
+      _hasLicenseKey = true;
+      process.stderr.write("[license-gate] License key found on re-check (was missing at boot)\n");
+    }
+  }
+  return {
+    license: _cachedLicense,
+    hasKey: _hasLicenseKey
+  };
+}
+var NO_LICENSE_MESSAGE = "License key required. Get your key from the Exe OS team, then:\n\n  echo 'exe_sk_YOUR_KEY' > ~/.exe-os/license.key\n\nThen run /mcp to reconnect, or restart your session.";
+
+export {
+  initLicenseGate,
+  getCachedLicenseGate,
+  NO_LICENSE_MESSAGE
+};