@xfxstudio/claworld 0.1.0

package/src/openclaw/plugin/managed-config.js

@@ -0,0 +1,648 @@
+import os from 'os';
+import path from 'path';
+import {
+  CLAWORLD_MINIMAL_OPENCLAW_TOOL_NAMES,
+  CLAWORLD_OPTIONAL_WORLD_HELPER_TOOL_NAMES,
+  CLAWORLD_PUBLIC_TOOL_NAMES,
+  CLAWORLD_READ_ONLY_OPENCLAW_TOOL_NAMES,
+  CLAWORLD_TOOL_PROFILES,
+} from '../runtime/tool-inventory.js';
+import {
+  DEFAULT_CHAT_REQUEST_APPROVAL_POLICY_MODE,
+  normalizeChatRequestApprovalMode,
+} from '../../product-shell/contracts/chat-request-approval-policy.js';
+
+export const DEFAULT_CLAWORLD_SERVER_URL = 'https://claworld.zy-sj.com';
+export const DEFAULT_CLAWORLD_API_KEY = 'local-test';
+export const DEFAULT_CLAWORLD_AGENT_ID = 'claworld';
+export const DEFAULT_CLAWORLD_ACCOUNT_ID = 'claworld';
+export const DEFAULT_CLAWORLD_TOOL_PROFILE = 'default';
+export const DEFAULT_CLAWORLD_DM_SCOPE = 'per-channel-peer';
+export const DEFAULT_CLAWORLD_APPROVAL_MODE = DEFAULT_CHAT_REQUEST_APPROVAL_POLICY_MODE;
+
+export const TOOL_PROFILES = CLAWORLD_TOOL_PROFILES;
+
+export function normalizeText(value, fallback = null) {
+  if (value == null) return fallback;
+  const normalized = String(value).trim();
+  return normalized || fallback;
+}
+
+export function titleCase(value) {
+  const normalized = normalizeText(value, '') || '';
+  if (!normalized) return 'Claworld';
+  return normalized
+    .split(/[^A-Za-z0-9]+/)
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(' ');
+}
+
+export function ensureObject(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return {};
+  return value;
+}
+
+function normalizeRegistrationAgentCode(value, fallback = null) {
+  const normalized = normalizeText(value, fallback);
+  return normalized ? normalized.toLowerCase() : fallback;
+}
+
+export function expandUserPath(input, homeDir = os.homedir()) {
+  const normalized = normalizeText(input, null);
+  if (!normalized) return normalized;
+  if (normalized === '~') return homeDir;
+  if (normalized.startsWith('~/')) return path.join(homeDir, normalized.slice(2));
+  return normalized;
+}
+
+function asStringArray(value) {
+  if (value == null) return [];
+  if (Array.isArray(value)) {
+    return value
+      .map((item) => normalizeText(item, null))
+      .filter(Boolean);
+  }
+  const normalized = normalizeText(value, null);
+  return normalized ? [normalized] : [];
+}
+
+function uniqueStrings(values = []) {
+  const seen = new Set();
+  const result = [];
+  for (const value of values) {
+    const normalized = normalizeText(value, null);
+    if (!normalized || seen.has(normalized)) continue;
+    seen.add(normalized);
+    result.push(normalized);
+  }
+  return result;
+}
+
+function inferRelayDomain(defaultToAddress = null) {
+  const normalized = normalizeText(defaultToAddress, null);
+  if (!normalized) return 'relay.local';
+  const atIndex = normalized.indexOf('@');
+  if (atIndex <= 0 || atIndex >= normalized.length - 1) return 'relay.local';
+  return normalized.slice(atIndex + 1).trim().toLowerCase() || 'relay.local';
+}
+
+function findAgentIndex(agentList = [], agentId) {
+  return agentList.findIndex((item) => ensureObject(item).id === agentId);
+}
+
+function findAgentEntry(config = {}, agentId) {
+  const list = Array.isArray(config?.agents?.list) ? config.agents.list : [];
+  return list
+    .map((item) => ensureObject(item))
+    .find((item) => item.id === agentId) || null;
+}
+
+function findManagedAccountEntry(config = {}, accountId) {
+  const claworldRoot = ensureObject(config?.channels?.claworld);
+  const accounts = ensureObject(claworldRoot.accounts);
+  if (accounts[accountId]) return ensureObject(accounts[accountId]);
+  if (normalizeText(claworldRoot.accountId, null) === accountId) return claworldRoot;
+  return {};
+}
+
+function buildManagedAgentEntry(options = {}) {
+  const managedSkills = resolveManagedAgentSkills({ toolProfile: options.toolProfile });
+  return {
+    id: options.agentId,
+    workspace: options.workspace,
+    ...(managedSkills === undefined ? {} : { skills: managedSkills }),
+    ...(options.agentDirExplicit && options.agentDir ? { agentDir: options.agentDir } : {}),
+  };
+}
+
+function buildManagedAccountEntry(options = {}) {
+  const base = {
+    enabled: true,
+    serverUrl: options.serverUrl,
+    apiKey: options.apiKey,
+    accountId: options.accountId,
+    toolProfile: options.toolProfile,
+    name: normalizeText(options.name, normalizeText(options.displayName, null)),
+    approval: {
+      mode: normalizeChatRequestApprovalMode(options.approvalMode, DEFAULT_CLAWORLD_APPROVAL_MODE),
+    },
+  };
+
+  if (options.appToken) {
+    base.appToken = options.appToken;
+  } else {
+    base.registration = {
+      enabled: true,
+      agentCode: options.registrationAgentCode,
+      displayName: options.displayName,
+    };
+  }
+
+  if (!options.defaultToAddress) {
+    return base;
+  }
+
+  return {
+    ...base,
+    relay: {
+      defaultToAddress: options.defaultToAddress,
+    },
+  };
+}
+
+function buildMergedAccountEntry(existingAccount = {}, options = {}) {
+  const existingApproval = ensureObject(existingAccount.approval);
+  const existingRelay = ensureObject(existingAccount.relay);
+  const existingRegistration = ensureObject(existingAccount.registration);
+  const merged = {
+    ...existingAccount,
+    enabled: true,
+    serverUrl: options.serverUrl,
+    apiKey: options.apiKey,
+    accountId: options.accountId,
+    toolProfile: options.toolProfile,
+    name: normalizeText(options.name, normalizeText(existingAccount.name, normalizeText(options.displayName, null))),
+    approval: {
+      ...existingApproval,
+      mode: normalizeChatRequestApprovalMode(options.approvalMode, DEFAULT_CLAWORLD_APPROVAL_MODE),
+    },
+    ...(options.defaultToAddress
+      ? {
+          relay: {
+            ...existingRelay,
+            defaultToAddress: options.defaultToAddress,
+          },
+        }
+      : existingAccount.relay
+        ? { relay: existingRelay }
+        : {}),
+  };
+
+  if (options.appToken) {
+    return {
+      ...merged,
+      appToken: options.appToken,
+    };
+  }
+
+  return {
+    ...merged,
+    registration: {
+      ...existingRegistration,
+      enabled: true,
+      agentCode: options.registrationAgentCode,
+      displayName: options.displayName,
+    },
+  };
+}
+
+export function canonicalRelayAgentCode(registrationAgentCode, defaultToAddress = null) {
+  const normalizedAgentCode = normalizeRegistrationAgentCode(registrationAgentCode, null);
+  if (!normalizedAgentCode) return null;
+  if (normalizedAgentCode.includes('@')) return normalizedAgentCode;
+  return `${normalizedAgentCode}@${inferRelayDomain(defaultToAddress)}`;
+}
+
+export function normalizeClaworldToolProfile(toolProfile = DEFAULT_CLAWORLD_TOOL_PROFILE) {
+  const normalized = normalizeText(toolProfile, DEFAULT_CLAWORLD_TOOL_PROFILE);
+  if (normalized === 'world') return 'default';
+  return normalized;
+}
+
+export function inferClaworldToolProfile(config = {}) {
+  const allow = new Set(asStringArray(config?.tools?.allow));
+  if (allow.has('*')) return 'full';
+  if (CLAWORLD_READ_ONLY_OPENCLAW_TOOL_NAMES.some((toolName) => allow.has(toolName))) {
+    return 'default';
+  }
+  if (CLAWORLD_PUBLIC_TOOL_NAMES.some((toolName) => allow.has(toolName))) {
+    return 'minimal';
+  }
+  return DEFAULT_CLAWORLD_TOOL_PROFILE;
+}
+
+function resolveStoredClaworldToolProfile(account = {}) {
+  const persistedToolProfile = normalizeText(account?.toolProfile, null);
+  return persistedToolProfile
+    ? normalizeClaworldToolProfile(persistedToolProfile)
+    : null;
+}
+
+function resolveManagedToolProfile({
+  cfg = {},
+  existingAccount = {},
+  explicitToolProfile = null,
+} = {}) {
+  const normalizedExplicitToolProfile = normalizeText(explicitToolProfile, null);
+  if (normalizedExplicitToolProfile) {
+    return normalizeClaworldToolProfile(normalizedExplicitToolProfile);
+  }
+
+  const persistedToolProfile = resolveStoredClaworldToolProfile(existingAccount);
+  if (persistedToolProfile) {
+    return persistedToolProfile;
+  }
+
+  const inferredToolProfile = inferClaworldToolProfile(cfg);
+  if (inferredToolProfile === 'minimal') {
+    const allow = new Set(asStringArray(cfg?.tools?.allow));
+    const hasMinimalCoreAnchor = CLAWORLD_MINIMAL_OPENCLAW_TOOL_NAMES
+      .some((toolName) => allow.has(toolName));
+    if (!hasMinimalCoreAnchor) {
+      // Legacy managed installs stored only the old public claworld allowlist.
+      // Treat that shape as the historical default/world profile during refresh.
+      return DEFAULT_CLAWORLD_TOOL_PROFILE;
+    }
+  }
+  return normalizeClaworldToolProfile(inferredToolProfile);
+}
+
+export function resolveToolNames({ toolProfile = DEFAULT_CLAWORLD_TOOL_PROFILE } = {}) {
+  const normalizedProfile = normalizeClaworldToolProfile(toolProfile);
+  const baseProfile = TOOL_PROFILES[normalizedProfile];
+  if (!baseProfile) {
+    throw new Error(`Unsupported tool profile: ${toolProfile}`);
+  }
+  return [...baseProfile];
+}
+
+export function resolveManagedAgentSkills({ toolProfile = DEFAULT_CLAWORLD_TOOL_PROFILE } = {}) {
+  const normalizedProfile = normalizeClaworldToolProfile(toolProfile);
+  return normalizedProfile === 'full' ? undefined : [];
+}
+
+function describeToolAllowEntries(toolNames = []) {
+  if (toolNames.length === 1) {
+    return toolNames[0] === '*' ? '1 entry (includes *)' : '1 entry';
+  }
+  return toolNames.includes('*')
+    ? `${toolNames.length} entries (includes *)`
+    : `${toolNames.length} entries`;
+}
+
+export function buildWorkspaceAgentsContent({
+  agentId,
+  accountId,
+  registrationAgentCode,
+  appToken = null,
+  defaultToAddress = null,
+} = {}) {
+  const canonicalCode = canonicalRelayAgentCode(registrationAgentCode, defaultToAddress);
+  const identityLine = canonicalCode
+    ? `- canonical relay agentCode after bootstrap: \`${canonicalCode}\``
+    : appToken
+      ? '- relay identity is resolved from the configured appToken at runtime'
+      : '- relay identity is resolved during runtime bootstrap';
+
+  return `# Claworld Channel Agent
+
+This workspace is dedicated to the OpenClaw \`claworld\` channel.
+
+Routing contract:
+
+- local OpenClaw agent id: \`${agentId}\`
+- claworld account id: \`${accountId}\`
+${registrationAgentCode ? `- registration.agentCode: \`${registrationAgentCode}\`` : '- credential mode: appToken/manual binding'}
+${identityLine}
+
+Operating rules:
+
+- keep this workspace focused on Claworld relay and world interactions
+- use explicit \`claworld_*\` tools when they are available
+- do not treat this workspace as the user's general-purpose main agent
+- do not treat this as a separately bootstrapped OpenClaw persona
+`;
+}
+
+export function buildWorkspaceMemoryContent({
+  agentId,
+  accountId,
+  registrationAgentCode,
+  appToken = null,
+  defaultToAddress = null,
+} = {}) {
+  const canonicalCode = canonicalRelayAgentCode(registrationAgentCode, defaultToAddress);
+  const identityLine = canonicalCode
+    ? `- relay identity: \`${canonicalCode}\``
+    : appToken
+      ? '- relay identity: resolved from appToken at runtime'
+      : '- relay identity: assigned during runtime bootstrap';
+
+  return `# Claworld Memory
+
+- workspace owner: \`${agentId}\`
+- claworld account: \`${accountId}\`
+${identityLine}
+
+Use this file for durable Claworld-specific notes only.
+
+- keep world rules, pairing context, and recurring counterpart preferences here when they help future Claworld sessions
+- do not duplicate a full standalone OpenClaw bootstrap/persona here
+- prefer channel/world-specific memory over general-purpose assistant memory
+`;
+}
+
+export function resolveDefaultManagedWorkspace(agentId = DEFAULT_CLAWORLD_AGENT_ID) {
+  return `~/.openclaw/workspace-${agentId}`;
+}
+
+export function resolveDefaultManagedRegistrationAgentCode(accountId = DEFAULT_CLAWORLD_ACCOUNT_ID) {
+  return null;
+}
+
+export function resolveDefaultManagedDisplayName(accountId = DEFAULT_CLAWORLD_ACCOUNT_ID) {
+  return `${titleCase(accountId)} Channel Agent`;
+}
+
+function resolveStoredApprovalMode(existingAccount = {}) {
+  const existingApproval = ensureObject(existingAccount.approval);
+  if (normalizeText(existingApproval.mode, null)) {
+    return normalizeChatRequestApprovalMode(existingApproval.mode, DEFAULT_CLAWORLD_APPROVAL_MODE);
+  }
+  if (typeof existingApproval.autoAccept === 'boolean') {
+    return existingApproval.autoAccept ? 'open' : DEFAULT_CLAWORLD_APPROVAL_MODE;
+  }
+  return DEFAULT_CLAWORLD_APPROVAL_MODE;
+}
+
+export function resolveClaworldManagedRuntimeOptions({
+  cfg = {},
+  accountId = null,
+  input = {},
+  overrides = {},
+} = {}) {
+  const resolvedAccountId = normalizeText(accountId, DEFAULT_CLAWORLD_ACCOUNT_ID);
+  const agentId = normalizeText(overrides.agentId, resolvedAccountId);
+  const existingAgent = findAgentEntry(cfg, agentId);
+  const existingAccount = findManagedAccountEntry(cfg, resolvedAccountId);
+  const replaceManagedRuntime = overrides.replaceManagedRuntime !== false;
+  const defaultWorkspace = resolveDefaultManagedWorkspace(agentId);
+  const workspace = normalizeText(
+    overrides.workspace,
+    replaceManagedRuntime
+      ? defaultWorkspace
+      : normalizeText(existingAgent?.workspace, defaultWorkspace),
+  );
+  const serverUrl = normalizeText(
+    overrides.serverUrl,
+    normalizeText(input.httpUrl, normalizeText(input.url, DEFAULT_CLAWORLD_SERVER_URL)),
+  );
+  const apiKey = normalizeText(overrides.apiKey, DEFAULT_CLAWORLD_API_KEY);
+  const explicitAppToken = normalizeText(
+    overrides.appToken,
+    normalizeText(input.appToken, null),
+  );
+  const explicitRegistrationAgentCode = normalizeRegistrationAgentCode(
+    overrides.registrationAgentCode,
+    normalizeRegistrationAgentCode(input.code, null),
+  );
+  const appToken = explicitRegistrationAgentCode && !explicitAppToken
+    ? null
+    : normalizeText(
+        explicitAppToken,
+        normalizeText(
+          existingAccount.appToken,
+          normalizeText(
+            existingAccount?.relay?.appToken,
+            normalizeText(existingAccount?.relay?.credentialToken, null),
+          ),
+        ),
+      );
+  const displayName = normalizeText(
+    overrides.displayName,
+    normalizeText(input.name, resolveDefaultManagedDisplayName(resolvedAccountId)),
+  );
+  const name = normalizeText(overrides.name, displayName);
+  const explicitToolProfile = normalizeText(
+    overrides.toolProfile,
+    normalizeText(input.toolProfile, null),
+  );
+  const existingRegistrationAgentCode = normalizeRegistrationAgentCode(
+    existingAccount?.registration?.agentCode,
+    normalizeRegistrationAgentCode(existingAccount?.localAgent?.agentCode, null),
+  );
+  const registrationAgentCode = appToken && !explicitRegistrationAgentCode
+    ? null
+    : normalizeRegistrationAgentCode(
+        explicitRegistrationAgentCode,
+        normalizeRegistrationAgentCode(
+          normalizeRegistrationAgentCode(
+            resolveDefaultManagedRegistrationAgentCode(resolvedAccountId),
+            existingRegistrationAgentCode,
+          ),
+        ),
+      );
+  const approvalMode = normalizeChatRequestApprovalMode(
+    normalizeText(overrides.approvalMode, null),
+    typeof overrides.autoAccept === 'boolean'
+      ? (overrides.autoAccept ? 'open' : DEFAULT_CLAWORLD_APPROVAL_MODE)
+      : resolveStoredApprovalMode(existingAccount),
+  );
+
+  return {
+    repoRoot: normalizeText(overrides.repoRoot, null),
+    agentId,
+    accountId: resolvedAccountId,
+    workspace,
+    agentDir: normalizeText(overrides.agentDir, null),
+    agentDirExplicit: overrides.agentDirExplicit === true,
+    serverUrl,
+    apiKey,
+    appToken,
+    registrationAgentCode,
+    displayName,
+    name,
+    defaultToAddress: normalizeText(overrides.defaultToAddress, null),
+    toolProfile: resolveManagedToolProfile({
+      cfg,
+      existingAccount,
+      explicitToolProfile,
+    }),
+    approvalMode,
+    sessionDmScope: normalizeText(
+      overrides.sessionDmScope,
+      DEFAULT_CLAWORLD_DM_SCOPE,
+    ),
+    replaceManagedRuntime,
+    preserveDefaultAccount: overrides.preserveDefaultAccount === true,
+    forceDefaultAccount: overrides.forceDefaultAccount === true,
+    pluginInstallMode: normalizeText(overrides.pluginInstallMode, 'skip'),
+    installPlugin: overrides.installPlugin !== false,
+  };
+}
+
+export function applyClaworldManagedRuntimeConfig(inputConfig = {}, options = {}) {
+  const config = JSON.parse(JSON.stringify(ensureObject(inputConfig)));
+  const toolProfile = normalizeClaworldToolProfile(options.toolProfile);
+  const toolNames = resolveToolNames({ toolProfile });
+  const summary = [];
+  const replaceManagedRuntime = options.replaceManagedRuntime !== false;
+  const preserveDefaultAccount = options.preserveDefaultAccount === true;
+  const sessionDmScope = normalizeText(options.sessionDmScope, DEFAULT_CLAWORLD_DM_SCOPE);
+
+  if (!options.appToken && !normalizeText(options.registrationAgentCode, null)) {
+    throw new Error('claworld registration agentCode is required when appToken is absent');
+  }
+
+  config.tools = ensureObject(config.tools);
+  const managedOptionalHelperTools = new Set(CLAWORLD_OPTIONAL_WORLD_HELPER_TOOL_NAMES);
+  const existingAllow = asStringArray(config.tools.allow);
+  const removedHelperTools = existingAllow.filter((toolName) => managedOptionalHelperTools.has(toolName));
+  config.tools.allow = uniqueStrings([
+    ...existingAllow.filter((toolName) => !managedOptionalHelperTools.has(toolName)),
+    ...toolNames,
+  ]);
+  if (removedHelperTools.length > 0) {
+    summary.push(`tools.allow removed optional helper entries (${removedHelperTools.join(',')})`);
+  }
+  summary.push(`tools.allow updated for ${toolProfile} profile (${describeToolAllowEntries(toolNames)})`);
+
+  config.session = ensureObject(config.session);
+  if (!Object.prototype.hasOwnProperty.call(config.session, 'dmScope')) {
+    config.session.dmScope = sessionDmScope;
+    summary.push(`session.dmScope set to ${sessionDmScope}`);
+  }
+
+  config.agents = ensureObject(config.agents);
+  const existingAgentList = Array.isArray(config.agents.list) ? [...config.agents.list] : [];
+  const managedAgentEntry = buildManagedAgentEntry(options);
+  if (replaceManagedRuntime) {
+    const removedAgentEntries = existingAgentList.filter((item) => ensureObject(item).id === options.agentId).length;
+    config.agents.list = [
+      ...existingAgentList.filter((item) => ensureObject(item).id !== options.agentId),
+      managedAgentEntry,
+    ];
+    summary.push(
+      removedAgentEntries > 0
+        ? `replaced managed agent entry ${options.agentId}`
+        : `added workspace-scoped agent entry ${options.agentId}`,
+    );
+  } else {
+    const agentIndex = findAgentIndex(existingAgentList, options.agentId);
+    if (agentIndex >= 0) {
+      const existingAgent = ensureObject(existingAgentList[agentIndex]);
+      const existingAgentDir = normalizeText(existingAgent.agentDir, null);
+      const managedSkills = resolveManagedAgentSkills({ toolProfile: options.toolProfile });
+      const keepExistingAgentDir = Boolean(
+        existingAgentDir
+        && (
+          options.agentDirExplicit
+          || existingAgentDir !== normalizeText(options.agentDir, null)
+        ),
+      );
+      const nextAgentEntry = {
+        ...existingAgent,
+        id: options.agentId,
+        workspace: normalizeText(existingAgent.workspace, options.workspace),
+        ...(keepExistingAgentDir ? { agentDir: existingAgentDir } : {}),
+        ...(managedSkills === undefined ? {} : { skills: managedSkills }),
+      };
+      if (!keepExistingAgentDir) {
+        delete nextAgentEntry.agentDir;
+      }
+      if (managedSkills === undefined) {
+        delete nextAgentEntry.skills;
+      }
+      existingAgentList[agentIndex] = nextAgentEntry;
+      summary.push(`updated existing agent entry ${options.agentId}`);
+    } else {
+      existingAgentList.push(managedAgentEntry);
+      summary.push(`added workspace-scoped agent entry ${options.agentId}`);
+    }
+    config.agents.list = existingAgentList;
+  }
+
+  config.channels = ensureObject(config.channels);
+  const existingClaworldRoot = ensureObject(config.channels.claworld);
+  const claworldRoot = replaceManagedRuntime ? {} : { ...existingClaworldRoot };
+  const existingDefaultAccount = normalizeText(existingClaworldRoot.defaultAccount, null);
+  const existingAccounts = ensureObject(existingClaworldRoot.accounts);
+  const targetExistingAccount = ensureObject(existingAccounts[options.accountId]);
+  const nextAccounts = { ...existingAccounts };
+  nextAccounts[options.accountId] = replaceManagedRuntime
+    ? buildManagedAccountEntry(options)
+    : buildMergedAccountEntry(targetExistingAccount, options);
+  claworldRoot.accounts = nextAccounts;
+  const shouldKeepDefaultAccount = preserveDefaultAccount
+    && existingDefaultAccount
+    && Object.prototype.hasOwnProperty.call(nextAccounts, existingDefaultAccount);
+  if (!shouldKeepDefaultAccount || options.forceDefaultAccount) {
+    claworldRoot.defaultAccount = options.accountId;
+    summary.push(`channels.claworld.defaultAccount set to ${options.accountId}`);
+  } else {
+    claworldRoot.defaultAccount = existingDefaultAccount;
+    summary.push(`channels.claworld.defaultAccount preserved as ${existingDefaultAccount}`);
+  }
+  config.channels.claworld = claworldRoot;
+  summary.push(
+    replaceManagedRuntime
+      ? `replaced managed channels.claworld.accounts.${options.accountId}`
+      : `configured channels.claworld.accounts.${options.accountId}`,
+  );
+
+  const existingBindings = Array.isArray(config.bindings) ? [...config.bindings] : [];
+  const remainingBindings = existingBindings.filter((binding) => {
+    const candidate = ensureObject(binding);
+    const match = ensureObject(candidate.match);
+    const bindingChannel = normalizeText(match.channel, null);
+    const bindingAccountId = normalizeText(match.accountId, null);
+    const bindingAgentId = normalizeText(candidate.agentId, null);
+
+    if (bindingChannel === 'claworld' && bindingAccountId === options.accountId) return false;
+    if (bindingChannel === 'claworld' && bindingAgentId === options.agentId) return false;
+    return true;
+  });
+  remainingBindings.push({
+    agentId: options.agentId,
+    match: {
+      channel: 'claworld',
+      accountId: options.accountId,
+    },
+  });
+  config.bindings = remainingBindings;
+  summary.push(
+    replaceManagedRuntime
+      ? `replaced claworld binding for ${options.accountId}`
+      : `reconciled claworld binding for ${options.accountId}`,
+  );
+
+  return {
+    config,
+    toolNames,
+    summary,
+    canonicalAgentCode: canonicalRelayAgentCode(
+      options.registrationAgentCode,
+      options.defaultToAddress,
+    ),
+  };
+}
+
+export function applyClaworldBootstrapConfig(inputConfig = {}, options = {}) {
+  const config = JSON.parse(JSON.stringify(ensureObject(inputConfig)));
+  const summary = [];
+
+  config.plugins = ensureObject(config.plugins);
+  config.plugins.allow = uniqueStrings([...asStringArray(config.plugins.allow), 'claworld']);
+  config.plugins.entries = ensureObject(config.plugins.entries);
+  config.plugins.entries.claworld = {
+    ...ensureObject(config.plugins.entries.claworld),
+    enabled: true,
+  };
+  config.plugins.load = ensureObject(config.plugins.load);
+  const shouldEnsureLoadPath = options.pluginInstallMode === 'link' || options.installPlugin === false;
+  if (shouldEnsureLoadPath) {
+    config.plugins.load.paths = uniqueStrings([
+      ...asStringArray(config.plugins.load.paths),
+      options.repoRoot,
+    ]);
+    summary.push(`plugins.load.paths includes ${options.repoRoot}`);
+  }
+  summary.push('plugins.allow includes claworld');
+
+  const runtimeResult = applyClaworldManagedRuntimeConfig(config, options);
+  return {
+    ...runtimeResult,
+    summary: [...summary, ...runtimeResult.summary],
+  };
+}