@shadowob/openclaw-shadowob 1.1.3-dev.251 → 1.1.3-dev.261

package/dist/{chunk-2R7AKKRH.js → chunk-ATPTVU3K.js}

@@ -656,8 +656,15 @@ function normalizeShadowSlashCommands(input) {
 function toPublicSlashCommands(commands) {
   return commands.map(({ body: _body, ...command }) => command);
 }
-async function loadLocalSlashCommands(runtime) {
-  const indexPath = process.env.SHADOW_SLASH_COMMANDS_PATH;
+async function fileExists(path) {
+  try {
+    await fsPromises2.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadSlashCommandFile(indexPath, runtime) {
   if (!indexPath) return [];
   try {
     const raw = await fsPromises2.readFile(indexPath, "utf-8");
@@ -669,6 +676,47 @@ async function loadLocalSlashCommands(runtime) {
     return [];
   }
 }
+async function runtimeExtensionSlashCommandPaths(runtime) {
+  const candidates = [
+    process.env.SHADOW_RUNTIME_EXTENSIONS_PATH,
+    process.env.OPENCLAW_RUNTIME_EXTENSIONS_PATH,
+    "/etc/openclaw/runtime-extensions.json"
+  ].filter((path) => Boolean(path));
+  const paths = [];
+  for (const manifestPath of [...new Set(candidates)]) {
+    if (!await fileExists(manifestPath)) continue;
+    try {
+      const raw = await fsPromises2.readFile(manifestPath, "utf-8");
+      const manifest = JSON.parse(raw);
+      const artifacts = Array.isArray(manifest.artifacts) ? manifest.artifacts : [];
+      for (const artifact of artifacts) {
+        if (!artifact || typeof artifact !== "object" || Array.isArray(artifact)) continue;
+        const record = artifact;
+        if (record.kind === "shadow.slashCommands" && typeof record.path === "string") {
+          paths.push(record.path);
+        }
+      }
+    } catch (err) {
+      runtime.error?.(`[slash] Failed to read runtime extensions ${manifestPath}: ${String(err)}`);
+    }
+  }
+  return paths;
+}
+async function loadShadowSlashCommands(runtime) {
+  const paths = [
+    process.env.SHADOW_SLASH_COMMANDS_PATH,
+    ...await runtimeExtensionSlashCommandPaths(runtime)
+  ].filter((path) => Boolean(path));
+  const seenPaths = [...new Set(paths)];
+  const loaded = await Promise.all(seenPaths.map((path) => loadSlashCommandFile(path, runtime)));
+  const merged = normalizeShadowSlashCommands(loaded.flat());
+  if (seenPaths.length > 1) {
+    runtime.log?.(
+      `[slash] Merged ${merged.length} slash command(s) from ${seenPaths.length} source(s)`
+    );
+  }
+  return merged;
+}
 async function registerAgentSlashCommands(params) {
   const baseUrl = params.account.serverUrl.replace(/\/api\/?$/, "").replace(/\/$/, "");
   const response = await fetch(`${baseUrl}/api/agents/${params.agentId}/slash-commands`, {
@@ -1369,6 +1417,34 @@ ${baseBodyForAgent}` : baseBodyForAgent;
   }
 }
 
+// src/monitor/message-queue.ts
+function queueKeyForMessage(message) {
+  return `${message.channelId}:${message.threadId ?? ""}`;
+}
+function createShadowMessageProcessingQueue(options) {
+  const queues = /* @__PURE__ */ new Map();
+  return {
+    enqueue(message, source) {
+      const key = queueKeyForMessage(message);
+      const previous = queues.get(key) ?? Promise.resolve();
+      const task = previous.catch(() => void 0).then(() => {
+        if (options.isStopped?.()) {
+          options.onSkipped?.(message, source);
+          return;
+        }
+        return options.process(message, source);
+      }).finally(() => {
+        if (queues.get(key) === task) queues.delete(key);
+      });
+      queues.set(key, task);
+      return task;
+    },
+    pendingKeys() {
+      return [...queues.keys()];
+    }
+  };
+}
+
 // src/runtime.ts
 import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
 var store = createPluginRuntimeStore(
@@ -1475,7 +1551,7 @@ async function monitorShadowProvider(options) {
   } else {
     runtime.log?.(`[config] Resolved agentId: ${agentId}`);
   }
-  const slashCommands = await loadLocalSlashCommands(runtime);
+  const slashCommands = await loadShadowSlashCommands(runtime);
   if (agentId) {
     try {
       await runShadowApiOperation(
@@ -1495,6 +1571,23 @@ async function monitorShadowProvider(options) {
   const messageWatermarks = await loadMessageWatermarks(accountId);
   const processedMessageIds = /* @__PURE__ */ new Set();
   const catchupInFlight = /* @__PURE__ */ new Map();
+  const buildAccessPolicyConfig = (config2) => {
+    const activeTenantIds = config2?.activeTenantIds ?? [];
+    const allowedTriggerUserIds = config2?.allowedTriggerUserIds ?? [config2?.ownerId, ...activeTenantIds].filter((id) => Boolean(id));
+    return {
+      allowedTriggerUserIds,
+      triggerUserIds: allowedTriggerUserIds,
+      ownerId: config2?.ownerId,
+      activeTenantIds,
+      replyRequiresMention: false
+    };
+  };
+  const buildDefaultAccessPolicy = (config2) => ({
+    listen: true,
+    reply: true,
+    mentionOnly: false,
+    config: buildAccessPolicyConfig(config2)
+  });
   const rememberProcessedMessage = (messageId) => {
     processedMessageIds.add(messageId);
     if (processedMessageIds.size > MAX_TRACKED_MESSAGE_IDS) {
@@ -1610,12 +1703,7 @@ async function monitorShadowProvider(options) {
     for (const ch of directChannels) {
       if (!allChannelIds.includes(ch.id)) allChannelIds.push(ch.id);
       if (!channelPolicies.has(ch.id)) {
-        channelPolicies.set(ch.id, {
-          listen: true,
-          reply: true,
-          mentionOnly: false,
-          config: {}
-        });
+        channelPolicies.set(ch.id, buildDefaultAccessPolicy(remoteConfig));
       }
     }
     runtime.log?.(`[config] Monitoring ${directChannels.length} direct channel(s)`);
@@ -1676,6 +1764,13 @@ async function monitorShadowProvider(options) {
       );
     }
   };
+  const messageQueue = createShadowMessageProcessingQueue({
+    process: processChannelMessageWithRetry,
+    isStopped: () => stopped,
+    onSkipped: (message, source) => {
+      runtime.log?.(`[${source}] Monitor stopped, skipping queued message ${message.id}`);
+    }
+  });
   const catchUpChannel = async (channelId, reason) => {
     try {
       const result = await client.getMessages(channelId, 50);
@@ -1700,7 +1795,7 @@ async function monitorShadowProvider(options) {
       }
       for (const message of candidates) {
         rememberProcessedMessage(message.id);
-        await processChannelMessageWithRetry(message, "catchup");
+        await messageQueue.enqueue(message, "catchup");
       }
     } catch (err) {
       runtime.error?.(`[catchup] Failed for channel ${channelId}: ${String(err)}`);
@@ -1806,8 +1901,65 @@ async function monitorShadowProvider(options) {
     "agent:policy-changed",
     (data) => {
       if (data.agentId !== agentId) return;
-      if (!data.channelId) return;
-      const mentionOnly = data.mentionOnly ?? false;
+      if (!data.channelId) {
+        void (async () => {
+          try {
+            const updatedConfig = await runShadowApiOperation(
+              "refresh remote config after access policy change",
+              () => client.getAgentConfig(agentId),
+              { runtime, abortSignal }
+            );
+            remoteConfig = updatedConfig;
+            const remoteChannelIds = /* @__PURE__ */ new Set();
+            const accessConfig2 = buildAccessPolicyConfig(updatedConfig);
+            for (const server of updatedConfig.servers) {
+              for (const ch of server.channels) {
+                remoteChannelIds.add(ch.id);
+                channelServerMap.set(ch.id, {
+                  serverId: server.id,
+                  serverSlug: server.slug ?? server.id,
+                  serverName: server.name,
+                  channelName: ch.name
+                });
+                channelPolicies.set(ch.id, {
+                  listen: true,
+                  reply: true,
+                  mentionOnly: false,
+                  config: { ...ch.policy.config, ...accessConfig2 }
+                });
+                if (!allChannelIds.includes(ch.id)) {
+                  allChannelIds.push(ch.id);
+                  void socket.joinChannel(ch.id);
+                }
+              }
+            }
+            for (const [channelId] of channelServerMap) {
+              if (remoteChannelIds.has(channelId)) continue;
+              channelServerMap.delete(channelId);
+              channelPolicies.delete(channelId);
+              const idx = allChannelIds.indexOf(channelId);
+              if (idx !== -1) allChannelIds.splice(idx, 1);
+              socket.leaveChannel(channelId);
+            }
+            for (const [channelId, existing2] of channelPolicies) {
+              if (channelServerMap.has(channelId)) continue;
+              channelPolicies.set(channelId, {
+                ...existing2,
+                listen: true,
+                reply: true,
+                mentionOnly: false,
+                config: { ...existing2.config, ...accessConfig2 }
+              });
+            }
+            runtime.log?.("[config] Refreshed Buddy owner/tenant access policy");
+          } catch (err) {
+            runtime.error?.(`[config] Failed to refresh access policy: ${String(err)}`);
+          }
+        })();
+        return;
+      }
+      const mentionOnly = false;
+      const accessConfig = buildAccessPolicyConfig(remoteConfig);
       runtime.log?.(
         `[ws] Received agent:policy-changed for channel ${data.channelId}: mentionOnly=${mentionOnly}, reply=${data.reply}, config=${JSON.stringify(data.config ?? {})}`
       );
@@ -1816,15 +1968,15 @@ async function monitorShadowProvider(options) {
         channelPolicies.set(data.channelId, {
           ...existing,
           mentionOnly,
-          reply: data.reply ?? existing.reply,
-          config: data.config ?? existing.config
+          reply: true,
+          config: { ...existing.config, ...accessConfig, ...data.config ?? {} }
         });
       } else {
         channelPolicies.set(data.channelId, {
           listen: true,
-          reply: data.reply ?? true,
+          reply: true,
           mentionOnly,
-          config: data.config ?? {}
+          config: { ...accessConfig, ...data.config ?? {} }
         });
       }
     }
@@ -1875,12 +2027,12 @@ async function monitorShadowProvider(options) {
       if (!refreshed) {
         await resolveChannelContext(data.channelId, "member-added");
       }
-      if (!refreshed && !channelPolicies.has(data.channelId)) {
+      if (!channelPolicies.has(data.channelId)) {
         const defaultPolicy = {
           listen: true,
           reply: true,
           mentionOnly: false,
-          config: {}
+          config: buildAccessPolicyConfig(remoteConfig)
         };
         channelPolicies.set(data.channelId, defaultPolicy);
       }
@@ -1924,7 +2076,7 @@ async function monitorShadowProvider(options) {
       runtime.log?.(`[ws] Message from unmonitored channel ${message.channelId}, ignoring`);
       return;
     }
-    void processChannelMessageWithRetry(message, "ws");
+    void messageQueue.enqueue(message, "ws");
   });
   socket.connect();
   const stop = () => {

package/dist/index.js

@@ -15,7 +15,7 @@ import {
   resolveOutboundMentions,
   setShadowRuntime,
   tryGetShadowRuntime
-} from "./chunk-2R7AKKRH.js";
+} from "./chunk-ATPTVU3K.js";
 
 // index.ts
 import { defineChannelPluginEntry } from "openclaw/plugin-sdk/core";
@@ -959,7 +959,7 @@ shadowPlugin.gateway = {
       lastError: null
     });
     ctx.log?.info(`Starting Shadow connection for account ${accountId}`);
-    const { monitorShadowProvider: monitorShadowProvider2 } = await import("./monitor-ZZHGWMZF.js");
+    const { monitorShadowProvider: monitorShadowProvider2 } = await import("./monitor-PUXW5FI2.js");
     await monitorShadowProvider2({
       account,
       accountId,

package/dist/{monitor-ZZHGWMZF.js → monitor-PUXW5FI2.js}

@@ -5,7 +5,7 @@ import {
   normalizeShadowSlashCommands,
   resolveShadowAgentIdFromConfig,
   shouldCatchUpShadowMessage
-} from "./chunk-2R7AKKRH.js";
+} from "./chunk-ATPTVU3K.js";
 export {
   formatSlashCommandPrompt,
   matchShadowSlashCommand,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shadowob/openclaw-shadowob",
-  "version": "1.1.3-dev.251",
+  "version": "1.1.3-dev.261",
   "description": "OpenClaw Shadow channel plugin — enables AI agents to interact in Shadow server channels",
   "type": "module",
   "main": "./dist/index.js",
@@ -58,7 +58,7 @@
   "dependencies": {
     "zod": "^3.25.67",
     "openclaw": "^2026.5.7",
-    "@shadowob/sdk": "1.1.3-dev.251"
+    "@shadowob/sdk": "1.1.3-dev.261"
   },
   "devDependencies": {
     "@types/node": "^22.15.21",