@trops/dash-core 0.1.624 → 0.1.626

package/dist/electron/index.js

@@ -976,11 +976,18 @@ 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";
+const BOTS_LIST_RUNNING$1 = "bots-list-running";
+const BOTS_PAUSE_ALL$1 = "bots-pause-all";
+const BOTS_RESUME_ALL$1 = "bots-resume-all";
+const BOTS_PAUSE_BOT$1 = "bots-pause-bot";
+const BOTS_RESUME_BOT$1 = "bots-resume-bot";
+const BOTS_GET_PAUSE_STATE$1 = "bots-get-pause-state";
 
 // --- 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 }
+const BOT_RUN_ACTIVE$2 = "bot-run-active"; // { count, running: string[] }
 
 var botEvents$1 = {
   BOTS_LIST: BOTS_LIST$1,
@@ -995,9 +1002,16 @@ var botEvents$1 = {
   BOTS_SET_BUDGET: BOTS_SET_BUDGET$1,
   BOTS_GET_SPEND: BOTS_GET_SPEND$1,
   BOTS_RESUME_BUDGET: BOTS_RESUME_BUDGET$1,
+  BOTS_LIST_RUNNING: BOTS_LIST_RUNNING$1,
+  BOTS_PAUSE_ALL: BOTS_PAUSE_ALL$1,
+  BOTS_RESUME_ALL: BOTS_RESUME_ALL$1,
+  BOTS_PAUSE_BOT: BOTS_PAUSE_BOT$1,
+  BOTS_RESUME_BOT: BOTS_RESUME_BOT$1,
+  BOTS_GET_PAUSE_STATE: BOTS_GET_PAUSE_STATE$1,
   BOT_STREAM: BOT_STREAM$2,
   BOT_APPROVAL_PENDING: BOT_APPROVAL_PENDING$2,
   BOT_BUDGET_ALERT: BOT_BUDGET_ALERT$2,
+  BOT_RUN_ACTIVE: BOT_RUN_ACTIVE$2,
 };
 
 /**
@@ -75420,6 +75434,63 @@ BudgetController$2.exports.WARN_AT = WARN_AT;
 
 var BudgetControllerExports = BudgetController$2.exports;
 
+/**
+ * PauseController.js
+ *
+ * Holds bot pause state and answers "is this bot paused?" for the permission
+ * gate (PRD US-014). Pause is enforced at the gate: while paused, every tool
+ * call is denied, so any engine halts at its next tool boundary. Two levels
+ * ship here — a global "pause all" kill switch and per-bot pause; the workspace/
+ * project levels layer on later using the same shape.
+ *
+ * Portable (NFR-006): pure state, injected audit sink, no Electron.
+ */
+
+let PauseController$1 = class PauseController {
+  constructor({ audit } = {}) {
+    this._global = false;
+    this._bots = new Set();
+    this._audit = audit || (() => {});
+  }
+
+  /** Global kill switch — pauses every bot (US-014 AC7). */
+  pauseAll() {
+    this._global = true;
+    this._audit({ type: "pause-all" });
+  }
+
+  resumeAll() {
+    this._global = false;
+    this._audit({ type: "resume-all" });
+  }
+
+  isGloballyPaused() {
+    return this._global;
+  }
+
+  pauseBot(botId) {
+    this._bots.add(botId);
+    this._audit({ type: "pause-bot", botId });
+  }
+
+  resumeBot(botId) {
+    this._bots.delete(botId);
+    this._audit({ type: "resume-bot", botId });
+  }
+
+  /** True when the global switch is on OR this bot is individually paused. */
+  isPaused(botId) {
+    return this._global || this._bots.has(botId);
+  }
+
+  /** @returns {{ global: boolean, bots: string[] }} */
+  list() {
+    return { global: this._global, bots: [...this._bots] };
+  }
+};
+
+var PauseController_1 = PauseController$1;
+
 /**
  * mcpResult.js
  *
@@ -75485,6 +75556,7 @@ const engines = engines$1;
 const BotRunner = BotRunner_1;
 const BotScheduler = BotScheduler_1;
 const BudgetController = BudgetControllerExports;
+const PauseController = PauseController_1;
 const { normalizeMcpResult } = mcpResult;
 const {
   getProvider: getProvider$1,
@@ -75497,6 +75569,7 @@ const {
   BOT_STREAM: BOT_STREAM$1,
   BOT_APPROVAL_PENDING: BOT_APPROVAL_PENDING$1,
   BOT_BUDGET_ALERT: BOT_BUDGET_ALERT$1,
+  BOT_RUN_ACTIVE: BOT_RUN_ACTIVE$1,
 } = botEvents$1;
 
 /** Pricing lookup for BudgetController: curated-model pricing by provider. */
@@ -75551,6 +75624,9 @@ const botController$1 = {
       },
     };
 
+    // Pause state (global kill switch + per-bot), enforced at the gate.
+    this._pause = new PauseController();
+
     // Budgets: accrue per-run cost, auto-pause bots over their monthly cap.
     this._budgets = new BudgetController({
       persistence: host.budgetPersistence,
@@ -75565,8 +75641,10 @@ 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.
+      // Paused at the permission gate when: globally/individually paused, or
+      // over any applicable budget.
       isPaused: (botId) =>
+        this._pause.isPaused(botId) ||
         this._budgets.isOverBudget(
           botId,
           (this._store.get(botId) || {}).workspaceId,
@@ -75670,14 +75748,63 @@ const botController$1 = {
     return this._budgets.resumeOverBudget(botId);
   },
 
+  // ---- background / pause (US-014, US-018) ---------------------------------
+
+  /** @returns {Array<{id: string, name: string}>} bots with an in-flight run */
+  listRunning() {
+    return this._runner.listActive().map((id) => ({
+      id,
+      name: (this._store.get(id) || {}).name || id,
+    }));
+  },
+
+  pauseAll() {
+    this._pause.pauseAll();
+    return this._pause.list();
+  },
+
+  resumeAll() {
+    this._pause.resumeAll();
+    return this._pause.list();
+  },
+
+  pauseBot(botId) {
+    this._pause.pauseBot(botId);
+    return this._pause.list();
+  },
+
+  resumeBot(botId) {
+    this._pause.resumeBot(botId);
+    return this._pause.list();
+  },
+
+  isGloballyPaused() {
+    return this._pause.isGloballyPaused();
+  },
+
+  getPauseState() {
+    return this._pause.list();
+  },
+
   // ---- internals ----------------------------------------------------------
 
   _run(botId, opts) {
-    return this._runner.run(botId, {
+    const p = this._runner.run(botId, {
       prompt: opts.prompt,
       trigger: opts.trigger,
       emit: (event) => this._broadcast(BOT_STREAM$1, { botId, event }),
     });
+    // The runner marks the bot active synchronously, so the active count is
+    // already updated here. Broadcast on start and again on completion so the
+    // tray/powerSaveBlocker can react (US-018).
+    this._broadcastRunActive();
+    Promise.resolve(p).finally(() => this._broadcastRunActive());
+    return p;
+  },
+
+  _broadcastRunActive() {
+    const running = this._runner.listActive();
+    this._broadcast(BOT_RUN_ACTIVE$1, { count: running.length, running });
   },
 
   _broadcast(channel, payload) {
@@ -79667,9 +79794,16 @@ const {
   BOTS_SET_BUDGET,
   BOTS_GET_SPEND,
   BOTS_RESUME_BUDGET,
+  BOTS_LIST_RUNNING,
+  BOTS_PAUSE_ALL,
+  BOTS_RESUME_ALL,
+  BOTS_PAUSE_BOT,
+  BOTS_RESUME_BOT,
+  BOTS_GET_PAUSE_STATE,
   BOT_STREAM,
   BOT_APPROVAL_PENDING,
   BOT_BUDGET_ALERT,
+  BOT_RUN_ACTIVE,
 } = botEvents$1;
 
 let _nextListenerId = 0;
@@ -79706,12 +79840,22 @@ const botApi$1 = {
   getSpend: (month) => ipcRenderer$3.invoke(BOTS_GET_SPEND, { month }),
   resumeBudget: (botId) => ipcRenderer$3.invoke(BOTS_RESUME_BUDGET, { botId }),
 
+  // --- Background / pause (US-014, US-018) ---
+  listRunning: () => ipcRenderer$3.invoke(BOTS_LIST_RUNNING),
+  pauseAll: () => ipcRenderer$3.invoke(BOTS_PAUSE_ALL),
+  resumeAll: () => ipcRenderer$3.invoke(BOTS_RESUME_ALL),
+  pauseBot: (botId) => ipcRenderer$3.invoke(BOTS_PAUSE_BOT, { botId }),
+  resumeBot: (botId) => ipcRenderer$3.invoke(BOTS_RESUME_BOT, { botId }),
+  getPauseState: () => ipcRenderer$3.invoke(BOTS_GET_PAUSE_STATE),
+
   /** 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),
+  /** Subscribe to active-run count changes: { count, running }. */
+  onRunActive: (callback) => _addListener(BOT_RUN_ACTIVE, callback),
 
   removeListener: (id) => {
     const entry = _listenerMap.get(id);