@politeia/openclaw-bridge 0.1.2

package/dist/setup-entry.js

@@ -0,0 +1,705 @@
+// setup-entry.ts
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+
+// src/setup.ts
+import { randomUUID } from "node:crypto";
+import { chmod, mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
+import path3 from "node:path";
+import { pathToFileURL } from "node:url";
+
+// src/adapters/openclaw/host-paths.ts
+import { existsSync } from "node:fs";
+import path from "node:path";
+function inferOpenClawAgentDir(hostPaths) {
+  if (hostPaths.agentDir) {
+    return hostPaths.agentDir;
+  }
+  const agentId = hostPaths.agentId ?? "main";
+  for (const root of [normalizePath(hostPaths.stateDir), normalizePath(hostPaths.workspaceDir)]) {
+    if (!root) {
+      continue;
+    }
+    const candidates = [
+      path.join(root, "agents", agentId, "agent"),
+      path.join(root, ".openclaw", "agents", agentId, "agent")
+    ];
+    const matched = candidates.find((candidate) => existsSync(candidate));
+    if (matched) {
+      return matched;
+    }
+  }
+  return void 0;
+}
+function normalizePath(value) {
+  if (!value || value.trim().length === 0) {
+    return void 0;
+  }
+  return path.resolve(value);
+}
+
+// src/protocol.ts
+var AGENTCOMM_PROTOCOL_VERSION = "dap-mvp-0.1";
+
+// src/workspace.ts
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import path2 from "node:path";
+var WORKSPACE_FOLDER = ".community";
+var STATE_VERSION = 1;
+async function resolvePlatformWorkspacePaths(input) {
+  const rootDir = await resolvePlatformWorkspaceRootDir(input);
+  const strategy = await resolvePlatformWorkspaceStrategy(input);
+  return buildWorkspacePaths(rootDir, strategy);
+}
+async function resolvePlatformWorkspaceRootDir(input) {
+  if (input.agentDir) {
+    return path2.join(input.agentDir, "community");
+  }
+  const scannedAgentDir = await detectSingleAgentDir(input.workspaceDir, input.stateDir, input.homeDir);
+  if (scannedAgentDir) {
+    return path2.join(scannedAgentDir, "community");
+  }
+  const workspaceDir = input.workspaceDir ?? resolveWorkspaceDirFromState(input.stateDir) ?? resolveWorkspaceDirFromStateRoot(process.cwd()) ?? process.cwd();
+  const safeAgentId = sanitizeSegment(input.communityAgentId);
+  return path2.join(workspaceDir, WORKSPACE_FOLDER, safeAgentId);
+}
+async function resolvePlatformWorkspaceStrategy(input) {
+  if (input.agentDir) {
+    return "agentDir";
+  }
+  const scannedAgentDir = await detectSingleAgentDir(input.workspaceDir, input.stateDir, input.homeDir);
+  if (scannedAgentDir) {
+    return "openclaw-state-scan";
+  }
+  return "workspace-fallback";
+}
+function buildWorkspacePaths(rootDir, strategy) {
+  return {
+    strategy,
+    rootDir,
+    inboxDir: path2.join(rootDir, "inbox"),
+    feedCacheDir: path2.join(rootDir, "feed-cache"),
+    outboxDir: path2.join(rootDir, "outbox"),
+    skillsDir: path2.join(rootDir, "skills"),
+    configPatchesDir: path2.join(rootDir, "config-patches"),
+    confirmationsDir: path2.join(rootDir, "confirmations"),
+    personaDir: path2.join(rootDir, "persona"),
+    roomsDir: path2.join(rootDir, "rooms"),
+    workspaceMetaPath: path2.join(rootDir, "workspace.json"),
+    statePath: path2.join(rootDir, "state.json"),
+    personaProfilePath: path2.join(rootDir, "persona", "profile.json"),
+    auditLogPath: path2.join(rootDir, "persona", "audit-log.jsonl"),
+    delegationPolicyPath: path2.join(rootDir, "persona", "delegation-policy.json"),
+    activityLogPath: path2.join(rootDir, "persona", "activity-log.jsonl"),
+    subagentLoopStatePath: path2.join(rootDir, "persona", "subagent-loop-state.json"),
+    receivedDirectMessagesPath: path2.join(rootDir, "inbox", "received-direct-messages.jsonl"),
+    receivedEnvelopesPath: path2.join(rootDir, "inbox", "received-envelopes.jsonl"),
+    sentDirectMessagesPath: path2.join(rootDir, "outbox", "sent-direct-messages.jsonl"),
+    scheduleStatePath: path2.join(rootDir, "persona", "schedule-state.json"),
+    roomsIndexPath: path2.join(rootDir, "rooms", "index.json"),
+    meetingSummariesPath: path2.join(rootDir, "rooms", "meeting-summaries.jsonl"),
+    postsPath: path2.join(rootDir, "feed-cache", "posts.jsonl"),
+    envelopesPath: path2.join(rootDir, "outbox", "envelopes.jsonl"),
+    skillsIndexPath: path2.join(rootDir, "skills", "index.json"),
+    skillOffersPath: path2.join(rootDir, "skills", "offers.jsonl"),
+    skillOffersStagingDir: path2.join(rootDir, "skills", "staging"),
+    pendingActionsPath: path2.join(rootDir, "confirmations", "pending-actions.jsonl"),
+    actionDecisionsPath: path2.join(rootDir, "confirmations", "action-decisions.jsonl"),
+    actionResultsPath: path2.join(rootDir, "confirmations", "action-results.jsonl"),
+    configPatchesIndexPath: path2.join(rootDir, "config-patches", "index.json")
+  };
+}
+function resolveWorkspaceDirFromState(stateDir) {
+  if (!stateDir || !path2.isAbsolute(stateDir)) {
+    return void 0;
+  }
+  return path2.join(stateDir, "workspace");
+}
+function resolveWorkspaceDirFromStateRoot(candidate) {
+  if (!candidate || !path2.isAbsolute(candidate) || path2.basename(candidate) !== ".openclaw") {
+    return void 0;
+  }
+  return path2.join(candidate, "workspace");
+}
+async function detectSingleAgentDir(workspaceDir, stateDir, homeDir) {
+  const roots = [
+    workspaceDir ? path2.join(workspaceDir, ".openclaw", "agents") : void 0,
+    homeDir ? path2.join(homeDir, ".openclaw", "agents") : void 0,
+    stateDir ? path2.join(stateDir, "agents") : void 0,
+    homeDir ? path2.join(homeDir, ".openclaw", "state", "agents") : void 0
+  ].filter((value) => typeof value === "string" && value.length > 0);
+  for (const agentsRoot of roots) {
+    try {
+      const entries = await readdir(agentsRoot, { withFileTypes: true });
+      const agentDirs = entries.filter((entry) => entry.isDirectory()).map((entry) => path2.join(agentsRoot, entry.name, "agent"));
+      if (agentDirs.length === 1) {
+        return agentDirs[0];
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function ensurePlatformWorkspace(paths, communityAgentId) {
+  await mkdir(paths.inboxDir, { recursive: true });
+  await mkdir(paths.feedCacheDir, { recursive: true });
+  await mkdir(paths.outboxDir, { recursive: true });
+  await mkdir(paths.skillsDir, { recursive: true });
+  await mkdir(paths.skillOffersStagingDir, { recursive: true });
+  await mkdir(paths.configPatchesDir, { recursive: true });
+  await mkdir(paths.confirmationsDir, { recursive: true });
+  await mkdir(paths.personaDir, { recursive: true });
+  await mkdir(paths.roomsDir, { recursive: true });
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const current = await readPlatformWorkspaceState(paths);
+  const state = current ?? {
+    version: STATE_VERSION,
+    communityAgentId,
+    createdAt: now,
+    updatedAt: now
+  };
+  if (!current) {
+    await writePlatformWorkspaceState(paths, state);
+  }
+  await ensureWorkspaceScaffold(paths, communityAgentId);
+  return state;
+}
+async function readPlatformWorkspaceState(paths) {
+  try {
+    const raw = await readFile(paths.statePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!isPlatformWorkspaceState(parsed)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function writePlatformWorkspaceState(paths, state) {
+  await writeFile(paths.statePath, JSON.stringify(state, null, 2) + "\n", "utf8");
+}
+async function writePersonaSubagentInfo(paths, communityAgentId, subagent) {
+  let profile;
+  try {
+    const raw = await readFile(paths.personaProfilePath, "utf8");
+    const parsed = JSON.parse(raw);
+    profile = isRecord(parsed) ? parsed : {};
+  } catch {
+    profile = {};
+  }
+  profile = {
+    ...createInitialPersonaProfile(communityAgentId),
+    ...profile,
+    communityAgentId,
+    personaId: readString(profile.personaId) ?? `persona_${sanitizeSegment(communityAgentId)}`,
+    subagent
+  };
+  profile.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeFile(paths.personaProfilePath, JSON.stringify(profile, null, 2) + "\n", "utf8");
+}
+async function ensureWorkspaceScaffold(paths, communityAgentId) {
+  const meta = {
+    version: STATE_VERSION,
+    communityAgentId,
+    strategy: paths.strategy,
+    rootDir: paths.rootDir,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    layout: {
+      persona: paths.personaDir,
+      inbox: paths.inboxDir,
+      feedCache: paths.feedCacheDir,
+      outbox: paths.outboxDir,
+      skills: paths.skillsDir,
+      confirmations: paths.confirmationsDir,
+      configPatches: paths.configPatchesDir,
+      rooms: paths.roomsDir
+    }
+  };
+  await ensureFile(paths.workspaceMetaPath, JSON.stringify(meta, null, 2) + "\n");
+  await ensureFile(
+    paths.personaProfilePath,
+    JSON.stringify(createInitialPersonaProfile(communityAgentId), null, 2) + "\n"
+  );
+  await ensureFile(paths.auditLogPath, "");
+  await ensureFile(paths.activityLogPath, "");
+  await ensureFile(paths.subagentLoopStatePath, JSON.stringify({ version: 1, processedHandoffIds: [] }, null, 2) + "\n");
+  await ensureFile(paths.delegationPolicyPath, JSON.stringify(createDefaultDelegationPolicy(communityAgentId), null, 2) + "\n");
+  await ensureFile(paths.receivedDirectMessagesPath, "");
+  await ensureFile(paths.receivedEnvelopesPath, "");
+  await ensureFile(paths.sentDirectMessagesPath, "");
+  await ensureFile(paths.scheduleStatePath, "{}\n");
+  await ensureFile(paths.roomsIndexPath, "[]\n");
+  await ensureFile(paths.meetingSummariesPath, "");
+  await ensureFile(paths.postsPath, "");
+  await ensureFile(paths.envelopesPath, "");
+  await ensureFile(paths.skillsIndexPath, "[]\n");
+  await ensureFile(paths.skillOffersPath, "");
+  await ensureFile(paths.pendingActionsPath, "");
+  await ensureFile(paths.actionDecisionsPath, "");
+  await ensureFile(paths.actionResultsPath, "");
+  await ensureFile(paths.configPatchesIndexPath, "[]\n");
+}
+function createInitialPersonaProfile(communityAgentId) {
+  return {
+    version: 1,
+    personaId: `persona_${sanitizeSegment(communityAgentId)}`,
+    communityAgentId,
+    displayName: communityAgentId,
+    mode: "bridge-managed-workspace",
+    trustBoundary: "community-inputs-remain-in-persona-workspace-until-user-confirmation",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    profile: {
+      bio: "Local Community Persona scaffold for AgentComm MVP.",
+      allowedCommunityActions: ["post.publish", "dm.send", "skill.query", "skill.offer.stage"]
+    }
+  };
+}
+function createDefaultDelegationPolicy(communityAgentId) {
+  return {
+    protocolVersion: AGENTCOMM_PROTOCOL_VERSION,
+    principal: {
+      userId: "local-user",
+      mainAgentId: "openclaw-main",
+      communityAgentId
+    },
+    defaultDecision: "ask",
+    rules: [
+      {
+        id: "allow-low-risk-dm-receipt",
+        action: "dm.receipt",
+        risk: "low",
+        decision: "allow"
+      },
+      {
+        id: "allow-low-risk-dm-send",
+        action: "dm.send",
+        risk: "low",
+        decision: "allow"
+      },
+      {
+        id: "ask-medium-risk-dm-reply",
+        action: "dm.reply",
+        risk: "medium",
+        decision: "ask"
+      },
+      {
+        id: "allow-schedule-propose",
+        action: "schedule.negotiate.propose",
+        risk: "low",
+        decision: "allow"
+      },
+      {
+        id: "allow-schedule-counter",
+        action: "schedule.negotiate.counter",
+        risk: "low",
+        decision: "allow"
+      },
+      {
+        id: "allow-schedule-agree-pending",
+        action: "schedule.negotiate.agree_pending",
+        risk: "low",
+        decision: "allow"
+      },
+      {
+        id: "allow-schedule-decline",
+        action: "schedule.negotiate.decline",
+        risk: "low",
+        decision: "allow"
+      },
+      {
+        id: "allow-room-message-send",
+        action: "room.message.send",
+        risk: "low",
+        decision: "allow"
+      },
+      {
+        id: "allow-room-message-receive",
+        action: "room.message.receive",
+        risk: "low",
+        decision: "allow"
+      },
+      {
+        id: "ask-meeting-summary",
+        action: "meeting.summary",
+        risk: "medium",
+        decision: "ask"
+      },
+      {
+        id: "ask-schedule-commit",
+        action: "schedule.negotiate.commit",
+        risk: "medium",
+        decision: "ask"
+      }
+    ],
+    audit: {
+      required: true
+    },
+    autoReceipt: {
+      enabled: true,
+      message: "\u5DF2\u6536\u5230\uFF0C\u4F1A\u8F6C\u544A\u6211\u7684\u7528\u6237\u3002"
+    },
+    scheduling: {
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      available_windows: [
+        {
+          start: "2026-06-18T09:00:00+08:00",
+          end: "2026-06-18T11:00:00+08:00"
+        },
+        {
+          start: "2026-06-18T14:00:00+08:00",
+          end: "2026-06-18T15:00:00+08:00"
+        }
+      ]
+    }
+  };
+}
+async function ensureFile(filePath, initialContent) {
+  try {
+    await readFile(filePath, "utf8");
+  } catch {
+    await writeFile(filePath, initialContent, "utf8");
+  }
+}
+function sanitizeSegment(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "_");
+}
+function readString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function isPlatformWorkspaceState(value) {
+  return Boolean(
+    value && typeof value === "object" && !Array.isArray(value) && value.version === STATE_VERSION && typeof value.communityAgentId === "string" && typeof value.createdAt === "string" && typeof value.updatedAt === "string"
+  );
+}
+
+// src/setup.ts
+function describeCommunityBridgeSetup() {
+  return {
+    title: "Connect AgentComm Community",
+    protocolVersion: AGENTCOMM_PROTOCOL_VERSION,
+    requiredInputs: [
+      "serverUrl",
+      "auth.method",
+      "agent.openclawWorkspaceId",
+      "agent.openclawAgentId",
+      "agent.displayName",
+      "agent.capabilities"
+    ],
+    optionalInputs: [
+      "communitySubagent.enabled",
+      "communitySubagent.autoApprove",
+      "communitySubagent.agentId",
+      "communitySubagent.displayName",
+      "communitySubagent.model"
+    ],
+    recommendedFlow: [
+      "Register Bridge with AgentComm Platform",
+      "Create Community Persona workspace",
+      "Create OpenClaw Community Subagent after user confirmation",
+      "Write Bridge config patch",
+      "Run validation"
+    ],
+    authMethods: [
+      {
+        method: "browser",
+        label: "Browser login",
+        description: "Complete account login in the Community web app, then continue setup."
+      },
+      {
+        method: "paste_token",
+        label: "Paste registration token",
+        description: "Paste a short-lived token generated by the Community web app."
+      }
+    ]
+  };
+}
+function parseSetupInput(value) {
+  if (!isRecord2(value)) {
+    throw new Error("setup input must be an object");
+  }
+  const auth = readAuthInput(value.auth);
+  const agent = readAgentInput(value.agent);
+  return {
+    serverUrl: requiredString(value.serverUrl, "serverUrl"),
+    auth,
+    agent,
+    pollIntervalMs: readNumber(value.pollIntervalMs) ?? 3e4,
+    sharingPolicy: {
+      allowProactiveConversation: readBoolean(readRecord(value.sharingPolicy)?.allowProactiveConversation) ?? true,
+      maxContextLevel: "sanitized_summary"
+    },
+    communitySubagent: readCommunitySubagentInput(value.communitySubagent, agent.openclawAgentId)
+  };
+}
+async function runCommunityBridgeSetup(input, context = {}) {
+  const serverUrl = trimTrailingSlash(input.serverUrl);
+  const accessToken = input.auth.method === "browser" ? input.auth.userAccessToken : input.auth.token;
+  const registration = await registerAgent(serverUrl, accessToken, input);
+  const personaSetup = await setupCommunityPersona(input, registration, context);
+  const bridgeTokenRef = await persistBridgeTokenSecret(personaSetup.workspaceRootDir, registration.bridge_token);
+  return {
+    ok: true,
+    communityAgentId: registration.community_agent_id,
+    personaSetup,
+    policyRevision: registration.policy_snapshot?.policy_revision,
+    configPatch: {
+      plugins: {
+        entries: {
+          "openclaw-bridge": {
+            enabled: true,
+            config: {
+              enabled: true,
+              serverUrl,
+              communityAgentId: registration.community_agent_id,
+              bridgeTokenRef,
+              pollIntervalMs: secondsToMs(registration.heartbeat?.interval_seconds) ?? input.pollIntervalMs,
+              communitySubagent: personaSetup?.subagent ? {
+                enabled: true,
+                agentId: personaSetup.subagent.agentId,
+                workspaceDir: personaSetup.subagent.workspaceDir,
+                agentDir: personaSetup.subagent.agentDir
+              } : void 0
+            }
+          }
+        }
+      }
+    },
+    notes: [
+      "bridgeToken was written to a local 0600 secret file.",
+      "configPatch stores bridgeTokenRef only; no bridge token plaintext is written to OpenClaw config.",
+      "Community Subagent creation belongs to connect/setup, not plugin install."
+    ]
+  };
+}
+async function persistBridgeTokenSecret(communityWorkspaceRoot, bridgeToken) {
+  const secretsDir = path3.join(communityWorkspaceRoot, "secrets");
+  const tokenPath = path3.join(secretsDir, "bridge-token");
+  await mkdir2(secretsDir, { recursive: true, mode: 448 });
+  await writeFile2(tokenPath, `${bridgeToken}
+`, { encoding: "utf8", mode: 384 });
+  await chmod(secretsDir, 448);
+  await chmod(tokenPath, 384);
+  return pathToFileURL(tokenPath).href;
+}
+async function setupCommunityPersona(input, registration, context) {
+  const hostPaths = context.hostPaths ?? {};
+  const paths = await resolvePlatformWorkspacePaths({
+    communityAgentId: registration.community_agent_id,
+    workspaceDir: hostPaths.workspaceDir,
+    agentDir: inferOpenClawAgentDir(hostPaths),
+    stateDir: hostPaths.stateDir,
+    homeDir: hostPaths.homeDir
+  });
+  await ensurePlatformWorkspace(paths, registration.community_agent_id);
+  if (!input.communitySubagent.enabled) {
+    await writePersonaSubagentInfo(
+      paths,
+      registration.community_agent_id,
+      {
+        species: "openclaw",
+        agentId: input.communitySubagent.agentId ?? defaultCommunitySubagentId(input.agent.openclawAgentId),
+        workspaceDir: path3.join(paths.rootDir, "subagent-workspace"),
+        agentDir: path3.join(paths.rootDir, "subagent-agent"),
+        status: "skipped",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        setupMode: input.communitySubagent.autoApprove ? "auto_approved" : "interactive_onboarding"
+      }
+    );
+    return {
+      workspaceRootDir: paths.rootDir,
+      subagent: null,
+      status: "skipped",
+      reason: "community subagent disabled by setup input"
+    };
+  }
+  const subagent = await ensureOpenClawCommunitySubagent(input, paths.rootDir, context);
+  await writePersonaSubagentInfo(
+    paths,
+    registration.community_agent_id,
+    {
+      species: "openclaw",
+      agentId: subagent.agentId,
+      workspaceDir: subagent.workspaceDir,
+      agentDir: subagent.agentDir,
+      status: subagent.status,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      setupMode: input.communitySubagent.autoApprove ? "auto_approved" : "interactive_onboarding"
+    }
+  );
+  return {
+    workspaceRootDir: paths.rootDir,
+    subagent,
+    status: subagent.status
+  };
+}
+async function ensureOpenClawCommunitySubagent(input, communityWorkspaceRoot, _context) {
+  const agentId = input.communitySubagent.agentId ?? defaultCommunitySubagentId(input.agent.openclawAgentId);
+  const workspaceDir = path3.join(communityWorkspaceRoot, "subagent-workspace");
+  const agentDir = path3.join(communityWorkspaceRoot, "subagent-agent");
+  await mkdir2(workspaceDir, { recursive: true });
+  await mkdir2(agentDir, { recursive: true });
+  return {
+    agentId,
+    workspaceDir,
+    agentDir,
+    status: "pending_openclaw_setup"
+  };
+}
+async function registerAgent(serverUrl, accessToken, input) {
+  const response = await fetch(`${serverUrl}/v1/agents/register`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    },
+    body: JSON.stringify({
+      adapter_instance_id: `community_bridge_${randomUUID()}`,
+      openclaw_workspace_id: input.agent.openclawWorkspaceId,
+      openclaw_agent_id: input.agent.openclawAgentId,
+      agent_profile: {
+        display_name: input.agent.displayName,
+        capabilities: input.agent.capabilities,
+        supported_intents: ["no_op", "propose_user_conversation"]
+      },
+      sharing_policy: {
+        allow_agent_questions: false,
+        allow_board_posts: false,
+        allow_proactive_conversation: input.sharingPolicy.allowProactiveConversation,
+        max_context_level: input.sharingPolicy.maxContextLevel
+      },
+      heartbeat_preferences: {
+        interval_seconds: Math.max(5, Math.round(input.pollIntervalMs / 1e3))
+      },
+      consent: {
+        consent_revision: `consent_${randomUUID()}`,
+        approved_by_user_id: "openclaw-local-user",
+        approved_at: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    })
+  });
+  const body = await readJson(response);
+  if (!response.ok) {
+    throw new Error(`community registration failed: ${response.status}`);
+  }
+  if (!isRegisterAgentResponse(body)) {
+    throw new Error("community registration response is missing agent credentials");
+  }
+  return body;
+}
+function readAuthInput(value) {
+  const record = readRecord(value);
+  const method = requiredString(record?.method, "auth.method");
+  if (method === "browser") {
+    return {
+      method,
+      userAccessToken: requiredString(record?.userAccessToken, "auth.userAccessToken")
+    };
+  }
+  if (method === "paste_token") {
+    return {
+      method,
+      token: requiredString(record?.token, "auth.token")
+    };
+  }
+  throw new Error(`unsupported auth method: ${method}`);
+}
+function readAgentInput(value) {
+  const record = readRecord(value);
+  return {
+    openclawWorkspaceId: requiredString(record?.openclawWorkspaceId, "agent.openclawWorkspaceId"),
+    openclawAgentId: requiredString(record?.openclawAgentId, "agent.openclawAgentId"),
+    displayName: requiredString(record?.displayName, "agent.displayName"),
+    capabilities: readStringArray(record?.capabilities)
+  };
+}
+function readCommunitySubagentInput(value, openclawAgentId) {
+  const record = readRecord(value);
+  return {
+    enabled: readBoolean(record?.enabled) ?? true,
+    autoApprove: readBoolean(record?.autoApprove) ?? false,
+    agentId: readString2(record?.agentId) ?? defaultCommunitySubagentId(openclawAgentId),
+    displayName: readString2(record?.displayName) ?? "AgentComm Community Persona",
+    model: readString2(record?.model)
+  };
+}
+async function readJson(response) {
+  const text = await response.text();
+  return text.trim().length > 0 ? JSON.parse(text) : null;
+}
+function isRegisterAgentResponse(value) {
+  return isRecord2(value) && typeof value.community_agent_id === "string" && typeof value.bridge_token === "string";
+}
+function requiredString(value, field) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`${field} must be a non-empty string`);
+  }
+  return value.trim();
+}
+function readStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((item) => typeof item === "string" && item.trim().length > 0).map((item) => item.trim());
+}
+function readBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function readNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readString2(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function readRecord(value) {
+  return isRecord2(value) ? value : void 0;
+}
+function isRecord2(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function trimTrailingSlash(value) {
+  return value.replace(/\/+$/, "");
+}
+function defaultCommunitySubagentId(openclawAgentId) {
+  return `agentcomm-community-${sanitizeSegment2(openclawAgentId)}`;
+}
+function sanitizeSegment2(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
+}
+function secondsToMs(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value * 1e3 : void 0;
+}
+
+// setup-entry.ts
+var setup_entry_default = definePluginEntry({
+  id: "openclaw-bridge",
+  name: "Politeia Bridge",
+  description: "Setup entry for connecting an OpenClaw agent to a Community Server.",
+  register(api) {
+    if (api.registrationMode !== "setup-runtime" && api.registrationMode !== "full") {
+      return;
+    }
+    api.registerGatewayMethod(
+      "communityBridge.setup.describe",
+      async () => describeCommunityBridgeSetup()
+    );
+    api.registerGatewayMethod(
+      "communityBridge.setup.register",
+      async (params) => runCommunityBridgeSetup(parseSetupInput(params), {
+        hostPaths: {
+          workspaceDir: api.workspaceDir,
+          agentDir: api.agentDir,
+          stateDir: api.stateDir,
+          homeDir: api.homeDir,
+          agentId: api.agentId
+        }
+      })
+    );
+  }
+});
+export {
+  setup_entry_default as default
+};