@trops/dash-core 0.1.654 → 0.1.655

package/dist/electron/index.js

@@ -76904,11 +76904,21 @@ var PauseController_1 = PauseController$1;
  * v1; SQLite can later slot in behind this exact interface if volume demands.
  */
 
-const VALID_SCOPES = ["workspace", "global"];
+const VALID_SCOPES = ["workspace", "global", "bot"];
 
-/** Bucket key for a (scope, id) pair. Global collapses all ids to one bucket. */
+/**
+ * Bucket key for a (scope, id) pair. Global collapses all ids to one bucket;
+ * "workspace" is a team's shared memory (id = the dashboard); "bot" is one
+ * bot's private memory (id = the bot) — used by bots with no dashboard, so
+ * they don't share one bucket.
+ */
 function bucketKey(scope, id) {
-  return scope === "global" ? "global" : `workspace:${id || "default"}`;
+  if (scope === "global") return "global";
+  if (scope === "bot") {
+    if (!id) throw new Error("BotMemory: the 'bot' scope needs a bot id");
+    return `bot:${id}`;
+  }
+  return `workspace:${id || "default"}`;
 }
 
 let BotMemory$1 = class BotMemory {
@@ -76969,6 +76979,21 @@ let BotMemory$1 = class BotMemory {
   }
 
   /** @returns {boolean} true if a value was removed. */
+  /**
+   * A bot was deleted: drop its private memory (the "bot" scope). Team and
+   * global memory are shared, so they're never touched.
+   * @returns {boolean} whether there was anything to remove
+   */
+  forgetBot(botId) {
+    if (!botId) return false;
+    const blob = this._read();
+    const key = bucketKey("bot", botId);
+    if (!blob.scopes[key]) return false;
+    delete blob.scopes[key];
+    this._write(blob);
+    return true;
+  }
+
   delete(scope, id, key) {
     const blob = this._read();
     const bucket = blob.scopes[bucketKey(scope, id)];
@@ -77000,7 +77025,7 @@ const SCOPE_PROP = {
   type: "string",
   enum: ["workspace", "global"],
   description:
-    "Which memory scope to use: 'workspace' (default, isolated to this bot's workspace) or 'global' (shared across your bots).",
+    "Which memory scope to use: 'workspace' (default — your team's shared memory, or private to you if you're not on a dashboard's team) or 'global' (shared across all your bots).",
 };
 
 const MEMORY_TOOLS$1 = [
@@ -77070,31 +77095,46 @@ function fail$2(text) {
 /**
  * Execute a memory_* tool call in-process.
  * @param {import("./BotMemory").BotMemory} memory
- * @param {{ workspaceId?: string }} ctx  the calling bot's scope context
+ * @param {{ workspaceId?: string|number, botId?: string }} ctx  the calling bot
  * @param {string} toolName
  * @param {object} args
  * @returns {{ text: string, isError: boolean }}
  */
 function handleMemoryTool$1(memory, ctx, toolName, args = {}) {
-  const scope = args && args.scope === "global" ? "global" : "workspace";
-  const id = ctx && ctx.workspaceId;
+  // "workspace" is the team's shared memory; a bot with no dashboard gets its
+  // own private bucket instead of sharing one with every other such bot.
+  const ws = ctx && ctx.workspaceId;
+  const onTeam = ws !== null && ws !== undefined && ws !== "";
+  let scope;
+  let id;
+  if (args && args.scope === "global") {
+    scope = "global";
+    id = null;
+  } else if (onTeam) {
+    scope = "workspace";
+    id = String(ws);
+  } else {
+    scope = "bot";
+    id = ctx && ctx.botId;
+  }
+  const label = scope === "bot" ? "private" : scope;
   try {
     switch (toolName) {
       case "memory_set": {
         if (!args || !args.key) return fail$2("memory_set requires a 'key'.");
         const entry = memory.set(scope, id, args.key, args.value);
-        return ok$2(`Stored '${args.key}' (${scope}, v${entry.version}).`);
+        return ok$2(`Stored '${args.key}' (${label}, v${entry.version}).`);
       }
       case "memory_get": {
         if (!args || !args.key) return fail$2("memory_get requires a 'key'.");
         const value = memory.get(scope, id, args.key);
         if (value === undefined)
-          return ok$2(`No value stored for '${args.key}' (${scope}).`);
+          return ok$2(`No value stored for '${args.key}' (${label}).`);
         return ok$2(typeof value === "string" ? value : JSON.stringify(value));
       }
       case "memory_list": {
         const entries = memory.list(scope, id, args && args.prefix);
-        if (!entries.length) return ok$2(`No memory keys stored (${scope}).`);
+        if (!entries.length) return ok$2(`No memory keys stored (${label}).`);
         return ok$2(entries.map((e) => `${e.key} (v${e.version})`).join("\n"));
       }
       case "memory_delete": {
@@ -77102,8 +77142,8 @@ function handleMemoryTool$1(memory, ctx, toolName, args = {}) {
         const removed = memory.delete(scope, id, args.key);
         return ok$2(
           removed
-            ? `Deleted '${args.key}' (${scope}).`
-            : `No value to delete for '${args.key}' (${scope}).`,
+            ? `Deleted '${args.key}' (${label}).`
+            : `No value to delete for '${args.key}' (${label}).`,
         );
       }
       default:
@@ -78297,6 +78337,9 @@ const botController$1 = {
     if (isLead(bot) && bot.workspaceId) {
       this._store.setTeamSettings(bot.workspaceId, { leadEnabled: false });
     }
+    // Its private memory (bots with no dashboard) goes with it; team and
+    // global memory are shared and stay.
+    this._memory.forgetBot(botId);
     return this._store.delete(botId);
   },
 
@@ -78755,7 +78798,7 @@ const botController$1 = {
     if (serverName === MEMORY_SERVER) {
       return handleMemoryTool(
         this._memory,
-        { workspaceId: opts.workspaceId },
+        { workspaceId: opts.workspaceId, botId: opts.botId },
         toolName,
         args,
       );