@askexenow/exe-os 0.9.227 → 0.9.229

package/dist/chunk-V3QAAU2U.js

@@ -0,0 +1,129 @@
+import {
+  EMPLOYEES_PATH,
+  getClient,
+  isInitialized,
+  loadEmployees
+} from "./chunk-UJOSFVWG.js";
+import {
+  PLAN_LIMITS,
+  checkLicense,
+  isFeatureAllowed
+} from "./chunk-D4IVTUNN.js";
+import {
+  EXE_AI_DIR
+} from "./chunk-TNTFEWU5.js";
+
+// src/lib/plan-limits.ts
+import { readFileSync, existsSync } from "fs";
+import path from "path";
+var PlanLimitError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PlanLimitError";
+  }
+};
+var CACHE_PATH = path.join(EXE_AI_DIR, "license-cache.json");
+function getLicenseSync() {
+  try {
+    if (!existsSync(CACHE_PATH)) return freeLicense();
+    const raw = JSON.parse(readFileSync(CACHE_PATH, "utf8"));
+    if (!raw.token || typeof raw.token !== "string") return freeLicense();
+    const parts = raw.token.split(".");
+    if (parts.length !== 3) return freeLicense();
+    const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString());
+    const plan = payload.plan ?? "free";
+    const limits = PLAN_LIMITS[plan] ?? PLAN_LIMITS.free;
+    return {
+      valid: true,
+      plan,
+      email: payload.sub ?? "",
+      expiresAt: payload.exp ? new Date(payload.exp * 1e3).toISOString() : null,
+      deviceLimit: limits.devices,
+      employeeLimit: limits.employees,
+      memoryLimit: limits.memories
+    };
+  } catch {
+    return freeLicense();
+  }
+}
+function freeLicense() {
+  const limits = PLAN_LIMITS.free;
+  return {
+    valid: true,
+    plan: "free",
+    email: "",
+    expiresAt: null,
+    deviceLimit: limits.devices,
+    employeeLimit: limits.employees,
+    memoryLimit: limits.memories
+  };
+}
+async function countActiveMemories() {
+  if (!isInitialized()) return 0;
+  const client = getClient();
+  const result = await client.execute(
+    "SELECT COUNT(*) as cnt FROM memories WHERE status = 'active' OR status IS NULL"
+  );
+  const row = result.rows[0];
+  return Number(row?.cnt ?? 0);
+}
+async function assertMemoryLimit() {
+  const license = await checkLicense();
+  if (license.memoryLimit < 0) return;
+  const count = await countActiveMemories();
+  if (count >= license.memoryLimit) {
+    throw new PlanLimitError(
+      `Memory limit reached: ${count}/${license.memoryLimit} active memories on the ${license.plan} plan. Upgrade at https://askexe.com to store more.`
+    );
+  }
+}
+async function assertEmployeeLimit(license, rosterPath) {
+  const lic = license ?? await checkLicense();
+  if (lic.employeeLimit < 0) return;
+  const employees = await loadEmployees(rosterPath ?? EMPLOYEES_PATH);
+  if (employees.length >= lic.employeeLimit) {
+    throw new PlanLimitError(
+      `Employee limit reached: ${employees.length}/${lic.employeeLimit} employees on the ${lic.plan} plan. Upgrade at https://askexe.com to add more.`
+    );
+  }
+}
+function assertEmployeeLimitSync(rosterPath) {
+  const license = getLicenseSync();
+  if (license.employeeLimit < 0) return;
+  const filePath = rosterPath ?? EMPLOYEES_PATH;
+  let count = 0;
+  try {
+    if (existsSync(filePath)) {
+      const raw = readFileSync(filePath, "utf8");
+      const employees = JSON.parse(raw);
+      count = Array.isArray(employees) ? employees.length : 0;
+    }
+  } catch {
+    throw new PlanLimitError(
+      `Cannot verify employee count: roster unreadable at ${filePath}. Refusing to proceed. Check file permissions or upgrade plan.`
+    );
+  }
+  if (count >= license.employeeLimit) {
+    throw new PlanLimitError(
+      `Employee limit reached: ${count}/${license.employeeLimit} employees on the ${license.plan} plan. Upgrade at https://askexe.com to add more.`
+    );
+  }
+}
+async function assertFeature(feature) {
+  const license = await checkLicense();
+  if (!isFeatureAllowed(license, feature)) {
+    throw new PlanLimitError(
+      `Feature "${feature}" requires a paid plan. Current plan: ${license.plan}. Upgrade at https://askexe.com.`
+    );
+  }
+}
+
+export {
+  PlanLimitError,
+  getLicenseSync,
+  countActiveMemories,
+  assertMemoryLimit,
+  assertEmployeeLimit,
+  assertEmployeeLimitSync,
+  assertFeature
+};

package/dist/chunk-V4TZI6EO.js

@@ -0,0 +1,60 @@
+// src/lib/telemetry.ts
+var ENABLED = process.env.EXE_TELEMETRY === "1";
+var initialized = false;
+async function ensureInit() {
+  if (initialized || !ENABLED) return;
+  initialized = true;
+  try {
+    const { NodeSDK } = await import("@opentelemetry/sdk-node");
+    const { ConsoleSpanExporter } = await import("@opentelemetry/sdk-trace-base");
+    const sdk = new NodeSDK({
+      serviceName: "exe-os",
+      traceExporter: new ConsoleSpanExporter()
+    });
+    sdk.start();
+    process.stderr.write("[exe-os] OpenTelemetry tracing enabled\n");
+  } catch (err) {
+    process.stderr.write(
+      `[exe-os] OpenTelemetry init failed: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
+async function withTrace(toolName, fn) {
+  if (!ENABLED) return fn();
+  await ensureInit();
+  const { trace, SpanStatusCode } = await import("@opentelemetry/api");
+  const tracer = trace.getTracer("exe-os", "1.0.0");
+  return tracer.startActiveSpan(`mcp.tool.${toolName}`, async (span) => {
+    span.setAttribute("mcp.tool.name", toolName);
+    try {
+      const result = await fn();
+      span.setStatus({ code: SpanStatusCode.OK });
+      return result;
+    } catch (err) {
+      span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: err instanceof Error ? err.message : String(err)
+      });
+      span.recordException(
+        err instanceof Error ? err : new Error(String(err))
+      );
+      throw err;
+    } finally {
+      span.end();
+    }
+  });
+}
+function instrumentServer(server) {
+  if (!ENABLED) return;
+  const original = server.registerTool.bind(server);
+  server.registerTool = (name, config, handler) => {
+    const traced = async (...args) => withTrace(name, () => handler(...args));
+    return original(name, config, traced);
+  };
+}
+
+export {
+  withTrace,
+  instrumentServer
+};

package/dist/chunk-W6TC6A73.js

@@ -0,0 +1,77 @@
+import {
+  getActiveAgent
+} from "./chunk-DLXTKVBO.js";
+import {
+  listTasks
+} from "./chunk-UBMGUX6T.js";
+
+// src/mcp/tools/list-tasks.ts
+import { z } from "zod";
+function registerListTasks(server) {
+  server.registerTool(
+    "list_tasks",
+    {
+      title: "List Tasks",
+      description: "Query tasks by assignee, status, project, or priority. Defaults to current project. Pass project_name='all' for all projects. When querying your own tasks, project filter is skipped automatically.",
+      inputSchema: {
+        assigned_to: z.string().optional().describe("Filter by employee name"),
+        status: z.enum(["open", "in_progress", "done", "needs_review", "blocked", "cancelled", "closed"]).optional().describe("Filter by status. Default: active tasks only (excludes closed/cancelled)"),
+        project_name: z.string().optional().describe("Project name. Defaults to current project. Pass 'all' for all projects."),
+        priority: z.enum(["p0", "p1", "p2"]).optional().describe("Filter by priority"),
+        cross_session: z.boolean().optional().describe("When true, return tasks from ALL coordinator sessions (read-only). Default: false.")
+      }
+    },
+    async ({ assigned_to, status, project_name, priority, cross_session }) => {
+      try {
+        const { agentId, agentRole } = getActiveAgent();
+        const isOwnQuery = assigned_to && assigned_to === agentId;
+        const resolvedProject = project_name && project_name !== "all" ? project_name : null;
+        const { canCoordinate: canCoord } = await import("./lib/employees.js");
+        const effectiveCrossSession = canCoord(agentId, agentRole) ? cross_session ?? false : false;
+        const tasks = await listTasks({
+          assignedTo: assigned_to,
+          status,
+          projectName: resolvedProject,
+          priority,
+          crossSession: effectiveCrossSession,
+          isOwnQuery: !!isOwnQuery
+        });
+        if (tasks.length === 0) {
+          return {
+            content: [{ type: "text", text: "No tasks found." }]
+          };
+        }
+        const lines = tasks.map((t) => {
+          const cpIndicator = t.checkpointCount && t.checkpointCount > 0 ? ` [cp:${t.checkpointCount}]` : "";
+          let budgetNote = "";
+          if (t.budgetTokens !== null) {
+            const pct = Math.round(t.tokensUsed / t.budgetTokens * 100);
+            budgetNote = ` [${t.tokensUsed}/${t.budgetTokens} tokens, ${pct}%]`;
+          }
+          const shortId = t.id.slice(0, 8);
+          const sessionNote = cross_session && t.sessionScope ? ` [session:${t.sessionScope}]` : "";
+          return `- [${t.priority.toUpperCase()}] ${t.title} (${t.projectName}) \u2014 ${t.status}${cpIndicator}${budgetNote}${sessionNote} \u2192 ${t.assignedTo} [id:${shortId}]`;
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: `${tasks.length} task(s):
+${lines.join("\n")}`
+            }
+          ]
+        };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Failed to list tasks: ${msg}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+export {
+  registerListTasks
+};

package/dist/chunk-WA67SFFZ.js

@@ -0,0 +1,227 @@
+import {
+  getClient
+} from "./chunk-UJOSFVWG.js";
+
+// src/lib/token-spend.ts
+import { readdir, stat } from "fs/promises";
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+import path from "path";
+import os from "os";
+var MODEL_PRICING = {
+  // Opus 4.5+ ($5/$25 — Anthropic price drop from original Opus 4)
+  "claude-opus-4-7": { input: 5 / 1e6, output: 25 / 1e6, cacheRead: 0.5 / 1e6, cacheWrite: 6.25 / 1e6 },
+  "claude-opus-4-6": { input: 5 / 1e6, output: 25 / 1e6, cacheRead: 0.5 / 1e6, cacheWrite: 6.25 / 1e6 },
+  "claude-opus-4-5": { input: 5 / 1e6, output: 25 / 1e6, cacheRead: 0.5 / 1e6, cacheWrite: 6.25 / 1e6 },
+  // Opus 4.0/4.1 (legacy $15/$75)
+  "claude-opus-4-1": { input: 15 / 1e6, output: 75 / 1e6, cacheRead: 1.5 / 1e6, cacheWrite: 18.75 / 1e6 },
+  "claude-opus-4": { input: 15 / 1e6, output: 75 / 1e6, cacheRead: 1.5 / 1e6, cacheWrite: 18.75 / 1e6 },
+  // Sonnet 4.x
+  "claude-sonnet-4": { input: 3 / 1e6, output: 15 / 1e6, cacheRead: 0.3 / 1e6, cacheWrite: 3.75 / 1e6 },
+  // Sonnet 3.7/3.5
+  "claude-3-7-sonnet": { input: 3 / 1e6, output: 15 / 1e6, cacheRead: 0.3 / 1e6, cacheWrite: 3.75 / 1e6 },
+  "claude-3-5-sonnet": { input: 3 / 1e6, output: 15 / 1e6, cacheRead: 0.3 / 1e6, cacheWrite: 3.75 / 1e6 },
+  // Haiku 4.5
+  "claude-haiku-4-5": { input: 1 / 1e6, output: 5 / 1e6, cacheRead: 0.1 / 1e6, cacheWrite: 1.25 / 1e6 },
+  // Haiku 3.5
+  "claude-3-5-haiku": { input: 0.8 / 1e6, output: 4 / 1e6, cacheRead: 0.08 / 1e6, cacheWrite: 1 / 1e6 },
+  // Opus 3
+  "claude-3-opus": { input: 15 / 1e6, output: 75 / 1e6, cacheRead: 1.5 / 1e6, cacheWrite: 18.75 / 1e6 },
+  // Sonnet 3
+  "claude-3-sonnet": { input: 3 / 1e6, output: 15 / 1e6, cacheRead: 0.3 / 1e6, cacheWrite: 3.75 / 1e6 },
+  // Haiku 3
+  "claude-3-haiku": { input: 0.25 / 1e6, output: 1.25 / 1e6, cacheRead: 0.03 / 1e6, cacheWrite: 0.3 / 1e6 }
+};
+var DEFAULT_PRICING = MODEL_PRICING["claude-sonnet-4"];
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+var JSONL_INDEX_TTL_MS = 5 * 60 * 1e3;
+var USAGE_CACHE_MAX_ENTRIES = 1e4;
+var _spendCache = /* @__PURE__ */ new Map();
+var _spendInFlight = /* @__PURE__ */ new Map();
+var _usageCache = /* @__PURE__ */ new Map();
+var _usageInFlight = /* @__PURE__ */ new Map();
+var _jsonlPathIndex = null;
+function yieldToEventLoop() {
+  return new Promise((resolve) => setImmediate(resolve));
+}
+function getPricing(model) {
+  if (MODEL_PRICING[model]) return MODEL_PRICING[model];
+  const stripped = model.replace(/-\d{8}$/, "");
+  if (MODEL_PRICING[stripped]) return MODEL_PRICING[stripped];
+  const sortedKeys = Object.keys(MODEL_PRICING).sort((a, b) => b.length - a.length);
+  for (const key of sortedKeys) {
+    if (model.includes(key)) return MODEL_PRICING[key];
+  }
+  return DEFAULT_PRICING;
+}
+async function getAgentSpend(period = "7d") {
+  const cached = _spendCache.get(period);
+  if (cached && Date.now() < cached.expires) {
+    return cached.result;
+  }
+  const inFlight = _spendInFlight.get(period);
+  if (inFlight) return inFlight;
+  const promise = computeAgentSpend(period).finally(() => _spendInFlight.delete(period));
+  _spendInFlight.set(period, promise);
+  return promise;
+}
+async function computeAgentSpend(period) {
+  const cutoff = periodToCutoff(period);
+  const client = getClient();
+  const dbResult = await client.execute({
+    sql: `SELECT session_uuid, agent_id FROM session_agent_map WHERE started_at >= ?`,
+    args: [cutoff]
+  });
+  if (dbResult.rows.length === 0) return [];
+  const sessionAgent = /* @__PURE__ */ new Map();
+  for (const row of dbResult.rows) {
+    sessionAgent.set(row.session_uuid, row.agent_id);
+  }
+  const jsonlPaths = await getClaudeSessionJsonlIndex();
+  if (jsonlPaths.size === 0) return [];
+  const agentTotals = /* @__PURE__ */ new Map();
+  let processed = 0;
+  for (const [sessionUuid, agentId] of sessionAgent) {
+    const jsonlPath = jsonlPaths.get(sessionUuid);
+    if (!jsonlPath) continue;
+    try {
+      const usage = await extractSessionUsageCached(jsonlPath);
+      if (usage.input === 0 && usage.output === 0) continue;
+      const totals = agentTotals.get(agentId) ?? {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheCreate: 0,
+        costUSD: 0,
+        sessions: /* @__PURE__ */ new Set()
+      };
+      totals.input += usage.input;
+      totals.output += usage.output;
+      totals.cacheRead += usage.cacheRead;
+      totals.cacheCreate += usage.cacheCreate;
+      totals.costUSD += usage.costUSD;
+      totals.sessions.add(sessionUuid);
+      agentTotals.set(agentId, totals);
+    } catch {
+    }
+    processed++;
+    if (processed % 25 === 0) await yieldToEventLoop();
+  }
+  const result = Array.from(agentTotals.entries()).map(([agentId, t]) => ({
+    agentId,
+    inputTokens: t.input,
+    outputTokens: t.output,
+    cacheReadTokens: t.cacheRead,
+    cacheCreationTokens: t.cacheCreate,
+    costUSD: t.costUSD,
+    sessions: t.sessions.size,
+    period
+  })).sort((a, b) => b.costUSD - a.costUSD);
+  _spendCache.set(period, { result, expires: Date.now() + CACHE_TTL_MS });
+  return result;
+}
+async function getClaudeSessionJsonlIndex() {
+  if (_jsonlPathIndex && Date.now() < _jsonlPathIndex.expires) {
+    return _jsonlPathIndex.paths;
+  }
+  const claudeDir = path.join(os.homedir(), ".claude", "projects");
+  const paths = /* @__PURE__ */ new Map();
+  let projectDirs = [];
+  try {
+    const entries = await readdir(claudeDir, { withFileTypes: true });
+    projectDirs = entries.filter((entry) => entry.isDirectory()).map((entry) => path.join(claudeDir, entry.name));
+  } catch {
+    _jsonlPathIndex = { expires: Date.now() + JSONL_INDEX_TTL_MS, paths };
+    return paths;
+  }
+  let scanned = 0;
+  for (const dir of projectDirs) {
+    try {
+      const files = await readdir(dir);
+      for (const file of files) {
+        if (!file.endsWith(".jsonl")) continue;
+        paths.set(file.slice(0, -".jsonl".length), path.join(dir, file));
+      }
+    } catch {
+    }
+    scanned++;
+    if (scanned % 25 === 0) await yieldToEventLoop();
+  }
+  _jsonlPathIndex = { expires: Date.now() + JSONL_INDEX_TTL_MS, paths };
+  return paths;
+}
+async function extractSessionUsageCached(jsonlPath) {
+  const st = await stat(jsonlPath);
+  const cached = _usageCache.get(jsonlPath);
+  if (cached && cached.mtimeMs === st.mtimeMs && cached.size === st.size) {
+    return cached.usage;
+  }
+  const existing = _usageInFlight.get(jsonlPath);
+  if (existing) return existing;
+  const promise = extractSessionUsage(jsonlPath).then((usage) => {
+    _usageCache.set(jsonlPath, { mtimeMs: st.mtimeMs, size: st.size, usage });
+    pruneUsageCache();
+    return usage;
+  }).finally(() => _usageInFlight.delete(jsonlPath));
+  _usageInFlight.set(jsonlPath, promise);
+  return promise;
+}
+function pruneUsageCache() {
+  if (_usageCache.size <= USAGE_CACHE_MAX_ENTRIES) return;
+  const overflow = _usageCache.size - USAGE_CACHE_MAX_ENTRIES;
+  let removed = 0;
+  for (const key of _usageCache.keys()) {
+    _usageCache.delete(key);
+    removed++;
+    if (removed >= overflow) break;
+  }
+}
+async function extractSessionUsage(jsonlPath) {
+  let input = 0;
+  let output = 0;
+  let cacheRead = 0;
+  let cacheCreate = 0;
+  let costUSD = 0;
+  const seenMessageIds = /* @__PURE__ */ new Set();
+  const rl = createInterface({
+    input: createReadStream(jsonlPath, { encoding: "utf8" }),
+    crlfDelay: Infinity
+  });
+  for await (const line of rl) {
+    if (!line.includes('"type":"assistant"')) continue;
+    try {
+      const record = JSON.parse(line);
+      if (record.type !== "assistant") continue;
+      const messageId = record.message?.id;
+      if (messageId) {
+        if (seenMessageIds.has(messageId)) continue;
+        seenMessageIds.add(messageId);
+      }
+      const usage = record.message?.usage;
+      if (!usage) continue;
+      const model = record.message?.model ?? "";
+      const pricing = getPricing(model);
+      const inp = usage.input_tokens ?? 0;
+      const out = usage.output_tokens ?? 0;
+      const cr = usage.cache_read_input_tokens ?? 0;
+      const cc = usage.cache_creation_input_tokens ?? 0;
+      input += inp;
+      output += out;
+      cacheRead += cr;
+      cacheCreate += cc;
+      if (pricing) {
+        costUSD += inp * pricing.input + out * pricing.output + cr * pricing.cacheRead + cc * pricing.cacheWrite;
+      }
+    } catch {
+    }
+  }
+  return { input, output, cacheRead, cacheCreate, costUSD };
+}
+function periodToCutoff(period) {
+  const ms = { "24h": 864e5, "7d": 6048e5, "30d": 2592e6 }[period];
+  return new Date(Date.now() - ms).toISOString();
+}
+
+export {
+  getAgentSpend
+};