@xfxstudio/claworld 2026.6.10 → 2026.6.26-testing.1

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

@@ -1303,6 +1303,7 @@ async function fetchPublicIdentity({
   agentId = null,
   generateShareCard = false,
   expiresInSeconds = null,
+  shareCardVariant = null,
   fetchImpl,
 }) {
   if (!resolveRuntimeAppToken(runtimeConfig)) {
@@ -1361,6 +1362,7 @@ async function fetchPublicIdentity({
       ...(agentId ? { agentId } : {}),
       action: 'view',
       ...(generateShareCard === true ? { generateShareCard: true } : {}),
+      ...(normalizeClaworldText(shareCardVariant, null) ? { shareCardVariant: normalizeClaworldText(shareCardVariant, null) } : {}),
       ...(normalizeClaworldInteger(expiresInSeconds, null) > 0
         ? { expiresInSeconds: normalizeClaworldInteger(expiresInSeconds, null) }
         : {}),
@@ -1384,6 +1386,7 @@ async function updatePublicIdentity({
   displayName = null,
   generateShareCard = true,
   expiresInSeconds = null,
+  shareCardVariant = null,
   fetchImpl,
 }) {
   const normalizedDisplayName = normalizeClaworldText(displayName, null);
@@ -1402,43 +1405,17 @@ async function updatePublicIdentity({
   let resolvedAgentId = normalizeClaworldText(agentId, normalizeClaworldText(resolvedRuntimeConfig?.relay?.agentId, null));
 
   if (!resolveRuntimeAppToken(resolvedRuntimeConfig)) {
-    const baseUrl = normalizeRelayHttpBaseUrl(resolvedRuntimeConfig.serverUrl);
-    const activationResult = await fetchJson(fetchImpl, `${baseUrl}/v1/onboarding/activate`, {
-      method: 'POST',
-      headers: {
-        'content-type': 'application/json',
-        ...(resolvedRuntimeConfig.apiKey ? { 'x-api-key': resolvedRuntimeConfig.apiKey } : {}),
-        ...buildRuntimeAuthHeaders(resolvedRuntimeConfig),
+    throw createRuntimeBoundaryError({
+      code: 'email_verification_required',
+      category: 'auth',
+      status: 401,
+      message: 'claworld email verification is required before updating public identity',
+      publicMessage: 'complete Claworld email verification before updating public identity',
+      recoverable: true,
+      context: {
+        requiredActions: ['start_email_verification', 'complete_email_verification'],
       },
-      body: JSON.stringify({
-        displayName: normalizedDisplayName,
-      }),
-    });
-    if (!activationResult.ok) {
-      createRelayRouteError({
-        result: activationResult,
-        runtimeConfig: resolvedRuntimeConfig,
-        code: 'claworld_activation_failed',
-        publicMessage: 'failed to activate Claworld account',
-      });
-    }
-    const activatedToken = normalizeClaworldText(activationResult.body?.appToken, null);
-    const activatedAgentId = normalizeClaworldText(activationResult.body?.agentId, null);
-    if (!activatedToken || !activatedAgentId) {
-      throw createRuntimeBoundaryError({
-        code: 'claworld_activation_failed',
-        category: 'runtime',
-        status: 502,
-        message: 'claworld activation did not return appToken and agentId',
-        publicMessage: 'failed to activate Claworld account',
-        recoverable: true,
-      });
-    }
-    resolvedRuntimeConfig = applyRuntimeIdentity(resolvedRuntimeConfig, {
-      appToken: activatedToken,
-      agentId: activatedAgentId,
     });
-    resolvedAgentId = activatedAgentId;
   }
   const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
   const result = await fetchJson(fetchImpl, `${baseUrl}/v1/profile`, {
@@ -1454,6 +1431,7 @@ async function updatePublicIdentity({
       action: 'update_identity',
       displayName: normalizedDisplayName,
       ...(generateShareCard === true ? { generateShareCard: true } : {}),
+      ...(normalizeClaworldText(shareCardVariant, null) ? { shareCardVariant: normalizeClaworldText(shareCardVariant, null) } : {}),
       ...(normalizeClaworldInteger(expiresInSeconds, null) > 0
         ? { expiresInSeconds: normalizeClaworldInteger(expiresInSeconds, null) }
         : {}),
@@ -1472,9 +1450,9 @@ async function updatePublicIdentity({
   }
   return {
     ...(result.body || {}),
-    runtimeActivation: !resolveRuntimeAppToken(runtimeConfig)
+    runtimeIdentity: !resolveRuntimeAppToken(runtimeConfig)
       ? {
-          status: 'activated',
+          status: 'verified',
           agentId: resolvedAgentId,
         }
       : null,
@@ -1482,6 +1460,106 @@ async function updatePublicIdentity({
   };
 }
 
+async function startEmailVerification({
+  runtimeConfig,
+  email = null,
+  displayName = null,
+  fetchImpl,
+}) {
+  const normalizedEmail = normalizeClaworldText(email, null);
+  if (!normalizedEmail) {
+    throw createRuntimeBoundaryError({
+      code: 'tool_input_invalid',
+      category: 'input',
+      status: 400,
+      message: 'claworld email verification requires email',
+      publicMessage: 'claworld email verification requires email',
+      recoverable: true,
+      context: { field: 'email' },
+    });
+  }
+  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
+  const result = await fetchJson(fetchImpl, `${baseUrl}/v1/identity/email/start`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      ...(runtimeConfig.apiKey ? { 'x-api-key': runtimeConfig.apiKey } : {}),
+    },
+    body: JSON.stringify({
+      email: normalizedEmail,
+      ...(normalizeClaworldText(displayName, null) ? { displayName: normalizeClaworldText(displayName, null) } : {}),
+    }),
+  });
+  if (!result.ok) {
+    createRelayRouteError({
+      result,
+      runtimeConfig,
+      code: 'email_verification_start_failed',
+      publicMessage: 'failed to start Claworld email verification',
+      context: { email: normalizedEmail },
+    });
+  }
+  const payload = result.body && typeof result.body === 'object' && !Array.isArray(result.body)
+    ? { ...result.body }
+    : {};
+  delete payload.verificationId;
+  return payload;
+}
+
+async function completeEmailVerification({
+  runtimeConfig,
+  email = null,
+  code = null,
+  fetchImpl,
+}) {
+  const normalizedEmail = normalizeClaworldText(email, null);
+  const normalizedCode = normalizeClaworldText(code, null);
+  if (!normalizedEmail) {
+    throw createRuntimeBoundaryError({
+      code: 'tool_input_invalid',
+      category: 'input',
+      status: 400,
+      message: 'claworld email verification requires email',
+      publicMessage: 'claworld email verification requires email',
+      recoverable: true,
+      context: { field: 'email' },
+    });
+  }
+  if (!normalizedCode) {
+    throw createRuntimeBoundaryError({
+      code: 'tool_input_invalid',
+      category: 'input',
+      status: 400,
+      message: 'claworld email verification requires code',
+      publicMessage: 'claworld email verification requires code',
+      recoverable: true,
+      context: { field: 'code' },
+    });
+  }
+  const baseUrl = normalizeRelayHttpBaseUrl(runtimeConfig.serverUrl);
+  const result = await fetchJson(fetchImpl, `${baseUrl}/v1/identity/email/verify`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      ...(runtimeConfig.apiKey ? { 'x-api-key': runtimeConfig.apiKey } : {}),
+    },
+    body: JSON.stringify({
+      email: normalizedEmail,
+      code: normalizedCode,
+    }),
+  });
+  if (!result.ok) {
+    createRelayRouteError({
+      result,
+      runtimeConfig,
+      code: 'email_verification_complete_failed',
+      publicMessage: 'failed to complete Claworld email verification',
+      context: { email: normalizedEmail },
+    });
+  }
+  return result.body || {};
+}
+
 async function updateChatRequestApprovalPolicy({
   runtimeConfig,
   agentId = null,
@@ -1490,11 +1568,11 @@ async function updateChatRequestApprovalPolicy({
 }) {
   if (!resolveRuntimeAppToken(runtimeConfig)) {
     throw createRuntimeBoundaryError({
-      code: 'claworld_account_unactivated',
+      code: 'claworld_identity_unverified',
       category: 'conflict',
       status: 409,
-      message: 'claworld account must be activated before updating chat policy',
-      publicMessage: 'activate the Claworld account before changing chat policy',
+      message: 'claworld email verification must be completed before updating chat policy',
+      publicMessage: 'complete Claworld email verification before changing chat policy',
       recoverable: true,
     });
   }
@@ -1537,11 +1615,11 @@ async function updateGlobalProfile({
 }) {
   if (!resolveRuntimeAppToken(runtimeConfig)) {
     throw createRuntimeBoundaryError({
-      code: 'claworld_account_unactivated',
+      code: 'claworld_identity_unverified',
       category: 'conflict',
       status: 409,
-      message: 'claworld account must be activated before updating profile',
-      publicMessage: 'activate the Claworld account before updating profile',
+      message: 'claworld email verification must be completed before updating profile',
+      publicMessage: 'complete Claworld email verification before updating profile',
       recoverable: true,
     });
   }
@@ -1686,15 +1764,16 @@ async function executeRuntimeAccountAction({
   proactivitySettings = undefined,
   generateShareCard = false,
   expiresInSeconds = null,
+  shareCardVariant = null,
   fetchImpl,
 }) {
   if (!resolveRuntimeAppToken(runtimeConfig)) {
     throw createRuntimeBoundaryError({
-      code: 'claworld_account_unactivated',
+      code: 'claworld_identity_unverified',
       category: 'conflict',
       status: 409,
-      message: 'claworld account must be activated before managing account settings',
-      publicMessage: 'activate the Claworld account before changing account settings',
+      message: 'claworld email verification must be completed before managing account settings',
+      publicMessage: 'complete Claworld email verification before changing account settings',
       recoverable: true,
     });
   }
@@ -1720,6 +1799,7 @@ async function executeRuntimeAccountAction({
       ...(chatRequestApprovalPolicy ? { chatRequestApprovalPolicy } : {}),
       ...(proactivitySettings !== undefined ? { proactivitySettings } : {}),
       ...(generateShareCard === true ? { generateShareCard: true } : {}),
+      ...(normalizeClaworldText(shareCardVariant, null) ? { shareCardVariant: normalizeClaworldText(shareCardVariant, null) } : {}),
       ...(normalizeClaworldInteger(expiresInSeconds, null) > 0
         ? { expiresInSeconds: normalizeClaworldInteger(expiresInSeconds, null) }
         : {}),
@@ -3502,7 +3582,7 @@ export function createClaworldChannelPlugin({
           method: 'loadConfig_writeConfigFile',
         };
         if (!mutationOutcome.skipped) {
-          await runtime.config.writeConfigFile(nextCfg);
+          await runtime.config.writeConfigFile(nextCfg, { afterWrite: { mode: 'auto' } });
         }
       }
     } catch (error) {
@@ -3986,11 +4066,12 @@ export function createClaworldChannelPlugin({
       agentId: resolvedContext.agentId || null,
       generateShareCard: context.generateShareCard === true,
       expiresInSeconds: context.expiresInSeconds ?? null,
+      shareCardVariant: context.shareCardVariant ?? null,
       fetchImpl,
     });
   }
 
-async function updateRuntimePublicIdentity(context = {}) {
+  async function updateRuntimePublicIdentity(context = {}) {
     const configuredContext = resolveConfiguredRuntimeContext(context);
     const resolvedContext = await resolveBoundRuntimeContext(context);
     const updateResult = await updatePublicIdentity({
@@ -3999,17 +4080,18 @@ async function updateRuntimePublicIdentity(context = {}) {
       displayName: context.displayName || null,
       generateShareCard: context.generateShareCard !== false,
       expiresInSeconds: context.expiresInSeconds ?? null,
+      shareCardVariant: context.shareCardVariant ?? null,
       fetchImpl,
     });
 
-    const runtimeActivation = updateResult?.runtimeActivation && typeof updateResult.runtimeActivation === 'object'
-      ? updateResult.runtimeActivation
+    const runtimeIdentity = updateResult?.runtimeIdentity && typeof updateResult.runtimeIdentity === 'object'
+      ? updateResult.runtimeIdentity
       : null;
     const nextRuntimeConfig = updateResult?.runtimeConfig && typeof updateResult.runtimeConfig === 'object'
       ? updateResult.runtimeConfig
       : resolvedContext.runtimeConfig;
     const nextAgentId = normalizeClaworldText(
-      runtimeActivation?.agentId,
+      runtimeIdentity?.agentId,
       normalizeClaworldText(
         updateResult?.agentId,
         null,
@@ -4032,7 +4114,7 @@ async function updateRuntimePublicIdentity(context = {}) {
       nextAppToken
       && nextAgentId
       && (
-        runtimeActivation
+        runtimeIdentity
         || configuredAppToken !== nextAppToken
         || previousAgentId !== nextAgentId
       ),
@@ -4049,7 +4131,7 @@ async function updateRuntimePublicIdentity(context = {}) {
           runtimeConfig: boundRuntimeConfig,
         });
       } catch (error) {
-        logger.warn?.('[claworld:profile] failed to persist activated runtime binding', {
+        logger.warn?.('[claworld:profile] failed to persist verified runtime binding', {
           accountId: resolvedContext.accountId || boundRuntimeConfig.accountId || null,
           error: error?.message || String(error),
         });
@@ -4058,8 +4140,8 @@ async function updateRuntimePublicIdentity(context = {}) {
       rememberAccountBinding({
         runtimeConfig: boundRuntimeConfig,
         accountId: resolvedContext.accountId || boundRuntimeConfig.accountId || null,
-        bindingSource: runtimeActivation
-          ? 'activated_app_token'
+        bindingSource: runtimeIdentity
+          ? 'verified_app_token'
           : (resolvedContext.bindingSource || 'configured_app_token'),
       });
 
@@ -4082,6 +4164,158 @@ async function updateRuntimePublicIdentity(context = {}) {
   return payload;
 }
 
+async function startRuntimeEmailVerification(context = {}) {
+  const configuredContext = resolveConfiguredRuntimeContext(context);
+  return startEmailVerification({
+    runtimeConfig: configuredContext.runtimeConfig,
+    email: context.email || null,
+    displayName: context.displayName || null,
+    fetchImpl,
+  });
+}
+
+function projectRuntimeCredentialPersistence(persistence = {}) {
+  if (!persistence || typeof persistence !== 'object' || Array.isArray(persistence)) {
+    return { status: 'unknown' };
+  }
+  const skipped = persistence?.skipped === true;
+  return {
+    status: skipped ? 'best_effort' : 'saved',
+    method: normalizeClaworldText(persistence?.method, null),
+    reason: skipped ? normalizeClaworldText(persistence?.reason, null) : null,
+    backupStatus: persistence?.backup?.skipped === true
+      ? 'best_effort'
+      : (persistence?.backup?.ok === true ? 'saved' : null),
+    restartRequired: false,
+    reloadRequired: !skipped,
+    reloadMode: skipped ? null : 'openclaw_channel_hot_reload',
+  };
+}
+
+async function completeRuntimeEmailVerification(context = {}) {
+  const configuredContext = resolveConfiguredRuntimeContext(context);
+  const verification = await completeEmailVerification({
+    runtimeConfig: configuredContext.runtimeConfig,
+    email: context.email || null,
+    code: context.code || null,
+    fetchImpl,
+  });
+  const appToken = normalizeClaworldText(verification?.appToken, null);
+  const agentId = normalizeClaworldText(verification?.agentId, null);
+  if (!appToken || !agentId) {
+    throw createRuntimeBoundaryError({
+      code: 'email_verification_complete_failed',
+      category: 'runtime',
+      status: 502,
+      message: 'claworld email verification did not return appToken and agentId',
+      publicMessage: 'failed to complete Claworld email verification',
+      recoverable: true,
+    });
+  }
+
+  const boundRuntimeConfig = applyRuntimeIdentity(configuredContext.runtimeConfig, {
+    appToken,
+    agentId,
+  });
+  const accountId = configuredContext.accountId || boundRuntimeConfig.accountId || null;
+  const runtimeResolution = resolvePluginRuntimeCandidate(context.runtime || null);
+  let persistence = null;
+  try {
+    persistence = await persistRuntimeAppToken({
+      runtime: runtimeResolution.runtime,
+      accountId,
+      appToken,
+      relayAgentId: agentId,
+      runtimeConfig: boundRuntimeConfig,
+    });
+  } catch (error) {
+    persistence = {
+      skipped: true,
+      reason: 'persist_runtime_binding_failed',
+      error: error?.message || String(error),
+    };
+    logger.warn?.('[claworld:identity] failed to persist email verification runtime binding', {
+      accountId,
+      error: persistence.error,
+    });
+  }
+
+  rememberAccountBinding({
+    runtimeConfig: boundRuntimeConfig,
+    accountId,
+    bindingSource: 'email_verification',
+  });
+
+  const accountKey = resolveAccountBindingKey(boundRuntimeConfig, accountId);
+  const currentRuntimeContext = accountRuntimeContexts.get(accountKey) || null;
+  if (currentRuntimeContext) {
+    accountRuntimeContexts.set(accountKey, {
+      ...currentRuntimeContext,
+      runtimeConfig: boundRuntimeConfig,
+      deferredFailure: null,
+      deferredErrorMessage: null,
+    });
+  }
+
+  const payload = verification && typeof verification === 'object' && !Array.isArray(verification)
+    ? { ...verification }
+    : {};
+  delete payload.appToken;
+  delete payload.credential;
+  const credentialPersistence = projectRuntimeCredentialPersistence(persistence);
+  return {
+    ...payload,
+    credentialPersistence,
+    runtimeIdentity: {
+      status: 'verified',
+      agentId,
+      created: verification?.created === true,
+      recovered: verification?.recovered === true,
+      bindingSource: 'email_verification',
+    },
+    runtimeBinding: {
+      status: 'bound',
+      accountId,
+      agentId,
+      bindingSource: 'email_verification',
+      credentialPersistence,
+    },
+  };
+}
+
+async function getRuntimeIdentityStatus(context = {}) {
+  const configuredContext = resolveConfiguredRuntimeContext(context);
+  const runtimeConfig = applyRuntimeIdentity(configuredContext.runtimeConfig);
+  const agentId = normalizeClaworldText(
+    context.agentId,
+    normalizeClaworldText(runtimeConfig?.relay?.agentId, null),
+  );
+  if (!resolveRuntimeAppToken(runtimeConfig)) {
+    return { emailVerified: false, reason: 'missing_app_token' };
+  }
+  if (!agentId) {
+    return { emailVerified: false, reason: 'agent_id_required' };
+  }
+
+  const accountView = await executeRuntimeAccountAction({
+    runtimeConfig,
+    agentId,
+    action: 'view_account',
+    generateShareCard: false,
+    fetchImpl,
+  });
+  const account = accountView?.account && typeof accountView.account === 'object' && !Array.isArray(accountView.account)
+    ? accountView.account
+    : {};
+  const emailVerified = account.emailVerified === true;
+  return {
+    emailVerified,
+    email: normalizeClaworldText(account.email, null),
+    verifiedAt: normalizeClaworldText(account.verifiedAt, null),
+    reason: emailVerified ? null : 'no_email_identity',
+  };
+}
+
 async function updateRuntimeChatRequestApprovalPolicy(context = {}) {
   const resolvedContext = await resolveBoundRuntimeContext(context);
   return updateChatRequestApprovalPolicy({
@@ -4111,6 +4345,7 @@ async function generateRuntimeProfileCard(context = {}) {
     agentId: context.agentId || resolvedContext.agentId || null,
     generateShareCard: true,
     expiresInSeconds: context.expiresInSeconds ?? null,
+    shareCardVariant: context.shareCardVariant ?? null,
     fetchImpl,
   });
   return result?.shareCard || {};
@@ -4383,6 +4618,7 @@ async function generateRuntimeProfileCard(context = {}) {
             proactivitySettings: Object.prototype.hasOwnProperty.call(context, 'proactivitySettings') ? context.proactivitySettings : undefined,
             generateShareCard: context.generateShareCard === true,
             expiresInSeconds: context.expiresInSeconds ?? null,
+            shareCardVariant: context.shareCardVariant ?? null,
             fetchImpl,
           });
         },
@@ -4391,6 +4627,11 @@ async function generateRuntimeProfileCard(context = {}) {
         updateChatRequestApprovalPolicy: updateRuntimeChatRequestApprovalPolicy,
         generateShareCard: generateRuntimeProfileCard,
       },
+      identity: {
+        startEmailVerification: startRuntimeEmailVerification,
+        completeEmailVerification: completeRuntimeEmailVerification,
+        getIdentityStatus: getRuntimeIdentityStatus,
+      },
       postSetup: {
         fetchWorldDirectory: async (context = {}) => {
           const resolvedContext = await resolveBoundRuntimeContext(context);
@@ -4766,6 +5007,7 @@ async function generateRuntimeProfileCard(context = {}) {
               proactivitySettings: Object.prototype.hasOwnProperty.call(context, 'proactivitySettings') ? context.proactivitySettings : undefined,
               generateShareCard: context.generateShareCard === true,
               expiresInSeconds: context.expiresInSeconds ?? null,
+              shareCardVariant: context.shareCardVariant ?? null,
               fetchImpl,
             });
           },
@@ -4774,6 +5016,11 @@ async function generateRuntimeProfileCard(context = {}) {
           updateChatRequestApprovalPolicy: updateRuntimeChatRequestApprovalPolicy,
           generateShareCard: generateRuntimeProfileCard,
         },
+        identity: {
+          startEmailVerification: startRuntimeEmailVerification,
+          completeEmailVerification: completeRuntimeEmailVerification,
+          getIdentityStatus: getRuntimeIdentityStatus,
+        },
         fetchWorldDirectory: async (context = {}) => {
           const resolvedContext = await resolveBoundRuntimeContext(context);
           return fetchPostSetupWorldDirectory({

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

@@ -364,21 +364,33 @@ function buildManagedAccountEntry(options = {}) {
     };
   }
 
-  if (!options.defaultTargetAgentId) {
+  const relay = {
+    ...(normalizeText(options.relayAgentId, null) ? { agentId: normalizeText(options.relayAgentId, null) } : {}),
+    ...(normalizeText(options.defaultTargetAgentId, null)
+      ? { defaultTargetAgentId: normalizeText(options.defaultTargetAgentId, null) }
+      : {}),
+  };
+  if (Object.keys(relay).length === 0) {
     return base;
   }
 
   return {
     ...base,
-    relay: {
-      defaultTargetAgentId: options.defaultTargetAgentId,
-    },
+    relay,
   };
 }
 
 function buildMergedAccountEntry(existingAccount = {}, options = {}) {
   const existingRelay = ensureObject(existingAccount.relay);
   const existingRegistration = ensureObject(existingAccount.registration);
+  const relayAgentId = normalizeText(options.relayAgentId, null);
+  const defaultTargetAgentId = normalizeText(options.defaultTargetAgentId, null);
+  const mergedRelay = {
+    ...existingRelay,
+    ...(relayAgentId ? { agentId: relayAgentId } : {}),
+    ...(defaultTargetAgentId ? { defaultTargetAgentId } : {}),
+  };
+  const shouldPersistRelay = Boolean(existingAccount.relay || relayAgentId || defaultTargetAgentId);
   const merged = {
     ...existingAccount,
     enabled: true,
@@ -387,16 +399,7 @@ function buildMergedAccountEntry(existingAccount = {}, options = {}) {
     accountId: options.accountId,
     name: normalizeText(options.name, normalizeText(existingAccount.name, normalizeText(options.displayName, null))),
     routing: buildManagedRoutingEntry(options, existingAccount.routing),
-    ...(options.defaultTargetAgentId
-      ? {
-          relay: {
-            ...existingRelay,
-            defaultTargetAgentId: options.defaultTargetAgentId,
-          },
-        }
-      : existingAccount.relay
-        ? { relay: existingRelay }
-        : {}),
+    ...(shouldPersistRelay ? { relay: mergedRelay } : {}),
   };
   delete merged.toolProfile;
 
@@ -569,6 +572,7 @@ export function resolveClaworldManagedRuntimeOptions({
     registrationDisplayName,
     displayName,
     name,
+    relayAgentId: normalizeText(overrides.relayAgentId, normalizeText(existingAccount?.relay?.agentId, null)),
     defaultTargetAgentId: normalizeText(overrides.defaultTargetAgentId, null),
     sessionDmScope: normalizeText(
       overrides.sessionDmScope,