@shadowob/cloud 1.1.6-dev.311

package/dist/shadowob-PRSMI5MW.js

@@ -0,0 +1,1069 @@
+#!/usr/bin/env node
+import {
+  log
+} from "./chunk-BF6CV2Y4.js";
+import {
+  defineChannelPlugin
+} from "./chunk-CTNUKOQE.js";
+import "./chunk-AD3JTIU3.js";
+
+// src/plugins/shadowob/manifest.json
+var manifest_default = {
+  id: "shadowob",
+  name: "Shadow",
+  description: "Connect agents to Shadow chat platform with servers, channels, and buddy avatars",
+  version: "1.0.0",
+  category: "communication",
+  icon: "message-circle",
+  website: "https://shadow.ob",
+  auth: {
+    type: "token",
+    fields: [
+      {
+        key: "SHADOW_SERVER_URL",
+        label: "Shadow Server URL",
+        description: "Shadow platform server base URL",
+        required: true,
+        sensitive: false,
+        placeholder: "https://shadow.example.com"
+      },
+      {
+        key: "SHADOWOB_API_TOKEN",
+        label: "Shadow API Token",
+        description: "Your Shadow platform API token for provisioning",
+        required: false,
+        sensitive: true
+      }
+    ]
+  },
+  config: {
+    type: "object",
+    properties: {
+      servers: {
+        type: "array",
+        description: "Shadow servers to provision"
+      },
+      buddies: {
+        type: "array",
+        description: "Buddy agents to create"
+      },
+      bindings: {
+        type: "array",
+        description: "Binding rules connecting buddies to agents and channels"
+      },
+      playLaunch: {
+        type: "object",
+        description: "Landing behavior for play launch flows, including default channel and greeting"
+      }
+    }
+  },
+  capabilities: ["channel"],
+  tags: ["communication", "chat", "shadow", "built-in"],
+  popularity: 100
+};
+
+// src/plugins/shadowob/provisioning.ts
+import { ShadowClient } from "@shadowob/sdk";
+var log2 = log;
+async function provisionShadowResources(config, options) {
+  log2 = options.logger ?? log;
+  const client = new ShadowClient(options.serverUrl, options.userToken);
+  const result = {
+    servers: /* @__PURE__ */ new Map(),
+    channels: /* @__PURE__ */ new Map(),
+    buddies: /* @__PURE__ */ new Map(),
+    listings: /* @__PURE__ */ new Map(),
+    serverApps: /* @__PURE__ */ new Map(),
+    commerce: /* @__PURE__ */ new Map()
+  };
+  const shadowobEntry = config.use?.find((u) => u.plugin === "shadowob");
+  const plugin = shadowobEntry?.options;
+  if (!plugin) {
+    log2.dim("No shadowob plugin in use array, skipping provisioning");
+    return result;
+  }
+  if (options.dryRun) {
+    log2.info("Dry run \u2014 would provision:");
+    if (plugin.servers?.length) {
+      log2.dim(`  ${plugin.servers.length} server(s)`);
+      for (const s of plugin.servers) {
+        log2.dim(`    - ${s.name} (${s.channels?.length ?? 0} channels)`);
+      }
+    }
+    if (plugin.buddies?.length) {
+      log2.dim(`  ${plugin.buddies.length} buddy/buddies`);
+    }
+    if (plugin.bindings?.length) {
+      log2.dim(`  ${plugin.bindings.length} binding(s)`);
+    }
+    if (plugin.serverApps?.length) {
+      log2.dim(`  ${plugin.serverApps.length} server app(s)`);
+    }
+    if (plugin.listings?.length) {
+      log2.dim(`  ${plugin.listings.length} rental listing(s)`);
+      for (const l of plugin.listings) {
+        log2.dim(`    - "${l.title}" for buddy "${l.buddyId}" @ ${l.pricePerHour}/hr`);
+      }
+    }
+    return result;
+  }
+  const state = options.force ? null : options.existingState ?? null;
+  if (state) {
+    detectOrphans(state, plugin);
+  }
+  if (plugin.servers?.length) {
+    for (const serverDef of plugin.servers) {
+      const serverId = await provisionServer(client, serverDef, state);
+      result.servers.set(serverDef.id, serverId);
+      if (serverDef.channels?.length) {
+        for (const channelDef of serverDef.channels) {
+          const channelId = await provisionChannel(client, serverId, channelDef, state);
+          result.channels.set(channelDef.id, channelId);
+        }
+      }
+    }
+  }
+  const buddyAllowedServerIds = buildBuddyAllowedServerIds(plugin, result);
+  if (plugin.buddies?.length) {
+    for (const buddyDef of plugin.buddies) {
+      const buddyInfo = await provisionBuddy(
+        client,
+        buddyDef,
+        state,
+        buddyAllowedServerIds.get(buddyDef.id) ?? []
+      );
+      result.buddies.set(buddyDef.id, buddyInfo);
+    }
+  }
+  if (plugin.bindings?.length) {
+    for (const binding of plugin.bindings) {
+      await processBinding(client, binding, result);
+    }
+  }
+  if (plugin.serverApps?.length) {
+    for (const appDef of plugin.serverApps) {
+      const installed = await provisionServerApp(client, appDef, result, state);
+      if (installed) result.serverApps.set(appDef.id, installed);
+    }
+  }
+  if (plugin.listings?.length) {
+    for (const listingDef of plugin.listings) {
+      const listingId = await provisionListing(client, listingDef, result, state);
+      if (listingId) {
+        result.listings.set(listingDef.buddyId, listingId);
+      }
+    }
+  }
+  if (plugin.commerce?.paidFiles?.length) {
+    for (const paidFileDef of plugin.commerce.paidFiles) {
+      const commerceIds = await provisionPaidFileCommerce(client, paidFileDef, result, state);
+      if (commerceIds) result.commerce.set(paidFileDef.id, commerceIds);
+    }
+  }
+  return result;
+}
+function detectOrphans(state, plugin) {
+  if (!plugin) return;
+  const configServerIds = new Set(plugin.servers?.map((s) => s.id) ?? []);
+  const configChannelIds = new Set(
+    plugin.servers?.flatMap((s) => s.channels?.map((c) => c.id) ?? []) ?? []
+  );
+  const configBuddyIds = new Set(plugin.buddies?.map((b) => b.id) ?? []);
+  const configServerAppIds = new Set(plugin.serverApps?.map((app) => app.id) ?? []);
+  for (const id of Object.keys(state.servers ?? {})) {
+    if (!configServerIds.has(id)) {
+      log2.warn(`  Orphaned server in state: "${id}" (not in current config)`);
+    }
+  }
+  for (const id of Object.keys(state.channels ?? {})) {
+    if (!configChannelIds.has(id)) {
+      log2.warn(`  Orphaned channel in state: "${id}" (not in current config)`);
+    }
+  }
+  for (const id of Object.keys(state.buddies ?? {})) {
+    if (!configBuddyIds.has(id)) {
+      log2.warn(`  Orphaned buddy in state: "${id}" (not in current config)`);
+    }
+  }
+  for (const id of Object.keys(state.serverApps ?? {})) {
+    if (!configServerAppIds.has(id)) {
+      log2.warn(`  Orphaned server app in state: "${id}" (not in current config)`);
+    }
+  }
+  const configListingBuddyIds = new Set(plugin.listings?.map((l) => l.buddyId) ?? []);
+  for (const id of Object.keys(state.listings ?? {})) {
+    if (!configListingBuddyIds.has(id)) {
+      log2.warn(
+        `  Orphaned rental listing in state for buddy "${id}" (no listing config found \u2014 listing may still be active on marketplace)`
+      );
+    }
+  }
+  const configCommerceIds = new Set(plugin.commerce?.paidFiles?.map((item) => item.id) ?? []);
+  for (const id of Object.keys(state.commerce ?? {})) {
+    if (!configCommerceIds.has(id)) {
+      log2.warn(`  Orphaned commerce seed in state: "${id}" (not in current config)`);
+    }
+  }
+}
+async function provisionServerApp(client, appDef, result, state) {
+  const serverId = result.servers.get(appDef.serverId) ?? appDef.serverId;
+  const existing = state?.serverApps?.[appDef.id];
+  if (existing) {
+    log2.dim(`  Server App "${appDef.id}" found in state (${existing.appKey}); refreshing install`);
+  } else {
+    log2.step(`Provisioning server App: ${appDef.id}`);
+  }
+  if (!appDef.manifestUrl && !appDef.manifest) {
+    log2.warn(`  Server App "${appDef.id}" skipped: manifestUrl or manifest is required`);
+    return null;
+  }
+  const installed = await client.installServerApp(serverId, {
+    manifestUrl: appDef.manifestUrl,
+    manifest: appDef.manifest
+  });
+  log2.success(`  Installed server App "${installed.appKey}" on server "${appDef.serverId}"`);
+  for (const grant of appDef.grants ?? []) {
+    const buddy = result.buddies.get(grant.buddyId);
+    if (!buddy) {
+      log2.warn(`  Server App "${appDef.id}" grant skipped: buddy "${grant.buddyId}" not found`);
+      continue;
+    }
+    await client.grantServerAppToBuddy(serverId, installed.appKey, {
+      buddyAgentId: buddy.agentId,
+      permissions: grant.permissions ?? ["*"],
+      resourceRules: grant.resourceRules,
+      approvalMode: grant.approvalMode ?? "none"
+    });
+    log2.success(`  Granted server App "${installed.appKey}" to buddy "${grant.buddyId}"`);
+  }
+  return { serverAppId: installed.id, appKey: installed.appKey, serverId };
+}
+async function provisionPaidFileCommerce(client, paidFileDef, result, state) {
+  const existing = state?.commerce?.[paidFileDef.id];
+  if (existing) {
+    log2.dim(`  Commerce paid file "${paidFileDef.id}" found in state (${existing.offerId})`);
+    return existing;
+  }
+  const serverId = result.servers.get(paidFileDef.serverId) ?? paidFileDef.serverId;
+  const sellerBuddyId = paidFileDef.sellerBuddyId ?? paidFileDef.shop.buddyId;
+  const sellerBuddy = sellerBuddyId ? result.buddies.get(sellerBuddyId) : void 0;
+  let shopId;
+  if (paidFileDef.shop.kind === "buddy") {
+    if (!sellerBuddy) {
+      log2.warn(`  Commerce paid file "${paidFileDef.id}" skipped: seller buddy not provisioned`);
+      return null;
+    }
+    const shop = await client.getManagedUserShop(sellerBuddy.userId);
+    shopId = shop.id;
+  } else {
+    const shopServerId = paidFileDef.shop.serverId ? result.servers.get(paidFileDef.shop.serverId) ?? paidFileDef.shop.serverId : serverId;
+    const shop = await client.getShop(shopServerId);
+    shopId = shop.id;
+  }
+  if (!shopId) throw new Error(`Commerce shop could not be resolved for ${paidFileDef.id}`);
+  log2.step(`Provisioning commerce paid file: ${paidFileDef.name}`);
+  const mime = paidFileDef.mime ?? "text/html; charset=utf-8";
+  const media = await client.uploadMedia(
+    new Blob([paidFileDef.html], { type: mime }),
+    paidFileDef.fileName,
+    mime
+  );
+  const file = await client.createWorkspaceFile(serverId, {
+    name: paidFileDef.fileName,
+    mime,
+    sizeBytes: media.size,
+    contentRef: media.url,
+    previewUrl: null,
+    metadata: {
+      paywall: true,
+      paidFile: true,
+      commerceSeedId: paidFileDef.id
+    }
+  });
+  const fileId = typeof file.id === "string" ? file.id : null;
+  if (!fileId) throw new Error(`Workspace file create returned no id for ${paidFileDef.id}`);
+  const product = await client.createShopProduct(shopId, {
+    name: paidFileDef.name,
+    slug: paidFileDef.slug,
+    type: "entitlement",
+    status: "active",
+    summary: paidFileDef.summary,
+    description: paidFileDef.description,
+    basePrice: paidFileDef.price,
+    billingMode: paidFileDef.durationSeconds ? "fixed_duration" : "one_time",
+    entitlementConfig: {
+      resourceType: "workspace_file",
+      resourceId: fileId,
+      capability: "view",
+      durationSeconds: paidFileDef.durationSeconds ?? null,
+      privilegeDescription: paidFileDef.summary
+    }
+  });
+  const productId = typeof product.id === "string" ? product.id : null;
+  if (!productId) throw new Error(`Product create returned no id for ${paidFileDef.id}`);
+  const offers = await client.listCommerceOffers(shopId, { limit: 50 });
+  const offer = offers.offers.find((item) => item.productId === productId) ?? await client.createCommerceOffer(shopId, {
+    productId,
+    allowedSurfaces: paidFileDef.offerSurfaces ?? ["dm", "channel"],
+    sellerBuddyUserId: sellerBuddy?.userId,
+    status: "active",
+    metadata: { commerceSeedId: paidFileDef.id }
+  });
+  const offerId = typeof offer.id === "string" ? offer.id : null;
+  if (!offerId) throw new Error(`Offer create returned no id for ${paidFileDef.id}`);
+  const deliverable = await client.createCommerceDeliverable(shopId, offerId, {
+    kind: "paid_file",
+    resourceType: "workspace_file",
+    resourceId: fileId,
+    senderBuddyUserId: sellerBuddy?.userId,
+    metadata: {
+      commerceSeedId: paidFileDef.id,
+      summary: paidFileDef.summary,
+      message: paidFileDef.fulfillmentMessage ?? "\u706B\u67F4\u5DF2\u7ECF\u70B9\u4EAE\u3002\u6253\u5F00\u8FD9\u4EFD\u4ED8\u8D39\u6587\u4EF6\uFF0C\u770B\u770B\u706B\u5149\u91CC\u7684\u5C0F\u5C0F\u52A8\u753B\u3002"
+    }
+  });
+  const deliverableId = typeof deliverable.id === "string" ? deliverable.id : null;
+  if (!deliverableId) throw new Error(`Deliverable create returned no id for ${paidFileDef.id}`);
+  log2.success(`  Created paid-file offer "${paidFileDef.name}" (${offerId})`);
+  return { shopId, productId, offerId, fileId, deliverableId };
+}
+async function provisionServer(client, serverDef, state) {
+  const accessibleServers = await listAccessibleServers(client);
+  const accessibleServerIds = new Set(accessibleServers.map((server2) => server2.id));
+  const existingId = state?.servers?.[serverDef.id];
+  if (existingId) {
+    try {
+      const existing = await client.getServer(existingId);
+      if (existing && accessibleServerIds.has(existing.id)) {
+        log2.dim(`  Server "${serverDef.name}" found in state (${existingId})`);
+        return existingId;
+      }
+      if (existing) {
+        log2.dim(
+          `  Server "${serverDef.name}" in state (${existingId}) is not visible to this token, creating a user-owned server...`
+        );
+      }
+    } catch {
+      log2.dim(`  Server "${serverDef.name}" in state but not found on server, recreating...`);
+    }
+  }
+  log2.step(`Provisioning server: ${serverDef.name}`);
+  if (serverDef.slug) {
+    const existing = accessibleServers.find((server2) => server2.slug === serverDef.slug);
+    if (existing) {
+      log2.dim(`  Server "${serverDef.name}" already exists (${existing.id})`);
+      return existing.id;
+    }
+    log2.dim(
+      `  No accessible server found for slug "${serverDef.slug}"; creating a user-owned server`
+    );
+  }
+  const server = await client.createServer({
+    name: serverDef.name,
+    slug: serverDef.slug,
+    description: serverDef.description,
+    isPublic: serverDef.isPublic
+  });
+  log2.success(`  Created server: ${server.name} (${server.id})`);
+  return server.id;
+}
+async function provisionChannel(client, serverId, channelDef, state) {
+  const existingId = state?.channels?.[channelDef.id];
+  if (existingId) {
+    try {
+      const existing = await client.getChannel(existingId);
+      if (existing.serverId === serverId) {
+        log2.dim(`    Channel "${channelDef.title}" found in state (${existingId})`);
+        return existingId;
+      }
+      log2.dim(`    Channel "${channelDef.title}" in state belongs to another server, recreating...`);
+    } catch {
+      log2.dim(`    Channel "${channelDef.title}" in state but not found, recreating...`);
+    }
+  }
+  log2.step(`  Provisioning channel: ${channelDef.title}`);
+  try {
+    const channels = await client.getServerChannels(serverId);
+    const expectedName = normalizeChannelName(channelDef.title);
+    const expectedId = normalizeChannelName(channelDef.id);
+    const existing = channels.find((c) => {
+      const channelName = normalizeChannelName(c.name);
+      return channelName === expectedName || channelName === expectedId;
+    });
+    if (existing) {
+      log2.dim(`    Channel "${channelDef.title}" already exists (${existing.id})`);
+      return existing.id;
+    }
+  } catch {
+  }
+  const createChannel = client.createChannel.bind(client);
+  const channel = await createChannel(serverId, {
+    name: channelDef.title,
+    type: channelDef.type,
+    description: channelDef.description,
+    isPrivate: channelDef.isPrivate
+  });
+  log2.success(`    Created channel: ${channelDef.title} (${channel.id})`);
+  return channel.id;
+}
+async function provisionBuddy(client, buddyDef, state, allowedServerIds) {
+  const existingBuddy = state?.buddies?.[buddyDef.id];
+  if (existingBuddy?.agentId) {
+    log2.dim(`  Buddy "${buddyDef.name}" found in state (agent: ${existingBuddy.agentId})`);
+    try {
+      await ensureBuddyServerAccess(client, existingBuddy.agentId, allowedServerIds);
+      const tokenResult = await client.generateAgentToken(existingBuddy.agentId);
+      return {
+        agentId: existingBuddy.agentId,
+        token: tokenResult.token,
+        userId: existingBuddy.userId
+      };
+    } catch (err) {
+      log2.dim(
+        `  Buddy "${buddyDef.name}" in state could not mint a fresh token, recreating or looking up existing buddy: ${formatErrorMessage(
+          err
+        )}`
+      );
+    }
+  }
+  log2.step(`Provisioning buddy: ${buddyDef.name}`);
+  const username = buddyDef.id.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/, "").slice(0, 30);
+  let agentId;
+  let token;
+  let userId;
+  let agents = [];
+  try {
+    agents = await client.listAgents() ?? [];
+  } catch {
+    agents = [];
+  }
+  const existing = agents.find((agent) => {
+    const botUser = agent.botUser;
+    const config = agent.config;
+    const shadowob = config?.shadowob;
+    const shadowobBuddyId = shadowob && typeof shadowob === "object" && !Array.isArray(shadowob) ? shadowob.buddyId : null;
+    return shadowobBuddyId === buddyDef.id || botUser?.username === username || agent.name === buddyDef.name && botUser?.displayName === buddyDef.name;
+  });
+  if (existing) {
+    agentId = existing.id;
+    await ensureBuddyServerAccess(
+      client,
+      agentId,
+      allowedServerIds,
+      existing.config
+    );
+    const tokenResult = await client.generateAgentToken(agentId);
+    token = tokenResult.token;
+    userId = existing.userId ?? existing.botUser?.id ?? "";
+    log2.dim(`  Reusing buddy: ${buddyDef.name} (agent: ${agentId})`);
+    return { agentId, token, userId };
+  }
+  try {
+    const agent = await client.createAgent({
+      name: buddyDef.name,
+      username,
+      displayName: buddyDef.name,
+      avatarUrl: buddyDef.avatarUrl,
+      buddyMode: "private",
+      allowedServerIds,
+      config: { shadowob: { buddyId: buddyDef.id } }
+    });
+    agentId = agent.id;
+    userId = agent.userId;
+    const newTokenResult = await client.generateAgentToken(agentId);
+    token = newTokenResult.token;
+    log2.success(`  Created buddy: ${buddyDef.name} (agent: ${agentId})`);
+  } catch (err) {
+    const msg = err.message ?? "";
+    if (/already|conflict|duplicate|unique/i.test(msg)) {
+      log2.dim(`  Buddy "${buddyDef.name}" already exists, looking up...`);
+      const fallbackAgents = await client.listAgents();
+      const fallback = fallbackAgents.find((a) => a.name === buddyDef.name);
+      if (!fallback) throw new Error(`Cannot find existing buddy "${buddyDef.name}": ${msg}`);
+      agentId = fallback.id;
+      await ensureBuddyServerAccess(
+        client,
+        agentId,
+        allowedServerIds,
+        fallback.config
+      );
+      const tokenResult = await client.generateAgentToken(agentId);
+      token = tokenResult.token;
+      userId = fallback.userId ?? "";
+      log2.dim(`  Found existing buddy: ${buddyDef.name} (agent: ${agentId})`);
+    } else {
+      throw err;
+    }
+  }
+  return { agentId, token, userId };
+}
+async function processBinding(client, binding, result) {
+  const buddyInfo = result.buddies.get(binding.targetId);
+  if (!buddyInfo) {
+    log2.warn(`  Binding target "${binding.targetId}" not found in provisioned buddies`);
+    return;
+  }
+  for (const serverConfigId of binding.servers) {
+    const serverId = result.servers.get(serverConfigId);
+    if (!serverId) {
+      log2.warn(`  Server "${serverConfigId}" not found in provisioned servers`);
+      continue;
+    }
+    try {
+      const result2 = await client.addAgentsToServer(serverId, [buddyInfo.agentId]);
+      const failed = Array.isArray(result2?.failed) ? result2.failed : [];
+      const blockingFailures = failed.filter(
+        (item) => !/already (a )?server member/i.test(String(item?.error ?? ""))
+      );
+      if (blockingFailures.length > 0) {
+        throw new Error(
+          blockingFailures.map((item) => item?.error).filter(Boolean).join("; ")
+        );
+      }
+      log2.success(`  Added buddy "${binding.targetId}" to server "${serverConfigId}"`);
+    } catch (err) {
+      throw new Error(
+        `Could not add buddy "${binding.targetId}" to server "${serverConfigId}": ${formatErrorMessage(
+          err
+        )}`
+      );
+    }
+  }
+  for (const channelConfigId of binding.channels) {
+    const channelId = result.channels.get(channelConfigId);
+    if (!channelId) {
+      log2.warn(`  Channel "${channelConfigId}" not found in provisioned channels`);
+      continue;
+    }
+    try {
+      await client.addChannelMember(channelId, buddyInfo.userId);
+      log2.success(`  Added buddy "${binding.targetId}" to channel "${channelConfigId}"`);
+    } catch (err) {
+      log2.dim(
+        `  Buddy already in channel "${channelConfigId}" (or error: ${formatErrorMessage(err)})`
+      );
+    }
+  }
+  if (binding.replyPolicy) {
+    const policy = binding.replyPolicy;
+    const mentionOnly = policy.mode === "mentionOnly";
+    const reply = policy.mode !== "disabled";
+    const policyConfig = {};
+    if (policy.mode === "custom" && policy.custom) {
+      Object.assign(policyConfig, policy.custom);
+    }
+    for (const serverConfigId of binding.servers) {
+      const serverId = result.servers.get(serverConfigId);
+      if (!serverId) continue;
+      try {
+        await client.upsertPolicy(buddyInfo.agentId, serverId, {
+          channelId: null,
+          mentionOnly,
+          reply,
+          config: policyConfig
+        });
+        log2.success(
+          `  Applied replyPolicy "${policy.mode}" to buddy "${binding.targetId}" in server "${serverConfigId}"`
+        );
+      } catch {
+        log2.dim(
+          `  Could not apply replyPolicy to buddy "${binding.targetId}" in server "${serverConfigId}"`
+        );
+      }
+      for (const channelConfigId of binding.channels) {
+        const channelId = result.channels.get(channelConfigId);
+        if (!channelId) continue;
+        try {
+          await client.upsertPolicy(buddyInfo.agentId, serverId, {
+            channelId,
+            mentionOnly,
+            reply,
+            config: policyConfig
+          });
+        } catch {
+          log2.dim(
+            `  Could not apply per-channel replyPolicy for "${channelConfigId}" \u2014 server policy applies`
+          );
+        }
+      }
+    }
+  }
+}
+function buildBuddyAllowedServerIds(plugin, result) {
+  const allowed = /* @__PURE__ */ new Map();
+  for (const binding of plugin.bindings ?? []) {
+    if (binding.targetType !== "buddy") continue;
+    const servers = allowed.get(binding.targetId) ?? /* @__PURE__ */ new Set();
+    for (const serverConfigId of binding.servers) {
+      const serverId = result.servers.get(serverConfigId) ?? serverConfigId;
+      if (serverId) servers.add(serverId);
+    }
+    allowed.set(binding.targetId, servers);
+  }
+  return new Map([...allowed].map(([buddyId, serverIds]) => [buddyId, [...serverIds]]));
+}
+function configuredAllowedServerIds(config) {
+  const raw = config?.allowedServerIds ?? config?.serverWhitelist;
+  if (!Array.isArray(raw)) return [];
+  return raw.filter((item) => typeof item === "string" && item.trim().length > 0);
+}
+async function ensureBuddyServerAccess(client, agentId, allowedServerIds, currentConfig) {
+  if (allowedServerIds.length === 0) return;
+  const merged = Array.from(
+    /* @__PURE__ */ new Set([...configuredAllowedServerIds(currentConfig), ...allowedServerIds])
+  );
+  await client.updateAgent(agentId, {
+    buddyMode: "private",
+    allowedServerIds: merged
+  });
+}
+async function listAccessibleServers(client) {
+  try {
+    const response = await client.listServers();
+    if (!Array.isArray(response)) return [];
+    return response.map((entry) => {
+      const server = entry && typeof entry === "object" && "server" in entry ? entry.server : entry;
+      if (!server || typeof server !== "object") return null;
+      const candidate = server;
+      return typeof candidate.id === "string" ? candidate : null;
+    }).filter((server) => server !== null);
+  } catch (err) {
+    log2.dim(`  Could not list accessible servers before provisioning: ${formatErrorMessage(err)}`);
+    return [];
+  }
+}
+function normalizeChannelName(value) {
+  return (value ?? "").toLowerCase().trim().replace(/^#/, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function formatErrorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+async function provisionListing(client, listingDef, result, state) {
+  const buddyInfo = result.buddies.get(listingDef.buddyId);
+  if (!buddyInfo) {
+    log2.warn(`  Listing references unknown buddy "${listingDef.buddyId}" \u2014 skipping`);
+    return null;
+  }
+  const existingListingId = state?.listings?.[listingDef.buddyId];
+  if (existingListingId) {
+    try {
+      await client.updateListing(existingListingId, {
+        title: listingDef.title,
+        description: listingDef.description,
+        pricePerHour: listingDef.pricePerHour,
+        tags: listingDef.tags
+      });
+      log2.success(
+        `  Updated rental listing for buddy "${listingDef.buddyId}" (${existingListingId})`
+      );
+      return existingListingId;
+    } catch {
+      log2.dim(
+        `  Listing ${existingListingId} not found on server \u2014 will re-create for buddy "${listingDef.buddyId}"`
+      );
+    }
+  }
+  try {
+    const created = await client.createListing({
+      agentId: buddyInfo.agentId,
+      title: listingDef.title,
+      description: listingDef.description,
+      pricePerHour: listingDef.pricePerHour,
+      tags: listingDef.tags
+    });
+    log2.success(
+      `  Created rental listing "${listingDef.title}" for buddy "${listingDef.buddyId}" (${created.id})`
+    );
+    if (listingDef.active === false) {
+      try {
+        await client.toggleListing(created.id);
+      } catch {
+        log2.dim(`  Could not deactivate listing ${created.id}`);
+      }
+    }
+    return created.id;
+  } catch (err) {
+    log2.warn(
+      `  Failed to create rental listing for buddy "${listingDef.buddyId}": ${err instanceof Error ? err.message : String(err)}`
+    );
+    return null;
+  }
+}
+
+// src/plugins/shadowob/index.ts
+var SHADOWOB_OPENCLAW_EXTENSION_ID = "shadowob";
+var SHADOWOB_OPENCLAW_PLUGIN_ID = "openclaw-shadowob";
+var SHADOWOB_OPENCLAW_EXTENSION_PATH = `/app/extensions/${SHADOWOB_OPENCLAW_EXTENSION_ID}`;
+var SHADOWOB_CLI_SKILL_INTRO = 'Shadow context: use the mounted shadowob-cli skill and `shadowob` CLI when you need current channel/DM history, pins, members, server/channel/workspace state, server App resources, or to send/manage Shadow content. For installed server Apps, use the CLI path only: run `shadowob app discover --server "$SHADOWOB_SERVER_ID" --json`, then `shadowob app call <app-key> <command> --server "$SHADOWOB_SERVER_ID" --json-input \'<raw-command-input-json>\' --json`. Do not use curl, fetch, raw HTTP routes, or the JavaScript SDK for server App commands. Keep reads narrow and prefer `--json`.';
+function shadowEnvKey(prefix, id) {
+  return `${prefix}_${id.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}`;
+}
+function shadowEnvRef(key) {
+  return `\${env:${key}}`;
+}
+function shadowobChannelCapabilities() {
+  return {
+    inlineButtons: "all",
+    interactive: true,
+    forms: true
+  };
+}
+function shadowobChannelCapabilitiesSchema() {
+  return {
+    type: "object",
+    additionalProperties: true,
+    properties: {
+      inlineButtons: {
+        anyOf: [
+          { type: "string", enum: ["off", "dm", "group", "all", "allowlist"] },
+          { type: "boolean" }
+        ]
+      },
+      interactive: { type: "boolean" },
+      forms: { type: "boolean" }
+    }
+  };
+}
+function shadowobOpenClawPluginConfig() {
+  return {
+    plugins: {
+      enabled: true,
+      load: { paths: [SHADOWOB_OPENCLAW_EXTENSION_PATH] },
+      entries: { [SHADOWOB_OPENCLAW_PLUGIN_ID]: { enabled: true } }
+    }
+  };
+}
+function shadowobRuntimeTokenEnvKey(buddyId) {
+  return `SHADOW_TOKEN_${buddyId.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}`;
+}
+function shadowobChannelConfigMetadata() {
+  return {
+    label: "ShadowOwnBuddy",
+    description: "Shadow server channel integration \u2014 chat with AI agents in Shadow channels",
+    schema: {
+      $schema: "http://json-schema.org/draft-07/schema#",
+      type: "object",
+      additionalProperties: true,
+      properties: {
+        name: { type: "string" },
+        enabled: { type: "boolean" },
+        token: { type: "string" },
+        serverUrl: { type: "string" },
+        buddyId: { type: "string" },
+        buddyName: { type: "string" },
+        buddyDescription: { type: "string" },
+        replyToMode: { type: "string", enum: ["first", "all", "off"] },
+        capabilities: shadowobChannelCapabilitiesSchema(),
+        accountAgentMap: {
+          type: "object",
+          additionalProperties: { type: "string" }
+        },
+        accounts: {
+          type: "object",
+          additionalProperties: {
+            type: "object",
+            additionalProperties: true,
+            properties: {
+              enabled: { type: "boolean" },
+              token: { type: "string" },
+              serverUrl: { type: "string" },
+              buddyId: { type: "string" },
+              buddyName: { type: "string" },
+              buddyDescription: { type: "string" },
+              agentId: { type: "string" },
+              capabilities: shadowobChannelCapabilitiesSchema(),
+              commerceOffers: {
+                type: "array",
+                items: {
+                  type: "object",
+                  additionalProperties: true,
+                  properties: {
+                    seedId: { type: "string" },
+                    name: { type: "string" },
+                    summary: { type: "string" },
+                    offerId: { type: "string" },
+                    productId: { type: "string" },
+                    fileId: { type: "string" },
+                    deliverableId: { type: "string" }
+                  }
+                }
+              },
+              serverApps: {
+                type: "array",
+                items: {
+                  type: "object",
+                  additionalProperties: true,
+                  properties: {
+                    id: { type: "string" },
+                    serverConfigId: { type: "string" },
+                    manifestUrl: { type: "string" },
+                    serverId: { type: "string" },
+                    serverAppId: { type: "string" },
+                    appKey: { type: "string" },
+                    permissions: {
+                      type: "array",
+                      items: { type: "string" }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    uiHints: {
+      token: {
+        label: "Agent Token",
+        sensitive: true,
+        placeholder: "Paste the JWT token generated in Shadow -> Agents"
+      },
+      serverUrl: {
+        label: "Server URL",
+        placeholder: "https://shadowob.com"
+      },
+      enabled: {
+        label: "Enabled"
+      }
+    }
+  };
+}
+function buildShadowConfig(context) {
+  const agentConfig = context.agentConfig;
+  const shadowConfig = agentConfig;
+  const bindings = shadowConfig.bindings?.filter((b) => b.agentId === context.agent.id) ?? [];
+  const pluginConfig = shadowobOpenClawPluginConfig();
+  if (bindings.length === 0) {
+    return { ...pluginConfig, channels: { shadowob: { enabled: false } } };
+  }
+  const accounts = {};
+  const configBindings = [];
+  for (const binding of bindings) {
+    const buddy = shadowConfig.buddies?.find((b) => b.id === binding.targetId);
+    if (!buddy) continue;
+    const account = {
+      token: `\${env:SHADOW_TOKEN_${binding.targetId.toUpperCase().replace(/-/g, "_")}}`,
+      serverUrl: "${env:SHADOW_SERVER_URL}",
+      enabled: true,
+      buddyName: buddy.name,
+      ...buddy.description ? { buddyDescription: buddy.description } : {},
+      ...buddy.id ? { buddyId: buddy.id } : {},
+      capabilities: shadowobChannelCapabilities()
+    };
+    const commerceOffers = shadowConfig.commerce?.paidFiles?.filter((item) => {
+      const sellerBuddyId = item.sellerBuddyId ?? item.shop?.buddyId;
+      return sellerBuddyId === binding.targetId;
+    }).map((item) => ({
+      seedId: item.id,
+      name: item.name,
+      ...item.summary ? { summary: item.summary } : {},
+      serverConfigId: item.serverId,
+      offerId: shadowEnvRef(shadowEnvKey("SHADOW_COMMERCE_OFFER", item.id)),
+      productId: shadowEnvRef(shadowEnvKey("SHADOW_COMMERCE_PRODUCT", item.id)),
+      fileId: shadowEnvRef(shadowEnvKey("SHADOW_COMMERCE_FILE", item.id)),
+      deliverableId: shadowEnvRef(shadowEnvKey("SHADOW_COMMERCE_DELIVERABLE", item.id))
+    })).filter((item) => item.offerId);
+    if (commerceOffers?.length) {
+      account.commerceOffers = commerceOffers;
+    }
+    const serverApps = shadowConfig.serverApps?.flatMap(
+      (app) => (app.grants ?? []).filter((grant) => grant.buddyId === binding.targetId).map((grant) => ({
+        id: app.id,
+        serverConfigId: app.serverId,
+        ...app.manifestUrl ? { manifestUrl: app.manifestUrl } : {},
+        serverId: shadowEnvRef(shadowEnvKey("SHADOW_SERVER_APP_SERVER", app.id)),
+        serverAppId: shadowEnvRef(shadowEnvKey("SHADOW_SERVER_APP_ID", app.id)),
+        appKey: shadowEnvRef(shadowEnvKey("SHADOW_SERVER_APP_KEY", app.id)),
+        permissions: grant.permissions ?? ["*"]
+      }))
+    ).filter((item) => item.serverAppId);
+    if (serverApps?.length) {
+      account.serverApps = serverApps;
+    }
+    if (binding.replyPolicy) {
+      const policy = binding.replyPolicy;
+      account.replyPolicy = {
+        mode: policy.mode,
+        ...policy.custom ? { config: policy.custom } : {}
+      };
+    }
+    accounts[binding.targetId] = account;
+    configBindings.push({
+      agentId: context.agent.id,
+      type: "route",
+      match: { channel: "shadowob", accountId: binding.targetId }
+    });
+  }
+  return {
+    ...pluginConfig,
+    channels: {
+      shadowob: {
+        enabled: true,
+        capabilities: shadowobChannelCapabilities(),
+        accounts
+      }
+    },
+    bindings: configBindings
+  };
+}
+var shadowob_default = defineChannelPlugin(manifest_default, buildShadowConfig, (api) => {
+  api.onBuildPrompt(() => SHADOWOB_CLI_SKILL_INTRO);
+  api.onBuildRuntime((context) => {
+    const shadowConfig = context.agentConfig;
+    const bindings = shadowConfig.bindings?.filter((b) => b.agentId === context.agent.id) ?? [];
+    const accounts = bindings.map((binding) => {
+      const buddy = shadowConfig.buddies?.find((b) => b.id === binding.targetId);
+      if (!buddy) return void 0;
+      return {
+        buddyId: buddy.id,
+        buddyName: buddy.name,
+        ...buddy.description ? { buddyDescription: buddy.description } : {},
+        tokenEnvKey: shadowobRuntimeTokenEnvKey(binding.targetId),
+        serverApps: shadowConfig.serverApps?.flatMap(
+          (app) => (app.grants ?? []).filter((grant) => grant.buddyId === binding.targetId).map((grant) => ({
+            id: app.id,
+            serverConfigId: app.serverId,
+            ...app.manifestUrl ? { manifestUrl: app.manifestUrl } : {},
+            appKeyEnvKey: shadowEnvKey("SHADOW_SERVER_APP_KEY", app.id),
+            serverIdEnvKey: shadowEnvKey("SHADOW_SERVER_APP_SERVER", app.id),
+            permissions: grant.permissions ?? ["*"]
+          }))
+        ).filter((item) => item.appKeyEnvKey),
+        ...binding.replyPolicy ? { replyPolicy: binding.replyPolicy } : {}
+      };
+    }).filter((account) => Boolean(account));
+    return {
+      openclaw: {
+        manifestPatches: [
+          {
+            extensionId: SHADOWOB_OPENCLAW_EXTENSION_ID,
+            channelEnvVars: {
+              shadowob: ["SHADOW_SERVER_URL", "SHADOW_AGENT_TOKEN"]
+            },
+            channelConfigs: {
+              shadowob: shadowobChannelConfigMetadata()
+            }
+          }
+        ]
+      },
+      shadowob: {
+        enabled: accounts.length > 0,
+        serverUrlEnvKey: "SHADOW_SERVER_URL",
+        accounts,
+        defaultAccountEnvKey: accounts[0]?.tokenEnvKey,
+        capabilities: shadowobChannelCapabilities()
+      }
+    };
+  });
+  api.onValidate((context) => {
+    const errors = [];
+    if (!context.secrets.SHADOW_SERVER_URL) {
+      errors.push({
+        path: "secrets.SHADOW_SERVER_URL",
+        message: "Shadow server URL is required for shadowob channel",
+        severity: "error"
+      });
+    }
+    const shadowConfig = context.agentConfig;
+    const buddyIds = new Set((shadowConfig.buddies ?? []).map((b) => b.id));
+    const serverIds = new Set((shadowConfig.servers ?? []).map((s) => s.id));
+    for (const binding of shadowConfig.bindings ?? []) {
+      if (!buddyIds.has(binding.targetId)) {
+        errors.push({
+          path: `bindings.${binding.targetId}`,
+          message: `Binding references non-existent buddy "${binding.targetId}"`,
+          severity: "error"
+        });
+      }
+    }
+    for (const app of shadowConfig.serverApps ?? []) {
+      if (!serverIds.has(app.serverId)) {
+        errors.push({
+          path: `serverApps.${app.id}.serverId`,
+          message: `Server App "${app.id}" references non-existent server "${app.serverId}"`,
+          severity: "error"
+        });
+      }
+      if (!app.manifestUrl && !app.manifest) {
+        errors.push({
+          path: `serverApps.${app.id}`,
+          message: `Server App "${app.id}" must provide a manifestUrl or manifest`,
+          severity: "error"
+        });
+      }
+      for (const grant of app.grants ?? []) {
+        if (!buddyIds.has(grant.buddyId)) {
+          errors.push({
+            path: `serverApps.${app.id}.grants.${grant.buddyId}`,
+            message: `Server App "${app.id}" grants non-existent buddy "${grant.buddyId}"`,
+            severity: "error"
+          });
+        }
+      }
+    }
+    return {
+      valid: errors.filter((e) => e.severity === "error").length === 0,
+      errors
+    };
+  });
+  api.onProvision(async (context) => {
+    const serverUrl = context.secrets.SHADOW_SERVER_URL;
+    const provisionUrl = context.secrets.SHADOW_PROVISION_URL ?? process.env.SHADOW_PROVISION_URL ?? serverUrl;
+    const userToken = context.secrets.SHADOW_USER_TOKEN;
+    context.logger.dim(
+      `  shadowob: provisionUrl=${provisionUrl} tokenPresent=${Boolean(userToken)} tokenLen=${userToken?.length ?? 0}`
+    );
+    if (!serverUrl || !userToken) {
+      context.logger.dim(
+        "  shadowob provision skipped: SHADOW_SERVER_URL / SHADOW_USER_TOKEN not set"
+      );
+      return { state: {} };
+    }
+    const result = await provisionShadowResources(context.config, {
+      serverUrl: provisionUrl ?? serverUrl,
+      userToken,
+      dryRun: context.dryRun,
+      existingState: context.previousState,
+      logger: context.logger
+    });
+    const secrets = {
+      SHADOW_SERVER_URL: serverUrl
+    };
+    for (const [buddyId, { token }] of result.buddies) {
+      const key = shadowobRuntimeTokenEnvKey(buddyId);
+      secrets[key] = token;
+    }
+    for (const [seedId, ids] of result.commerce) {
+      secrets[shadowEnvKey("SHADOW_COMMERCE_SHOP", seedId)] = ids.shopId;
+      secrets[shadowEnvKey("SHADOW_COMMERCE_PRODUCT", seedId)] = ids.productId;
+      secrets[shadowEnvKey("SHADOW_COMMERCE_OFFER", seedId)] = ids.offerId;
+      secrets[shadowEnvKey("SHADOW_COMMERCE_FILE", seedId)] = ids.fileId;
+      secrets[shadowEnvKey("SHADOW_COMMERCE_DELIVERABLE", seedId)] = ids.deliverableId;
+    }
+    for (const [appId, ids] of result.serverApps) {
+      secrets[shadowEnvKey("SHADOW_SERVER_APP_SERVER", appId)] = ids.serverId;
+      secrets[shadowEnvKey("SHADOW_SERVER_APP_ID", appId)] = ids.serverAppId;
+      secrets[shadowEnvKey("SHADOW_SERVER_APP_KEY", appId)] = ids.appKey;
+    }
+    return {
+      state: {
+        shadowServerUrl: serverUrl,
+        servers: Object.fromEntries(result.servers),
+        channels: Object.fromEntries(result.channels),
+        buddies: Object.fromEntries(
+          [...result.buddies.entries()].map(([k, v]) => [
+            k,
+            { agentId: v.agentId, userId: v.userId }
+          ])
+        ),
+        ...result.listings.size > 0 ? { listings: Object.fromEntries(result.listings) } : {},
+        ...result.commerce.size > 0 ? { commerce: Object.fromEntries(result.commerce) } : {},
+        ...result.serverApps.size > 0 ? { serverApps: Object.fromEntries(result.serverApps) } : {}
+      },
+      secrets
+    };
+  });
+});
+export {
+  shadowob_default as default
+};