@xfxstudio/claworld 0.2.12 → 0.2.14

package/src/openclaw/plugin/claworld-channel-plugin.js

@@ -36,12 +36,9 @@ import {
   buildWorldSelectionPrompt,
   buildCandidateDeliverySummary,
   buildPostSetupWorldDirectory,
-  broadcastWorld,
-  fetchWorldSearch,
   fetchWorldCandidateFeed,
   fetchWorldDetail,
   joinWorld,
-  submitWorldSearch,
   resolveWorldSelection,
   resolveWorldSelectionFlow,
 } from '../runtime/product-shell-helper.js';
@@ -53,7 +50,6 @@ import {
   serializeRuntimeBoundaryError,
 } from '../../lib/runtime-errors.js';
 import { PUBLIC_IDENTITY_STATUS } from '../../lib/public-identity.js';
-import { v4 as uuidv4 } from 'uuid';
 
 function normalizeRelayHttpBaseUrl(serverUrl) {
   const parsed = new URL(serverUrl);
@@ -70,8 +66,12 @@ function normalizePluginOptionalText(value) {
   return normalized || null;
 }
 
-function resolveClientMessageId(value = null) {
-  return normalizePluginOptionalText(value) || `cmsg_${uuidv4()}`;
+function requireClientMessageId(value = null) {
+  const normalized = normalizePluginOptionalText(value);
+  if (!normalized) {
+    throw new Error('claworld outbound clientMessageId is required for POST /v1/messages');
+  }
+  return normalized;
 }
 
 function buildRelayAgentSummary(item = {}) {
@@ -338,7 +338,7 @@ async function deliverRelayMessage({ runtimeConfig, to, text, fetchImpl, logger,
   }
   payload.source = normalizeClaworldText(payload.source, 'openclaw-claworld');
   payload.accountId = normalizeClaworldText(payload.accountId, runtimeConfig.accountId);
-  const clientMessageId = resolveClientMessageId(
+  const clientMessageId = requireClientMessageId(
     outboundContext.clientMessageId || outboundContext.metadata?.clientMessageId || null
   );
 
@@ -433,129 +433,6 @@ function createRelayRouteError({
   });
 }
 
-async function createFriendRequest({
-  runtimeConfig,
-  fromAgentId,
-  targetAgentId,
-  message = null,
-  metadata = {},
-  fetchImpl,
-}) {
-  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
-  const result = await fetchJson(fetchImpl, `${baseUrl}/v1/friend-requests`, {
-    method: 'POST',
-    headers: {
-      'content-type': 'application/json',
-      ...(runtimeConfig.apiKey ? { 'x-api-key': runtimeConfig.apiKey } : {}),
-      ...buildRuntimeAuthHeaders(runtimeConfig),
-    },
-    body: JSON.stringify({
-      fromAgentId,
-      targetAgentId,
-      message: normalizeClaworldText(message, null),
-      metadata: metadata && typeof metadata === 'object' && !Array.isArray(metadata) ? metadata : {},
-    }),
-  });
-  if (!result.ok) {
-    createRelayRouteError({
-      result,
-      runtimeConfig,
-      code: 'friend_request_failed',
-      publicMessage: 'failed to create friend request',
-      context: { fromAgentId, targetAgentId },
-    });
-  }
-  return result.body || {};
-}
-
-async function listFriendRequests({
-  runtimeConfig,
-  agentId,
-  direction = null,
-  status = null,
-  fetchImpl,
-}) {
-  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
-  const path = buildRelayJsonPath('/v1/friend-requests', {
-    agentId,
-    direction,
-    status,
-  });
-  const result = await fetchJson(fetchImpl, `${baseUrl}${path}`, {
-    method: 'GET',
-    headers: {
-      ...(runtimeConfig.apiKey ? { 'x-api-key': runtimeConfig.apiKey } : {}),
-      ...buildRuntimeAuthHeaders(runtimeConfig),
-    },
-  });
-  if (!result.ok) {
-    createRelayRouteError({
-      result,
-      runtimeConfig,
-      code: 'friend_request_list_failed',
-      publicMessage: 'failed to list friend requests',
-      context: { agentId, direction, status },
-    });
-  }
-  return result.body || {};
-}
-
-async function acceptFriendRequest({
-  runtimeConfig,
-  actorAgentId,
-  friendRequestId,
-  fetchImpl,
-}) {
-  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
-  const result = await fetchJson(fetchImpl, `${baseUrl}/v1/friend-requests/${encodeURIComponent(friendRequestId)}/accept`, {
-    method: 'POST',
-    headers: {
-      'content-type': 'application/json',
-      ...(runtimeConfig.apiKey ? { 'x-api-key': runtimeConfig.apiKey } : {}),
-      ...buildRuntimeAuthHeaders(runtimeConfig),
-    },
-    body: JSON.stringify({ actorAgentId }),
-  });
-  if (!result.ok) {
-    createRelayRouteError({
-      result,
-      runtimeConfig,
-      code: 'friend_request_accept_failed',
-      publicMessage: 'failed to accept friend request',
-      context: { actorAgentId, friendRequestId },
-    });
-  }
-  return result.body || {};
-}
-
-async function rejectFriendRequest({
-  runtimeConfig,
-  actorAgentId,
-  friendRequestId,
-  fetchImpl,
-}) {
-  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
-  const result = await fetchJson(fetchImpl, `${baseUrl}/v1/friend-requests/${encodeURIComponent(friendRequestId)}/reject`, {
-    method: 'POST',
-    headers: {
-      'content-type': 'application/json',
-      ...(runtimeConfig.apiKey ? { 'x-api-key': runtimeConfig.apiKey } : {}),
-      ...buildRuntimeAuthHeaders(runtimeConfig),
-    },
-    body: JSON.stringify({ actorAgentId }),
-  });
-  if (!result.ok) {
-    createRelayRouteError({
-      result,
-      runtimeConfig,
-      code: 'friend_request_reject_failed',
-      publicMessage: 'failed to reject friend request',
-      context: { actorAgentId, friendRequestId },
-    });
-  }
-  return result.body || {};
-}
-
 async function createChatRequest({
   runtimeConfig,
   fromAgentId,
@@ -932,7 +809,7 @@ async function fetchPublicIdentity({
       recommendedDisplayName,
       nextAction: 'set_public_identity',
       requiredAction: 'set_public_identity',
-      nextTool: 'claworld_profile',
+      nextTool: 'claworld_account',
       missingFields: [
         {
           fieldId: 'displayName',
@@ -2748,45 +2625,6 @@ export function createClaworldChannelPlugin({
         }),
       },
       social: {
-        sendFriendRequest: async (context = {}) => {
-          const resolvedContext = await resolveBoundRuntimeContext(context);
-          return createFriendRequest({
-            runtimeConfig: resolvedContext.runtimeConfig,
-            fromAgentId: resolvedContext.agentId || null,
-            targetAgentId: context.targetAgentId || null,
-            message: context.message || null,
-            metadata: context.metadata || {},
-            fetchImpl,
-          });
-        },
-        listFriendRequests: async (context = {}) => {
-          const resolvedContext = await resolveBoundRuntimeContext(context);
-          return listFriendRequests({
-            runtimeConfig: resolvedContext.runtimeConfig,
-            agentId: resolvedContext.agentId || null,
-            direction: context.direction || null,
-            status: context.status || null,
-            fetchImpl,
-          });
-        },
-        acceptFriendRequest: async (context = {}) => {
-          const resolvedContext = await resolveBoundRuntimeContext(context);
-          return acceptFriendRequest({
-            runtimeConfig: resolvedContext.runtimeConfig,
-            actorAgentId: resolvedContext.agentId || null,
-            friendRequestId: context.friendRequestId || null,
-            fetchImpl,
-          });
-        },
-        rejectFriendRequest: async (context = {}) => {
-          const resolvedContext = await resolveBoundRuntimeContext(context);
-          return rejectFriendRequest({
-            runtimeConfig: resolvedContext.runtimeConfig,
-            actorAgentId: resolvedContext.agentId || null,
-            friendRequestId: context.friendRequestId || null,
-            fetchImpl,
-          });
-        },
         requestChat: async (context = {}) => {
           const resolvedContext = await resolveBoundRuntimeContext(context);
           const requestContext = resolvedContext.requesterSessionKey
@@ -2815,15 +2653,6 @@ export function createClaworldChannelPlugin({
             fetchImpl,
           });
         },
-        listChatRequests: async (context = {}) => {
-          const resolvedContext = await resolveBoundRuntimeContext(context);
-          return listChatInbox({
-            runtimeConfig: resolvedContext.runtimeConfig,
-            agentId: resolvedContext.agentId || null,
-            direction: context.direction || null,
-            fetchImpl,
-          });
-        },
         acceptChatRequest: async (context = {}) => {
           const resolvedContext = await resolveBoundRuntimeContext(context);
           return acceptChatRequest({
@@ -2899,34 +2728,6 @@ export function createClaworldChannelPlugin({
             logger,
           });
         },
-        fetchWorldSearch: async (context = {}) => {
-          const resolvedContext = await resolveBoundRuntimeContext(context);
-          return fetchWorldSearch({
-            cfg: resolvedContext.cfg || {},
-            accountId: resolvedContext.accountId || null,
-            runtimeConfig: resolvedContext.runtimeConfig || null,
-            worldId: context.worldId || null,
-            agentId: resolvedContext.agentId || null,
-            query: context.query || {},
-            limit: context.limit ?? null,
-            fetchImpl,
-            logger,
-          });
-        },
-        submitWorldSearch: async (context = {}) => {
-          const resolvedContext = await resolveBoundRuntimeContext(context);
-          return submitWorldSearch({
-            cfg: resolvedContext.cfg || {},
-            accountId: resolvedContext.accountId || null,
-            runtimeConfig: resolvedContext.runtimeConfig || null,
-            worldId: context.worldId || null,
-            agentId: resolvedContext.agentId || null,
-            query: context.query || {},
-            limit: context.limit ?? null,
-            fetchImpl,
-            logger,
-          });
-        },
         resolveWorldSelection: (context = {}) => resolveWorldSelection(
           context.worldDirectory || {},
           context.selection ?? context.userChoice ?? null,
@@ -3054,52 +2855,6 @@ export function createClaworldChannelPlugin({
             logger,
           });
         },
-        fetchWorldSearch: async (context = {}) => {
-          const resolvedContext = await resolveBoundRuntimeContext(context);
-          return fetchWorldSearch({
-            cfg: resolvedContext.cfg || {},
-            accountId: resolvedContext.accountId || null,
-            runtimeConfig: resolvedContext.runtimeConfig || null,
-            worldId: context.worldId || null,
-            agentId: resolvedContext.agentId || null,
-            query: context.query || {},
-            limit: context.limit ?? null,
-            fetchImpl,
-            logger,
-          });
-        },
-        submitWorldSearch: async (context = {}) => {
-          const resolvedContext = await resolveBoundRuntimeContext(context);
-          return submitWorldSearch({
-            cfg: resolvedContext.cfg || {},
-            accountId: resolvedContext.accountId || null,
-            runtimeConfig: resolvedContext.runtimeConfig || null,
-            worldId: context.worldId || null,
-            agentId: resolvedContext.agentId || null,
-            query: context.query || {},
-            limit: context.limit ?? null,
-            fetchImpl,
-            logger,
-          });
-        },
-        broadcastWorld: async (context = {}) => {
-          const resolvedContext = await resolveBoundRuntimeContext(context);
-          return broadcastWorld({
-            cfg: resolvedContext.cfg || {},
-            accountId: resolvedContext.accountId || null,
-            runtimeConfig: resolvedContext.runtimeConfig || null,
-            worldId: context.worldId || null,
-            agentId: resolvedContext.agentId || null,
-            message: context.message || null,
-            payload: context.payload || {},
-            audience: context.audience || null,
-            replyPolicy: context.replyPolicy || null,
-            ...(Object.prototype.hasOwnProperty.call(context, 'excludeSelf') ? { excludeSelf: context.excludeSelf } : {}),
-            conversation: context.conversation || {},
-            fetchImpl,
-            logger,
-          });
-        },
         resolveWorldSelection,
         buildCandidateDeliverySummary,
         resolveWorldSelectionFlow: async (context = {}) => {

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

@@ -2,10 +2,8 @@ import os from 'os';
 import path from 'path';
 import {
   CLAWORLD_MINIMAL_OPENCLAW_TOOL_NAMES,
-  CLAWORLD_COMPATIBILITY_TOOL_NAMES,
   CLAWORLD_PUBLIC_TOOL_NAMES,
   CLAWORLD_READ_ONLY_OPENCLAW_TOOL_NAMES,
-  CLAWORLD_RETIRED_PUBLIC_TOOL_NAMES,
   CLAWORLD_TOOL_PROFILES,
 } from '../runtime/tool-inventory.js';
 import {
@@ -725,11 +723,7 @@ export function applyClaworldManagedRuntimeConfig(inputConfig = {}, options = {}
   const sessionDmScope = normalizeText(options.sessionDmScope, DEFAULT_CLAWORLD_DM_SCOPE);
   const manageAgentEntry = options.manageAgentEntry === true;
 
-  const removedManagedToolNames = new Set([
-    ...CLAWORLD_PUBLIC_TOOL_NAMES,
-    ...CLAWORLD_COMPATIBILITY_TOOL_NAMES,
-    ...CLAWORLD_RETIRED_PUBLIC_TOOL_NAMES,
-  ]);
+  const removedManagedToolNames = new Set(CLAWORLD_PUBLIC_TOOL_NAMES);
   if (inputConfig?.tools && typeof inputConfig.tools === 'object') {
     config.tools = ensureObject(config.tools);
     const existingAllow = asStringArray(config.tools.allow);

package/src/openclaw/plugin/onboarding.js

@@ -1,6 +1,5 @@
 import {
   DEFAULT_CLAWORLD_ACCOUNT_ID,
-  DEFAULT_CLAWORLD_SERVER_URL,
   applyClaworldManagedRuntimeConfig,
   ensureObject,
   normalizeText,
@@ -11,15 +10,11 @@ import {
   inspectClaworldChannelAccount,
   listClaworldAccountIds,
 } from './config-schema.js';
-import {
-  buildManagedOnboardingStatus as buildClaworldOnboardingStatus,
-  inspectManagedClaworldInstall,
-  seedManagedWorkspace as ensureManagedWorkspaceSeed,
-} from '../installer/core.js';
 
 function collectUnsupportedSetupFlags(input = {}) {
   const unsupported = [];
   const flagMap = [
+    ['appToken', '--app-token'],
     ['token', '--token'],
     ['tokenFile', '--token-file'],
     ['botToken', '--bot-token'],
@@ -54,89 +49,143 @@ function collectUnsupportedSetupFlags(input = {}) {
   return unsupported;
 }
 
-function validateClaworldSetupInput({ cfg = {}, accountId = null, input = {} } = {}) {
+export function validateClaworldSetupInput({ input = {} } = {}) {
   const unsupportedFlags = collectUnsupportedSetupFlags(input);
   if (unsupportedFlags.length > 0) {
     return (
-      'Claworld setup only supports --name, --http-url/--url, and --app-token. ' +
-      `Unsupported flag(s): ${unsupportedFlags.join(', ')}.`
+      'Claworld host-native setup only supports an optional local account label and --http-url/--url overrides. '
+      + `Unsupported flag(s): ${unsupportedFlags.join(', ')}.`
     );
   }
 
-  const inspected = inspectClaworldChannelAccount(cfg, accountId);
-  const appToken = normalizeText(
-    input.appToken,
-    normalizeText(inspected?.appToken, null),
-  );
-
   const serverUrl = normalizeText(input.httpUrl, normalizeText(input.url, null));
-  if (serverUrl) {
-    try {
-      const parsed = new URL(serverUrl);
-      if (!['http:', 'https:', 'ws:', 'wss:'].includes(parsed.protocol)) {
-        return `Unsupported Claworld server URL protocol: ${parsed.protocol}`;
-      }
-    } catch {
-      return `Invalid Claworld server URL: ${serverUrl}`;
-    }
+  if (!serverUrl) {
+    return null;
   }
 
-  const registrationDisplayName = normalizeText(
-    input.name,
-    normalizeText(
-      inspected?.name,
-      normalizeText(
-        inspected?.registration?.displayName,
-        normalizeText(inspected?.localAgent?.displayName, null),
-      ),
-    ),
-  );
-  if (!appToken && !registrationDisplayName) {
-    return 'Claworld public display name is required unless you already have an appToken. Use --name <display-name> or --app-token <token>.';
+  try {
+    const parsed = new URL(serverUrl);
+    if (!['http:', 'https:', 'ws:', 'wss:'].includes(parsed.protocol)) {
+      return `Unsupported Claworld server URL protocol: ${parsed.protocol}`;
+    }
+  } catch {
+    return `Invalid Claworld server URL: ${serverUrl}`;
   }
 
   return null;
 }
 
-function currentManagedIdentityInput({ cfg = {}, accountId = null } = {}) {
-  const inspected = inspectClaworldChannelAccount(cfg, accountId);
-  const appToken = normalizeText(inspected?.appToken, null);
-  if (appToken) {
-    return {
-      appToken,
-    };
-  }
+function findAgentEntry(config = {}, agentId) {
+  const normalizedAgentId = normalizeText(agentId, null);
+  if (!normalizedAgentId) return null;
+  const list = Array.isArray(config?.agents?.list) ? config.agents.list : [];
+  return list
+    .map((entry) => ensureObject(entry))
+    .find((entry) => entry.id === normalizedAgentId) || null;
+}
 
-  const currentDisplayName = normalizeText(
-    inspected?.name,
-    normalizeText(
-      inspected?.registration?.displayName,
-      normalizeText(inspected?.localAgent?.displayName, null),
-    ),
+function hasClaworldBinding(config = {}, { agentId, accountId } = {}) {
+  const normalizedAgentId = normalizeText(agentId, null);
+  const normalizedAccountId = normalizeText(accountId, DEFAULT_CLAWORLD_ACCOUNT_ID);
+  const resolvedDefaultAccountId = defaultClaworldAccountId(config) || DEFAULT_CLAWORLD_ACCOUNT_ID;
+  const bindings = Array.isArray(config?.bindings) ? config.bindings : [];
+  return bindings.some((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') return false;
+    if (normalizedAgentId && bindingAgentId !== normalizedAgentId) return false;
+    if (bindingAccountId === normalizedAccountId) return true;
+    return !bindingAccountId && resolvedDefaultAccountId === normalizedAccountId;
+  });
+}
+
+function isRelayBootstrapReady(account = {}) {
+  return Boolean(
+    account?.configured
+    && normalizeText(account?.appToken, null),
   );
-  return currentDisplayName
-    ? { name: currentDisplayName }
-    : {};
 }
 
-async function collectManagedIdentityInput({ cfg = {}, prompter, accountId = null } = {}) {
-  const currentInput = currentManagedIdentityInput({ cfg, accountId });
-  if (currentInput.appToken) {
-    return currentInput;
+export function inspectManagedClaworldInstall({
+  cfg = {},
+  accountId = DEFAULT_CLAWORLD_ACCOUNT_ID,
+  input = {},
+  overrides = {},
+} = {}) {
+  const configuredAccountIds = listClaworldAccountIds(cfg);
+  const hasAnyConfig = configuredAccountIds.length > 0 || cfg?.channels?.claworld != null;
+  const managedOptions = resolveClaworldManagedRuntimeOptions({
+    cfg,
+    accountId,
+    input,
+    overrides,
+  });
+  const managedAgentPresent = Boolean(findAgentEntry(cfg, managedOptions.agentId));
+  const managedBindingPresent = hasClaworldBinding(cfg, managedOptions);
+  const managedAccountPresent = configuredAccountIds.includes(managedOptions.accountId);
+  const accountStatus = managedAccountPresent
+    ? inspectClaworldChannelAccount(cfg, managedOptions.accountId)
+    : inspectClaworldChannelAccount({}, managedOptions.accountId);
+  const activationReady = isRelayBootstrapReady(accountStatus);
+  const setupReady = Boolean(
+    managedAccountPresent
+    && managedBindingPresent
+    && (managedOptions.manageAgentEntry !== true || managedAgentPresent)
+  );
+
+  let statusLabel = 'needs setup';
+  let selectionHint = 'remote relay world channel';
+  let quickstartScore = 5;
+
+  if (setupReady && activationReady) {
+    statusLabel = 'configured';
+    selectionHint = 'configured · ready';
+    quickstartScore = 2;
+  } else if (setupReady) {
+    statusLabel = 'configured (activation pending)';
+    selectionHint = 'configured · activation pending';
+    quickstartScore = 3;
+  } else if (managedAccountPresent && !managedBindingPresent) {
+    statusLabel = 'configured (binding pending)';
+    selectionHint = 'configured · binding pending';
+    quickstartScore = 4;
+  } else if (hasAnyConfig) {
+    statusLabel = 'configured (refresh recommended)';
+    selectionHint = 'configured · refresh recommended';
+    quickstartScore = 4;
   }
 
-  const name = await prompter.text({
-    message: 'Choose the public display name to bootstrap this Claworld agent',
-    initialValue: currentInput.name || '',
-    placeholder: 'Claworld Agent',
-    validate: (value) => {
-      const message = validateClaworldSetupInput({ input: { name: value } });
-      return message || undefined;
-    },
-  });
+  return {
+    hasAnyConfig,
+    configuredAccountIds,
+    defaultAccountId: defaultClaworldAccountId(cfg) || null,
+    managedOptions,
+    managedAccountPresent,
+    managedAgentPresent,
+    managedBindingPresent,
+    accountStatus,
+    activationReady,
+    setupReady,
+    statusLabel,
+    selectionHint,
+    quickstartScore,
+  };
+}
 
+export function buildClaworldOnboardingStatus({
+  cfg = {},
+  accountId = DEFAULT_CLAWORLD_ACCOUNT_ID,
+} = {}) {
+  const inspection = inspectManagedClaworldInstall({ cfg, accountId });
   return {
-    name,
+    configured: inspection.setupReady,
+    statusLines: [`Claworld: ${inspection.statusLabel}`],
+    selectionHint: inspection.selectionHint,
+    quickstartScore: inspection.quickstartScore,
+    activationReady: inspection.activationReady,
   };
 }
 
@@ -178,7 +227,7 @@ function resolveManagedOptionsFromContext({ cfg = {}, accountId = null, input =
     input: resolvedInput,
     overrides: {
       ...overrides,
-      ...(normalizeText(normalizedInput.name, null) ? { displayName: normalizedInput.name } : {}),
+      ...(normalizeText(normalizedInput.name, null) ? { name: normalizedInput.name } : {}),
     },
   });
 }
@@ -192,19 +241,14 @@ async function applyManagedOnboardingConfig({
 } = {}) {
   const managedOptions = resolveManagedOptionsFromContext({ cfg, accountId, input });
   const next = applyClaworldManagedRuntimeConfig(cfg, managedOptions);
-  if (managedOptions.manageWorkspace) {
-    await ensureManagedWorkspaceSeed(managedOptions);
-  }
 
   const noteLines = [
     `Bound local agent/account: ${managedOptions.agentId}`,
     `Remote backend: ${managedOptions.serverUrl}`,
     managedOptions.appToken
       ? 'Activation state: ready via configured appToken'
-      : 'Activation state: pending until claworld_profile runs',
-    managedOptions.manageWorkspace
-      ? 'This flow refreshes plugin-side config and the dedicated claworld workspace contract. It does not start a backend service.'
-      : 'This flow refreshes plugin-side config and binds claworld onto the existing local agent. It does not start a backend service.',
+      : 'Activation state: pending until claworld_account(action=update_identity) runs',
+    'This flow refreshes plugin-side config and binds claworld onto the selected local agent. It does not run installer commands or start a backend service.',
   ];
   await prompter.note(
     noteLines.join('\n'),
@@ -230,7 +274,7 @@ export const claworldSetupAdapter = {
     return accountIds.length > 0 ? defaultClaworldAccountId(cfg) : DEFAULT_CLAWORLD_ACCOUNT_ID;
   },
   applyAccountName: ({ cfg, accountId, name }) => applyManagedAccountName({ cfg, accountId, name }),
-  validateInput: ({ cfg, accountId, input }) => validateClaworldSetupInput({ cfg, accountId, input }),
+  validateInput: ({ input }) => validateClaworldSetupInput({ input }),
   applyAccountConfig: ({ cfg, accountId, input }) => {
     const managedOptions = resolveManagedOptionsFromContext({ cfg, accountId, input });
     return applyClaworldManagedRuntimeConfig(cfg, managedOptions).config;
@@ -249,39 +293,20 @@ export const claworldOnboardingAdapter = {
       }),
     };
   },
-  configure: async ({ cfg, prompter, accountOverrides }) => {
-    const input = await collectManagedIdentityInput({
-      cfg,
-      prompter,
-      accountId: accountOverrides?.claworld,
-    });
-    return await applyManagedOnboardingConfig({
+  configure: async ({ cfg, prompter, accountOverrides }) =>
+    applyManagedOnboardingConfig({
       cfg,
       prompter,
       accountId: accountOverrides?.claworld,
       phase: 'setup',
-      input,
-    });
-  },
-  configureWhenConfigured: async ({ cfg, prompter, accountOverrides }) => {
-    const input = await collectManagedIdentityInput({
-      cfg,
-      prompter,
-      accountId: accountOverrides?.claworld,
-    });
-    return await applyManagedOnboardingConfig({
+      input: {},
+    }),
+  configureWhenConfigured: async ({ cfg, prompter, accountOverrides }) =>
+    applyManagedOnboardingConfig({
       cfg,
       prompter,
       accountId: accountOverrides?.claworld,
       phase: 'refresh',
-      input,
-    });
-  },
-};
-
-export {
-  buildClaworldOnboardingStatus,
-  ensureManagedWorkspaceSeed,
-  inspectManagedClaworldInstall,
-  validateClaworldSetupInput,
+      input: {},
+    }),
 };