@trops/dash-core 0.1.622 → 0.1.623

package/dist/electron/index.js

@@ -972,10 +972,15 @@ const BOTS_RUN$1 = "bots-run";
 const BOTS_STOP$1 = "bots-stop";
 const BOTS_APPROVE$1 = "bots-approve";
 const BOTS_LIST_APPROVALS$1 = "bots-list-approvals";
+const BOTS_GET_BUDGETS$1 = "bots-get-budgets";
+const BOTS_SET_BUDGET$1 = "bots-set-budget";
+const BOTS_GET_SPEND$1 = "bots-get-spend";
+const BOTS_RESUME_BUDGET$1 = "bots-resume-budget";
 
 // --- Main → Renderer (send) ---
 const BOT_STREAM$2 = "bot-stream"; // { botId, event: BotEvent }
 const BOT_APPROVAL_PENDING$2 = "bot-approval-pending"; // { id, request }
+const BOT_BUDGET_ALERT$2 = "bot-budget-alert"; // { botId, cost, estimated, status }
 
 var botEvents$1 = {
   BOTS_LIST: BOTS_LIST$1,
@@ -986,8 +991,13 @@ var botEvents$1 = {
   BOTS_STOP: BOTS_STOP$1,
   BOTS_APPROVE: BOTS_APPROVE$1,
   BOTS_LIST_APPROVALS: BOTS_LIST_APPROVALS$1,
+  BOTS_GET_BUDGETS: BOTS_GET_BUDGETS$1,
+  BOTS_SET_BUDGET: BOTS_SET_BUDGET$1,
+  BOTS_GET_SPEND: BOTS_GET_SPEND$1,
+  BOTS_RESUME_BUDGET: BOTS_RESUME_BUDGET$1,
   BOT_STREAM: BOT_STREAM$2,
   BOT_APPROVAL_PENDING: BOT_APPROVAL_PENDING$2,
+  BOT_BUDGET_ALERT: BOT_BUDGET_ALERT$2,
 };
 
 /**
@@ -40808,7 +40818,7 @@ function getProvider$2(providerId) {
   return PROVIDERS[providerId] || PROVIDERS[DEFAULT_PROVIDER$1];
 }
 
-function getCuratedModels(providerId) {
+function getCuratedModels$1(providerId) {
   return getProvider$2(providerId).curatedModels.slice();
 }
 
@@ -40860,7 +40870,7 @@ var modelProviders = {
   PROVIDERS,
   DEFAULT_PROVIDER: DEFAULT_PROVIDER$1,
   getProvider: getProvider$2,
-  getCuratedModels,
+  getCuratedModels: getCuratedModels$1,
   getDefaultModel: getDefaultModel$1,
   migrateModelId: migrateModelId$3,
   isKnownRetired,
@@ -73658,6 +73668,7 @@ const Store = require$$0$5;
  */
 function createElectronHost$1() {
   const store = new Store({ name: "dash-bots" });
+  const budgetStore = new Store({ name: "dash-bot-budgets" });
   const botsRoot = path$3.join(app$2.getPath("userData"), "bots");
 
   return {
@@ -73669,6 +73680,12 @@ function createElectronHost$1() {
       read: () => store.get("store", { bots: {}, runs: {} }),
       write: (obj) => store.set("store", obj),
     },
+    // Separate blob for budgets + monthly spend (Slice 5).
+    budgetPersistence: {
+      read: () =>
+        budgetStore.get("store", { budgets: {}, spend: {}, overrides: {} }),
+      write: (obj) => budgetStore.set("store", obj),
+    },
   };
 }
 
@@ -74929,6 +74946,9 @@ let BotRunner$1 = class BotRunner {
       deps.makeRequestPermission || createRequestPermission;
     this._gate = deps.gate; // forwarded to PermissionGate ctx (optional)
     this._isPaused = deps.isPaused || (() => false);
+    // Called after each run with the run's token usage so budgets (Slice 5)
+    // can accrue cost. Optional — default no-op keeps the runner portable.
+    this._onUsage = deps.onUsage || null;
     /** @type {Map<string, AbortController>} */
     this._active = new Map();
   }
@@ -74979,9 +74999,11 @@ let BotRunner$1 = class BotRunner {
     let status = "completed";
     let usage = null;
     let errorMessage = null;
+    let runProfile = null;
 
     try {
       const profile = await this._resolveRunProfile(bot);
+      runProfile = profile;
       const engine = this._engines.getEngine(profile.engineId);
       if (!engine) {
         throw new Error(`no engine registered for "${profile.engineId}"`);
@@ -75068,6 +75090,19 @@ let BotRunner$1 = class BotRunner {
       error: errorMessage,
     };
     this._store.appendRun(botId, runRecord);
+
+    // Feed usage to budgets (Slice 5). Optional hook; only when we captured
+    // usage and know which provider/model produced it.
+    if (usage && runProfile && this._onUsage) {
+      this._onUsage({
+        botId,
+        workspaceId: bot.workspaceId,
+        providerId: runProfile.providerId,
+        model: runProfile.model,
+        usage,
+      });
+    }
+
     return runRecord;
   }
 };
@@ -75180,6 +75215,211 @@ let BotScheduler$1 = class BotScheduler {
 
 var BotScheduler_1 = BotScheduler$1;
 
+var BudgetController$2 = {exports: {}};
+
+/**
+ * BudgetController.js
+ *
+ * Per-run cost capture and monthly spend limits for bots (PRD US-019 / FR-017).
+ * Records each run's token usage as a dollar cost (from the provider registry's
+ * per-model pricing), accrues it to bot / workspace / global monthly buckets,
+ * and reports status: ok, warn (≥80%), or exceeded (≥100%). A bot that has
+ * exceeded any applicable budget is over-budget and should auto-pause; the user
+ * may explicitly (and audibly) override to keep it running for the rest of the
+ * month.
+ *
+ * Portable (NFR-006): persistence, pricing lookup, clock, and audit sink are
+ * injected. No Electron.
+ *
+ *   new BudgetController({ persistence, getPricing, clock?, audit? })
+ *     persistence: { read(): object, write(obj): void }   // { budgets, spend, overrides }
+ *     getPricing:  (providerId, model) => { input, output } | null   // USD per 1M tokens
+ *     clock:       () => number (epoch ms)
+ *     audit:       (entry) => void
+ */
+
+const WARN_AT = 0.8;
+
+function monthKey(ms) {
+  const d = new Date(ms);
+  return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, "0")}`;
+}
+
+function scopeKey(scope, id) {
+  if (scope === "global") return "global";
+  if (scope === "workspace") return `workspace:${id}`;
+  if (scope === "bot") return `bot:${id}`;
+  throw new Error(`BudgetController: unknown scope "${scope}"`);
+}
+
+function stateFor(spent, budget) {
+  if (!(budget > 0)) return "ok"; // no limit set
+  const pct = spent / budget;
+  if (pct >= 1) return "exceeded";
+  if (pct >= WARN_AT) return "warn";
+  return "ok";
+}
+
+// Most-restrictive wins.
+const RANK = { ok: 0, warn: 1, exceeded: 2 };
+
+let BudgetController$1 = class BudgetController {
+  constructor({ persistence, getPricing, clock, audit } = {}) {
+    if (!persistence || typeof persistence.read !== "function") {
+      throw new Error(
+        "BudgetController: persistence with read()/write() is required",
+      );
+    }
+    this._persistence = persistence;
+    this._getPricing = getPricing || (() => null);
+    this._now = clock || (() => Date.now());
+    this._audit = audit || (() => {});
+  }
+
+  _load() {
+    const d = this._persistence.read() || {};
+    if (!d.budgets) d.budgets = {};
+    if (!d.spend) d.spend = {};
+    if (!d.overrides) d.overrides = {};
+    return d;
+  }
+
+  _save(d) {
+    this._persistence.write(d);
+  }
+
+  /** Set a monthly USD limit for a scope. @param scope "bot"|"workspace"|"global" */
+  setBudget(scope, id, monthlyUsd) {
+    const key = scopeKey(scope, id);
+    const d = this._load();
+    if (monthlyUsd == null) delete d.budgets[key];
+    else d.budgets[key] = monthlyUsd;
+    this._save(d);
+    this._audit({ type: "budget-set", scope: key, monthlyUsd });
+    return d.budgets[key];
+  }
+
+  /** @returns {object} scopeKey → monthly USD limit */
+  getBudgets() {
+    return { ...this._load().budgets };
+  }
+
+  /**
+   * Record a run's usage. Accrues cost to the bot/workspace/global buckets for
+   * the current month.
+   * @returns {{ cost: number, estimated: boolean, status: object }}
+   */
+  recordUsage({ botId, workspaceId, providerId, model, usage } = {}) {
+    const inTok = (usage && usage.inputTokens) || 0;
+    const outTok = (usage && usage.outputTokens) || 0;
+    const pricing = this._getPricing(providerId, model);
+    let cost = 0;
+    let estimated = false;
+    if (pricing) {
+      cost = (inTok / 1e6) * pricing.input + (outTok / 1e6) * pricing.output;
+    } else {
+      // Unknown pricing — track tokens only and flag the figure as estimated.
+      estimated = true;
+    }
+
+    const d = this._load();
+    const mk = monthKey(this._now());
+    if (!d.spend[mk]) d.spend[mk] = {};
+
+    const keys = [scopeKey("bot", botId), scopeKey("global")];
+    if (workspaceId) keys.splice(1, 0, scopeKey("workspace", workspaceId));
+    for (const key of keys) {
+      const bucket = d.spend[mk][key] || {
+        usd: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+      };
+      bucket.usd += cost;
+      bucket.inputTokens += inTok;
+      bucket.outputTokens += outTok;
+      d.spend[mk][key] = bucket;
+    }
+    this._save(d);
+
+    this._audit({
+      type: "usage",
+      botId,
+      workspaceId,
+      cost,
+      estimated,
+      inTok,
+      outTok,
+    });
+    return { cost, estimated, status: this.status(botId, workspaceId) };
+  }
+
+  _spent(mk, key) {
+    const d = this._load();
+    return (d.spend[mk] && d.spend[mk][key] && d.spend[mk][key].usd) || 0;
+  }
+
+  /**
+   * Budget status for a bot across its applicable scopes.
+   * @returns {{ scopes: object[], overall: "ok"|"warn"|"exceeded" }}
+   */
+  status(botId, workspaceId) {
+    const d = this._load();
+    const mk = monthKey(this._now());
+    const applicable = [scopeKey("bot", botId)];
+    if (workspaceId) applicable.push(scopeKey("workspace", workspaceId));
+    applicable.push(scopeKey("global"));
+
+    const scopes = [];
+    let overall = "ok";
+    for (const key of applicable) {
+      const budget = d.budgets[key];
+      if (budget == null) continue; // no limit for this scope
+      const spent = this._spent(mk, key);
+      const state = stateFor(spent, budget);
+      scopes.push({ scope: key, spent, budget, pct: spent / budget, state });
+      if (RANK[state] > RANK[overall]) overall = state;
+    }
+    return { scopes, overall };
+  }
+
+  /**
+   * Whether a bot should be paused for budget. True when any applicable budget
+   * is exceeded AND the user hasn't overridden for this month.
+   */
+  isOverBudget(botId, workspaceId) {
+    const mk = monthKey(this._now());
+    const d = this._load();
+    if (d.overrides[mk] && d.overrides[mk][botId]) return false;
+    return this.status(botId, workspaceId).overall === "exceeded";
+  }
+
+  /**
+   * Explicit, audited override to keep a budget-exceeded bot running for the
+   * rest of the current month (US-019 AC6). Cleared automatically next month
+   * (overrides are keyed by month).
+   */
+  resumeOverBudget(botId) {
+    const d = this._load();
+    const mk = monthKey(this._now());
+    if (!d.overrides[mk]) d.overrides[mk] = {};
+    d.overrides[mk][botId] = true;
+    this._save(d);
+    this._audit({ type: "budget-override", botId, month: mk });
+    return true;
+  }
+
+  /** @returns {object} spend buckets for a month (default current) */
+  getSpend(mk) {
+    const d = this._load();
+    return d.spend[mk || monthKey(this._now())] || {};
+  }
+};
+
+BudgetController$2.exports = BudgetController$1;
+BudgetController$2.exports.WARN_AT = WARN_AT;
+
+var BudgetControllerExports = BudgetController$2.exports;
+
 /**
  * mcpResult.js
  *
@@ -75244,14 +75484,26 @@ const ApprovalRegistry = approvalsExports;
 const engines = engines$1;
 const BotRunner = BotRunner_1;
 const BotScheduler = BotScheduler_1;
+const BudgetController = BudgetControllerExports;
 const { normalizeMcpResult } = mcpResult;
 const {
   getProvider: getProvider$1,
   getDefaultModel,
+  getCuratedModels,
   migrateModelId,
   DEFAULT_PROVIDER,
 } = modelProviders;
-const { BOT_STREAM: BOT_STREAM$1, BOT_APPROVAL_PENDING: BOT_APPROVAL_PENDING$1 } = botEvents$1;
+const {
+  BOT_STREAM: BOT_STREAM$1,
+  BOT_APPROVAL_PENDING: BOT_APPROVAL_PENDING$1,
+  BOT_BUDGET_ALERT: BOT_BUDGET_ALERT$1,
+} = botEvents$1;
+
+/** Pricing lookup for BudgetController: curated-model pricing by provider. */
+function pricingFor(providerId, model) {
+  const m = getCuratedModels(providerId).find((c) => c.value === model);
+  return (m && m.pricing) || null;
+}
 
 const botController$1 = {
   _ready: false,
@@ -75299,6 +75551,12 @@ const botController$1 = {
       },
     };
 
+    // Budgets: accrue per-run cost, auto-pause bots over their monthly cap.
+    this._budgets = new BudgetController({
+      persistence: host.budgetPersistence,
+      getPricing: pricingFor,
+    });
+
     this._runner = new BotRunner({
       engines,
       store: this._store,
@@ -75307,6 +75565,24 @@ const botController$1 = {
       resolveTools: (bot) => this._resolveTools(bot),
       callTool: (serverName, toolName, args, o) =>
         this._callTool(serverName, toolName, args, o),
+      // A bot over any applicable budget is paused at the permission gate.
+      isPaused: (botId) =>
+        this._budgets.isOverBudget(
+          botId,
+          (this._store.get(botId) || {}).workspaceId,
+        ),
+      // After each run, accrue cost and alert on warn/exceeded.
+      onUsage: (u) => {
+        const r = this._budgets.recordUsage(u);
+        if (r.status.overall !== "ok") {
+          this._broadcast(BOT_BUDGET_ALERT$1, {
+            botId: u.botId,
+            cost: r.cost,
+            estimated: r.estimated,
+            status: r.status,
+          });
+        }
+      },
     });
 
     this._scheduler = new BotScheduler({
@@ -75374,6 +75650,26 @@ const botController$1 = {
     return this._approvals.list();
   },
 
+  // ---- budgets (US-019) ---------------------------------------------------
+
+  getBudgets() {
+    return this._budgets.getBudgets();
+  },
+
+  setBudget(scope, id, monthlyUsd) {
+    return this._budgets.setBudget(scope, id, monthlyUsd);
+  },
+
+  /** Current-month (or given month) spend buckets by scope. */
+  getSpend(month) {
+    return this._budgets.getSpend(month);
+  },
+
+  /** Explicit, audited override to keep a budget-exceeded bot running. */
+  resumeBudget(botId) {
+    return this._budgets.resumeOverBudget(botId);
+  },
+
   // ---- internals ----------------------------------------------------------
 
   _run(botId, opts) {
@@ -79367,8 +79663,13 @@ const {
   BOTS_STOP,
   BOTS_APPROVE,
   BOTS_LIST_APPROVALS,
+  BOTS_GET_BUDGETS,
+  BOTS_SET_BUDGET,
+  BOTS_GET_SPEND,
+  BOTS_RESUME_BUDGET,
   BOT_STREAM,
   BOT_APPROVAL_PENDING,
+  BOT_BUDGET_ALERT,
 } = botEvents$1;
 
 let _nextListenerId = 0;
@@ -79397,10 +79698,20 @@ const botApi$1 = {
     ipcRenderer$3.invoke(BOTS_APPROVE, { approvalId, decision }),
   listApprovals: () => ipcRenderer$3.invoke(BOTS_LIST_APPROVALS),
 
+  // --- Budgets (US-019) ---
+  getBudgets: () => ipcRenderer$3.invoke(BOTS_GET_BUDGETS),
+  /** scope: "bot"|"workspace"|"global" */
+  setBudget: (scope, id, monthlyUsd) =>
+    ipcRenderer$3.invoke(BOTS_SET_BUDGET, { scope, id, monthlyUsd }),
+  getSpend: (month) => ipcRenderer$3.invoke(BOTS_GET_SPEND, { month }),
+  resumeBudget: (botId) => ipcRenderer$3.invoke(BOTS_RESUME_BUDGET, { botId }),
+
   /** Subscribe to streamed run events: { botId, event }. */
   onStream: (callback) => _addListener(BOT_STREAM, callback),
   /** Subscribe to new pending approvals: { id, request }. */
   onApprovalPending: (callback) => _addListener(BOT_APPROVAL_PENDING, callback),
+  /** Subscribe to budget warn/exceeded alerts. */
+  onBudgetAlert: (callback) => _addListener(BOT_BUDGET_ALERT, callback),
 
   removeListener: (id) => {
     const entry = _listenerMap.get(id);