@xfxstudio/claworld 0.1.0

package/src/openclaw/plugin/onboarding.js

@@ -0,0 +1,291 @@
+import {
+  DEFAULT_CLAWORLD_ACCOUNT_ID,
+  DEFAULT_CLAWORLD_SERVER_URL,
+  applyClaworldManagedRuntimeConfig,
+  ensureObject,
+  normalizeText,
+  resolveClaworldManagedRuntimeOptions,
+} from './managed-config.js';
+import {
+  LOCAL_AGENT_BOOTSTRAP_SCHEMA,
+  defaultClaworldAccountId,
+  inspectClaworldChannelAccount,
+  listClaworldAccountIds,
+} from './config-schema.js';
+import { parseAgentHandle } from '../../lib/agent-address.js';
+import {
+  buildManagedOnboardingStatus as buildClaworldOnboardingStatus,
+  inspectManagedClaworldInstall,
+  seedManagedWorkspace as ensureManagedWorkspaceSeed,
+} from '../installer/core.js';
+
+const LOCAL_AGENT_CODE_REGEX = new RegExp(
+  LOCAL_AGENT_BOOTSTRAP_SCHEMA?.properties?.agentCode?.pattern || '^[A-Za-z0-9._:+~-]+$',
+  'i',
+);
+
+function isCanonicalAgentHandle(value) {
+  return Boolean(parseAgentHandle(value)?.canonical);
+}
+
+function collectUnsupportedSetupFlags(input = {}) {
+  const unsupported = [];
+  const flagMap = [
+    ['token', '--token'],
+    ['tokenFile', '--token-file'],
+    ['botToken', '--bot-token'],
+    ['signalNumber', '--signal-number'],
+    ['cliPath', '--cli-path'],
+    ['dbPath', '--db-path'],
+    ['service', '--service'],
+    ['region', '--region'],
+    ['authDir', '--auth-dir'],
+    ['httpHost', '--http-host'],
+    ['httpPort', '--http-port'],
+    ['webhookPath', '--webhook-path'],
+    ['webhookUrl', '--webhook-url'],
+    ['audienceType', '--audience-type'],
+    ['audience', '--audience'],
+    ['homeserver', '--homeserver'],
+    ['userId', '--user-id'],
+    ['accessToken', '--access-token'],
+    ['password', '--password'],
+    ['deviceName', '--device-name'],
+    ['initialSyncLimit', '--initial-sync-limit'],
+    ['ship', '--ship'],
+  ];
+
+  for (const [field, flag] of flagMap) {
+    if (normalizeText(input[field], null)) unsupported.push(flag);
+  }
+  if (Array.isArray(input.groupChannels) && input.groupChannels.length > 0) unsupported.push('--group-channels');
+  if (Array.isArray(input.dmAllowlist) && input.dmAllowlist.length > 0) unsupported.push('--dm-allowlist');
+  if (input.autoDiscoverChannels === true) unsupported.push('--auto-discover-channels');
+  if (input.useEnv === true) unsupported.push('--use-env');
+  return unsupported;
+}
+
+function validateClaworldSetupInput({ cfg = {}, accountId = null, input = {} } = {}) {
+  const unsupportedFlags = collectUnsupportedSetupFlags(input);
+  if (unsupportedFlags.length > 0) {
+    return (
+      'Claworld setup only supports --name, --http-url/--url, --app-token, and --code. ' +
+      `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}`;
+    }
+  }
+
+  const explicitRegistrationAgentCode = normalizeText(input.code, null);
+  const existingRegistrationAgentCode = normalizeText(
+    inspected?.registration?.agentCode,
+    normalizeText(inspected?.localAgent?.agentCode, null),
+  );
+  const registrationAgentCode = explicitRegistrationAgentCode
+    || (isCanonicalAgentHandle(existingRegistrationAgentCode) ? existingRegistrationAgentCode : null);
+  if (!appToken && !explicitRegistrationAgentCode && existingRegistrationAgentCode && !isCanonicalAgentHandle(existingRegistrationAgentCode)) {
+    return 'Existing Claworld registration.agentCode is legacy/raw. Re-run setup with --code <local@namespace> so the namespace stays explicit.';
+  }
+  if (!appToken && !registrationAgentCode) {
+    return 'Claworld identity handle is required unless you already have an appToken. Use --code <local@namespace> or --app-token <token>.';
+  }
+  if (!appToken && explicitRegistrationAgentCode && !LOCAL_AGENT_CODE_REGEX.test(explicitRegistrationAgentCode)) {
+    return 'Claworld identity handle must match ^[A-Za-z0-9._:+~-]+(?:@[A-Za-z0-9._:+~-]+)?$.';
+  }
+  if (!appToken && explicitRegistrationAgentCode && !isCanonicalAgentHandle(explicitRegistrationAgentCode)) {
+    return 'Claworld identity handle must use canonical local@namespace syntax (for example "xiaofafa@robin").';
+  }
+
+  return null;
+}
+
+function currentManagedIdentityInput({ cfg = {}, accountId = null } = {}) {
+  const inspected = inspectClaworldChannelAccount(cfg, accountId);
+  const appToken = normalizeText(inspected?.appToken, null);
+  if (appToken) {
+    return {
+      appToken,
+    };
+  }
+
+  const currentCode = normalizeText(
+    inspected?.registration?.agentCode,
+    normalizeText(inspected?.localAgent?.agentCode, null),
+  );
+  return isCanonicalAgentHandle(currentCode)
+    ? { code: currentCode }
+    : {};
+}
+
+async function collectManagedIdentityInput({ cfg = {}, prompter, accountId = null } = {}) {
+  const currentInput = currentManagedIdentityInput({ cfg, accountId });
+  if (currentInput.appToken) {
+    return currentInput;
+  }
+
+  const code = await prompter.text({
+    message: 'Choose a unique Claworld identity handle',
+    initialValue: currentInput.code || '',
+    placeholder: 'xiaofafa@robin',
+    validate: (value) => {
+      const message = validateClaworldSetupInput({ input: { code: value } });
+      return message || undefined;
+    },
+  });
+
+  return {
+    code,
+  };
+}
+
+function applyManagedAccountName({ cfg = {}, accountId, name } = {}) {
+  const normalizedName = normalizeText(name, null);
+  if (!normalizedName) return cfg;
+
+  const next = JSON.parse(JSON.stringify(ensureObject(cfg)));
+  next.channels = ensureObject(next.channels);
+  const claworldRoot = ensureObject(next.channels.claworld);
+  const accounts = ensureObject(claworldRoot.accounts);
+  const existingAccount = ensureObject(accounts[accountId]);
+  accounts[accountId] = {
+    ...existingAccount,
+    name: normalizedName,
+    ...(existingAccount.registration
+      ? {
+          registration: {
+            ...ensureObject(existingAccount.registration),
+            displayName: normalizedName,
+          },
+        }
+      : {}),
+  };
+  next.channels.claworld = {
+    ...claworldRoot,
+    accounts,
+  };
+  return next;
+}
+
+function resolveManagedOptionsFromContext({ cfg = {}, accountId = null, input = {}, overrides = {} } = {}) {
+  return resolveClaworldManagedRuntimeOptions({
+    cfg,
+    accountId: normalizeText(accountId, DEFAULT_CLAWORLD_ACCOUNT_ID),
+    input,
+    overrides,
+  });
+}
+
+async function applyManagedOnboardingConfig({
+  cfg = {},
+  prompter,
+  accountId = null,
+  phase = 'setup',
+  input = {},
+} = {}) {
+  const managedOptions = resolveManagedOptionsFromContext({ cfg, accountId, input });
+  const next = applyClaworldManagedRuntimeConfig(cfg, managedOptions);
+  await ensureManagedWorkspaceSeed(managedOptions);
+
+  const noteLines = [
+    `Managed local agent/account: ${managedOptions.agentId}`,
+    `Remote backend: ${managedOptions.serverUrl}`,
+    managedOptions.registrationAgentCode
+      ? `Bootstrap mode: registration (${managedOptions.registrationAgentCode})`
+      : 'Bootstrap mode: appToken/manual binding',
+    'This flow only refreshes plugin-side config and workspace files. It does not start a backend service.',
+  ];
+  await prompter.note(
+    noteLines.join('\n'),
+    phase === 'refresh' ? 'Claworld refresh' : 'Claworld setup',
+  );
+
+  return {
+    cfg: next.config,
+    accountId: managedOptions.accountId,
+  };
+}
+
+export const claworldSetupAdapter = {
+  resolveAccountId: ({ accountId }) => normalizeText(accountId, DEFAULT_CLAWORLD_ACCOUNT_ID),
+  resolveBindingAccountId: ({ cfg, agentId, accountId }) => {
+    const explicit = normalizeText(accountId, null);
+    if (explicit) return explicit;
+    const normalizedAgentId = normalizeText(agentId, null);
+    const accountIds = listClaworldAccountIds(cfg);
+    if (normalizedAgentId && accountIds.includes(normalizedAgentId)) {
+      return normalizedAgentId;
+    }
+    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 }),
+  applyAccountConfig: ({ cfg, accountId, input }) => {
+    const managedOptions = resolveManagedOptionsFromContext({ cfg, accountId, input });
+    return applyClaworldManagedRuntimeConfig(cfg, managedOptions).config;
+  },
+};
+
+export const claworldOnboardingAdapter = {
+  channel: 'claworld',
+  getStatus: async ({ cfg, accountOverrides }) => {
+    const managedAccountId = normalizeText(accountOverrides?.claworld, DEFAULT_CLAWORLD_ACCOUNT_ID);
+    return {
+      channel: 'claworld',
+      ...buildClaworldOnboardingStatus({
+        cfg,
+        accountId: managedAccountId,
+      }),
+    };
+  },
+  configure: async ({ cfg, prompter, accountOverrides }) => {
+    const input = await collectManagedIdentityInput({
+      cfg,
+      prompter,
+      accountId: accountOverrides?.claworld,
+    });
+    return await 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({
+      cfg,
+      prompter,
+      accountId: accountOverrides?.claworld,
+      phase: 'refresh',
+      input,
+    });
+  },
+};
+
+export {
+  buildClaworldOnboardingStatus,
+  ensureManagedWorkspaceSeed,
+  inspectManagedClaworldInstall,
+  validateClaworldSetupInput,
+};