@xfxstudio/claworld 0.2.19 → 0.2.21

package/openclaw.plugin.json

@@ -8,7 +8,7 @@
   ],
   "name": "Claworld Persona Relay",
   "description": "Claworld relay world channel plugin for OpenClaw.",
-  "version": "0.2.19",
+  "version": "0.2.21",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xfxstudio/claworld",
-  "version": "0.2.19",
+  "version": "0.2.21",
   "description": "Claworld channel plugin for OpenClaw",
   "type": "module",
   "main": "index.js",

package/src/openclaw/plugin/register-tooling.js

@@ -29,6 +29,82 @@ export function normalizeObject(value, fallback = null) {
   return value;
 }
 
+function resolveRuntimeAppToken(runtimeConfig = {}) {
+  return normalizeText(
+    runtimeConfig?.appToken,
+    normalizeText(
+      runtimeConfig?.relay?.appToken,
+      normalizeText(runtimeConfig?.relay?.credentialToken, null),
+    ),
+  );
+}
+
+async function buildPendingPublicIdentityError({
+  plugin,
+  cfg,
+  accountId,
+  runtimeConfig,
+  agentId = null,
+  capability,
+} = {}) {
+  const getPublicIdentity = plugin?.runtime?.productShell?.profile?.getPublicIdentity;
+  const capabilityLabel = normalizeText(capability, 'this Claworld capability');
+  const fallbackMessage = `${capabilityLabel} requires a public Claworld identity`;
+  if (typeof getPublicIdentity !== 'function') {
+    return createRuntimeBoundaryError({
+      code: 'public_identity_incomplete',
+      category: 'conflict',
+      status: 409,
+      message: fallbackMessage,
+      publicMessage: fallbackMessage,
+      recoverable: true,
+      context: {
+        accountId: normalizeText(accountId, null),
+        agentId: normalizeText(agentId, null),
+        httpStatus: 409,
+        backendCode: 'public_identity_incomplete',
+        backendMessage: fallbackMessage,
+        requiredAction: 'set_public_identity',
+        nextAction: 'set_public_identity',
+        nextTool: 'claworld_account',
+      },
+    });
+  }
+
+  const identityPayload = await getPublicIdentity({
+    cfg,
+    accountId,
+    runtimeConfig,
+    agentId: normalizeText(agentId, null),
+    generateShareCard: false,
+    expiresInSeconds: null,
+  });
+  const publicMessage = normalizeText(identityPayload?.message, fallbackMessage);
+  return createRuntimeBoundaryError({
+    code: 'public_identity_incomplete',
+    category: 'conflict',
+    status: 409,
+    message: publicMessage,
+    publicMessage,
+    recoverable: true,
+    context: {
+      accountId: normalizeText(accountId, null),
+      agentId: normalizeText(
+        agentId,
+        normalizeText(identityPayload?.agentId, null),
+      ),
+      httpStatus: 409,
+      backendCode: 'public_identity_incomplete',
+      backendMessage: publicMessage,
+      requiredAction: normalizeText(identityPayload?.requiredAction, 'set_public_identity'),
+      nextAction: normalizeText(identityPayload?.nextAction, 'set_public_identity'),
+      nextTool: normalizeText(identityPayload?.nextTool, 'claworld_account'),
+      missingFields: Array.isArray(identityPayload?.missingFields) ? identityPayload.missingFields : [],
+      publicIdentity: normalizeObject(identityPayload?.publicIdentity, null),
+    },
+  });
+}
+
 function normalizePublicFieldError(fieldError = {}) {
   const fieldId = normalizeText(fieldError.fieldId, null);
   const message = normalizeText(fieldError.message, null);
@@ -142,22 +218,60 @@ export function withToolErrorBoundary(toolName, execute) {
   };
 }
 
-export async function resolveToolContext(api, plugin, params = {}, { bindRuntime = true } = {}) {
+export async function resolveToolContext(
+  api,
+  plugin,
+  params = {},
+  {
+    bindRuntime = true,
+    requiredPublicIdentityCapability = null,
+  } = {},
+) {
   const cfg = await loadCurrentConfig(api);
   const accountId = normalizeText(params.accountId, plugin.config.defaultAccountId(cfg) || null);
   const runtimeConfig = plugin.config.resolveRuntimeConfig(cfg, accountId);
 
   if (bindRuntime && typeof plugin.helpers?.resolveToolRuntimeContext === 'function') {
-    return await plugin.helpers.resolveToolRuntimeContext({
+    const resolvedContext = await plugin.helpers.resolveToolRuntimeContext({
       cfg,
       accountId,
       runtimeConfig,
       agentId: normalizeText(params.agentId, runtimeConfig.relay?.agentId || null),
       requesterSessionKey: normalizeText(params[INTERNAL_REQUESTER_SESSION_KEY_PARAM], null),
     });
+    if (
+      requiredPublicIdentityCapability
+      && (
+        !normalizeText(resolvedContext?.agentId, null)
+        || !resolveRuntimeAppToken(resolvedContext?.runtimeConfig || runtimeConfig)
+      )
+    ) {
+      throw await buildPendingPublicIdentityError({
+        plugin,
+        cfg,
+        accountId: resolvedContext?.accountId || accountId,
+        runtimeConfig: resolvedContext?.runtimeConfig || runtimeConfig,
+        agentId: resolvedContext?.agentId || null,
+        capability: requiredPublicIdentityCapability,
+      });
+    }
+    return resolvedContext;
   }
 
   const agentId = normalizeText(params.agentId, runtimeConfig.relay?.agentId || null);
+  if (
+    requiredPublicIdentityCapability
+    && (!agentId || !resolveRuntimeAppToken(runtimeConfig))
+  ) {
+    throw await buildPendingPublicIdentityError({
+      plugin,
+      cfg,
+      accountId,
+      runtimeConfig,
+      agentId,
+      capability: requiredPublicIdentityCapability,
+    });
+  }
   return {
     cfg,
     accountId,

package/src/openclaw/plugin/register.js

@@ -275,7 +275,9 @@ function buildRegisteredTools(api, plugin) {
         ],
       }),
       async execute(_toolCallId, params = {}) {
-        const context = await resolveToolContext(api, plugin, params);
+        const context = await resolveToolContext(api, plugin, params, {
+          requiredPublicIdentityCapability: 'join world',
+        });
         const payload = await plugin.runtime.productShell.joinWorld({
           ...context,
           worldId: params.worldId,
@@ -338,7 +340,9 @@ function buildRegisteredTools(api, plugin) {
         ],
       }),
       async execute(_toolCallId, params = {}) {
-        const context = await resolveToolContext(api, plugin, params);
+        const context = await resolveToolContext(api, plugin, params, {
+          requiredPublicIdentityCapability: 'create world',
+        });
         const payload = await plugin.runtime.productShell.moderation.createWorld({
           ...context,
           displayName: params.displayName,
@@ -421,7 +425,9 @@ function buildRegisteredTools(api, plugin) {
         ],
       }),
       async execute(_toolCallId, params = {}) {
-        const context = await resolveToolContext(api, plugin, params);
+        const context = await resolveToolContext(api, plugin, params, {
+          requiredPublicIdentityCapability: 'manage worlds',
+        });
         if (Object.prototype.hasOwnProperty.call(params, 'action')
           && !normalizeManageWorldAction(params.action, null)) {
           requireManageWorldField('action', 'action must be one of list, get, update_context, pause, close, or resume');
@@ -560,7 +566,9 @@ function buildRegisteredTools(api, plugin) {
         ],
       }),
       async execute(_toolCallId, params = {}) {
-        const context = await resolveToolContext(api, plugin, params);
+        const context = await resolveToolContext(api, plugin, params, {
+          requiredPublicIdentityCapability: 'request chat',
+        });
         const payload = await plugin.helpers.social.requestChat({
           ...context,
           displayName: params.displayName,
@@ -1014,12 +1022,20 @@ function buildRegisteredTools(api, plugin) {
         });
         const pairedAgentId = identityPayload?.agentId || runtimeConfig.relay?.agentId || null;
         const relayAgent = pairedAgentId
-          ? await plugin.helpers.pairing.resolveAgentIdentity({
-            cfg,
-            accountId,
-            runtimeConfig,
+          ? {
             agentId: pairedAgentId,
-          })
+            displayName: normalizeText(
+              identityPayload?.publicIdentity?.displayName,
+              normalizeText(
+                identityPayload?.recommendedDisplayName,
+                normalizeText(runtimeConfig?.name, normalizeText(runtimeConfig?.registration?.displayName, null)),
+              ),
+            ),
+            discoverable: null,
+            contactable: null,
+            online: null,
+            resolved: null,
+          }
           : null;
         const hasConfiguredAppToken = Boolean(
           runtimeConfig.appToken

package/src/openclaw/plugin/relay-client.js

@@ -459,7 +459,7 @@ export class ClaworldRelayClient extends EventEmitter {
     config,
     agentId,
     credential = null,
-    clientVersion = 'claworld-plugin/0.2.19',
+    clientVersion = 'claworld-plugin/0.2.21',
     sessionTarget,
     fallbackTarget,
   } = {}) {

package/src/openclaw/runtime/world-moderation-helper.js

@@ -249,12 +249,14 @@ export async function fetchOwnedWorlds({
   });
 
   if (!result.ok) {
-      logger.error?.('[claworld:moderation] managed worlds fetch failed', {
-        status: result.status,
-        accountId: resolvedRuntimeConfig.accountId || accountId || null,
-        body: result.body,
-      });
-    throw new Error(`claworld managed worlds fetch failed: ${result.status}`);
+    logger.error?.('[claworld:moderation] managed worlds fetch failed', {
+      status: result.status,
+      accountId: resolvedRuntimeConfig.accountId || accountId || null,
+      body: result.body,
+    });
+    throw createModerationHttpError('list', result, {
+      accountId: resolvedRuntimeConfig.accountId || accountId || null,
+    });
   }
 
   return {
@@ -308,7 +310,10 @@ export async function manageModeratedWorld({
         accountId: resolvedRuntimeConfig.accountId || accountId || null,
         body: result.body,
       });
-      throw new Error(`claworld managed world fetch failed: ${result.status}`);
+      throw createModerationHttpError('get', result, {
+        accountId: resolvedRuntimeConfig.accountId || accountId || null,
+        worldId: resolvedWorldId,
+      });
     }
 
     return normalizeManagedWorld(result.body);
@@ -336,7 +341,10 @@ export async function manageModeratedWorld({
       accountId: resolvedRuntimeConfig.accountId || accountId || null,
       body: result.body,
     });
-    throw new Error(`claworld managed world update failed: ${result.status}`);
+    throw createModerationHttpError('update', result, {
+      accountId: resolvedRuntimeConfig.accountId || accountId || null,
+      worldId: resolvedWorldId,
+    });
   }
 
   return normalizeManagedWorld(result.body);