@xfxstudio/claworld 0.2.11 → 0.2.13

package/src/product-shell/onboarding/onboarding-service.js

@@ -1,16 +1,16 @@
 import {
-  CLAWORLD_DOCTOR_COMMAND,
-  CLAWORLD_INSTALLER_COMMAND,
   CLAWORLD_INSTALLER_PACKAGE_NAME,
   CLAWORLD_OPENCLAW_MIN_HOST_VERSION,
-  CLAWORLD_UNINSTALL_COMMAND,
-  CLAWORLD_UPDATE_COMMAND,
 } from '../../openclaw/installer/constants.js';
 
 const DEFAULT_INSTALL_CHANNEL_ID = 'claworld';
 const DEFAULT_INSTALL_ACCOUNT_ID = 'claworld';
 const DEFAULT_INSTALL_LOCAL_AGENT_ID = 'main';
 const DEFAULT_ACTIVATION_DISPLAY_NAME = 'Claworld Agent';
+const CLAWORLD_HOST_NATIVE_INSTALL_COMMAND = `openclaw plugins install ${CLAWORLD_INSTALLER_PACKAGE_NAME}`;
+const CLAWORLD_HOST_NATIVE_SETUP_COMMAND = 'openclaw channels add --channel claworld';
+const CLAWORLD_HOST_NATIVE_ONBOARD_COMMAND = 'openclaw onboard';
+const CLAWORLD_HOST_NATIVE_INSPECT_COMMAND = 'openclaw plugins info claworld';
 
 function normalizeText(value, fallback = null) {
   if (value == null) return fallback;
@@ -107,15 +107,15 @@ export function createOnboardingService({ worldService, store = null } = {}) {
         product: 'claworld',
         mode: 'agent_install',
         installer: {
-          command: CLAWORLD_INSTALLER_COMMAND,
+          command: CLAWORLD_HOST_NATIVE_INSTALL_COMMAND,
           packageName: CLAWORLD_INSTALLER_PACKAGE_NAME,
           minHostVersion: CLAWORLD_OPENCLAW_MIN_HOST_VERSION,
-          canonicalFlow: 'installer_first',
+          canonicalFlow: 'host_native_setup',
           lifecycle: {
-            install: CLAWORLD_INSTALLER_COMMAND,
-            doctor: CLAWORLD_DOCTOR_COMMAND,
-            update: CLAWORLD_UPDATE_COMMAND,
-            uninstall: CLAWORLD_UNINSTALL_COMMAND,
+            install: CLAWORLD_HOST_NATIVE_INSTALL_COMMAND,
+            configure: CLAWORLD_HOST_NATIVE_SETUP_COMMAND,
+            onboard: CLAWORLD_HOST_NATIVE_ONBOARD_COMMAND,
+            inspect: CLAWORLD_HOST_NATIVE_INSPECT_COMMAND,
           },
         },
         plugin: {
@@ -139,10 +139,11 @@ export function createOnboardingService({ worldService, store = null } = {}) {
         },
         compatibility: {
           nativeOpenclaw: {
-            status: 'compatibility_only',
+            status: 'preferred',
             commands: [
-              'openclaw onboard',
-              'openclaw channels add claworld --app-token <token>',
+              CLAWORLD_HOST_NATIVE_INSTALL_COMMAND,
+              CLAWORLD_HOST_NATIVE_SETUP_COMMAND,
+              CLAWORLD_HOST_NATIVE_ONBOARD_COMMAND,
             ],
           },
         },
@@ -160,14 +161,14 @@ export function createOnboardingService({ worldService, store = null } = {}) {
           expectedBinding: 'runtime_bound_by_app_token',
         },
         steps: [
-          `run ${CLAWORLD_INSTALLER_COMMAND}`,
-          'installer validates OpenClaw availability and minimum host version',
-          'installer verifies or installs the claworld OpenClaw plugin package',
-          'installer writes or refreshes the managed claworld channel config and binds it to the local main agent by default',
-          'installer reloads or starts the runtime and verifies the managed channel shape without requiring backend activation',
-          'first-run readiness goes through claworld_pair_agent and then claworld_update_public_identity',
-          'claworld_update_public_identity performs activation when needed and completes the public displayName#code identity',
-          `ongoing lifecycle uses ${CLAWORLD_UPDATE_COMMAND} for tracked package updates plus managed repair, then ${CLAWORLD_DOCTOR_COMMAND} for health confirmation`,
+          `run ${CLAWORLD_HOST_NATIVE_INSTALL_COMMAND}`,
+          `configure one account with ${CLAWORLD_HOST_NATIVE_SETUP_COMMAND} or ${CLAWORLD_HOST_NATIVE_ONBOARD_COMMAND}`,
+          'host-native setup writes or refreshes the claworld channel config and binding without requiring backend activation',
+          `inspect plugin install state with ${CLAWORLD_HOST_NATIVE_INSPECT_COMMAND} when setup needs verification`,
+          'ask once for the desired public display name after setup completes',
+          'claworld_profile(action=update_identity) performs activation when needed, persists the returned appToken, and completes the public displayName#code identity',
+          'use claworld_pair_agent when runtime readiness still looks unhealthy after setup or initialization',
+          'ongoing package updates and removal stay on the OpenClaw host plugin lifecycle instead of a plugin-owned installer CLI',
         ],
         recommendedWorlds,
         status: 'ready',
@@ -181,10 +182,11 @@ export function createOnboardingService({ worldService, store = null } = {}) {
       return {
         selectedWorld: selectedWorld ? { worldId: selectedWorld.worldId, displayName: selectedWorld.displayName } : null,
         actions: [
-          'install the claworld plugin and write the managed config shape',
-          'run claworld_pair_agent to confirm readiness after install',
-          'if public identity is pending, call claworld_update_public_identity',
-          'claworld_update_public_identity activates the backend binding when needed and persists the returned appToken',
+          'install the claworld plugin through the OpenClaw host',
+          'configure the claworld channel account and local binding through host-native setup',
+          'ask once for the desired public display name',
+          'call claworld_profile with action=update_identity to finish activation and public naming',
+          'use claworld_pair_agent only when the runtime still needs diagnosis after setup or initialization',
           'collect required world profile fields',
           'validate world membership eligibility',
           'start the first A2A loop or deliver world content',

package/src/product-shell/profile/profile-service.js

@@ -0,0 +1,142 @@
+function normalizeBoolean(value, fallback = false) {
+  if (typeof value === 'boolean') return value;
+  return fallback;
+}
+
+function normalizePositiveInteger(value, fallback = null) {
+  const normalized = Number(value);
+  if (!Number.isFinite(normalized) || normalized <= 0) return fallback;
+  return Math.floor(normalized);
+}
+
+async function maybeGenerateShareCard({
+  agentCardService,
+  agentId,
+  identityStatus,
+  generateShareCard = false,
+  expiresInSeconds = null,
+  forceRegenerate = true,
+}) {
+  if (!generateShareCard) return undefined;
+  if (identityStatus?.ready !== true) {
+    return {
+      status: 'unavailable',
+      reason: 'public_identity_not_ready',
+    };
+  }
+
+  try {
+    return await agentCardService.renderCard({
+      agentId,
+      expiresInSeconds: normalizePositiveInteger(expiresInSeconds, null),
+      forceRegenerate: normalizeBoolean(forceRegenerate, true),
+    });
+  } catch (error) {
+    return {
+      status: 'unavailable',
+      reason: 'generation_failed',
+      message: error?.publicMessage || error?.message || 'share card generation failed',
+    };
+  }
+}
+
+export function createProfileService({
+  publicIdentityService,
+  agentCardService,
+} = {}) {
+  if (!publicIdentityService) {
+    throw new Error('profile_service_requires_public_identity_service');
+  }
+  if (!agentCardService) {
+    throw new Error('profile_service_requires_agent_card_service');
+  }
+
+  return {
+    getPublicIdentityStatus(input = {}) {
+      return publicIdentityService.getPublicIdentityStatus(input);
+    },
+
+    updatePublicIdentity(input = {}) {
+      return publicIdentityService.updatePublicIdentity(input);
+    },
+
+    assertPublicIdentityReady(input = {}) {
+      return publicIdentityService.assertPublicIdentityReady(input);
+    },
+
+    async getProfile({
+      agentId,
+      generateShareCard = false,
+      expiresInSeconds = null,
+      forceRegenerate = true,
+    } = {}) {
+      const identityStatus = publicIdentityService.getPublicIdentityStatus({ agentId });
+      const shareCard = await maybeGenerateShareCard({
+        agentCardService,
+        agentId,
+        identityStatus,
+        generateShareCard,
+        expiresInSeconds,
+        forceRegenerate,
+      });
+      return shareCard === undefined
+        ? identityStatus
+        : {
+            ...identityStatus,
+            shareCard,
+          };
+    },
+
+    async updateProfileIdentity({
+      agentId,
+      displayName,
+      generateShareCard = true,
+      expiresInSeconds = null,
+      forceRegenerate = true,
+    } = {}) {
+      const identityStatus = await publicIdentityService.updatePublicIdentity({
+        agentId,
+        displayName,
+      });
+      const shareCard = await maybeGenerateShareCard({
+        agentCardService,
+        agentId,
+        identityStatus,
+        generateShareCard,
+        expiresInSeconds,
+        forceRegenerate,
+      });
+      return shareCard === undefined
+        ? identityStatus
+        : {
+            ...identityStatus,
+            shareCard,
+          };
+    },
+
+    async executeProfileAction({
+      action = 'view',
+      agentId,
+      displayName = null,
+      generateShareCard = false,
+      expiresInSeconds = null,
+      forceRegenerate = true,
+    } = {}) {
+      if (action === 'update_identity') {
+        return this.updateProfileIdentity({
+          agentId,
+          displayName,
+          generateShareCard,
+          expiresInSeconds,
+          forceRegenerate,
+        });
+      }
+      return this.getProfile({
+        agentId,
+        generateShareCard,
+        expiresInSeconds,
+        forceRegenerate,
+      });
+    },
+  };
+}

package/src/product-shell/profile/public-identity-routes.js

@@ -1,5 +1,45 @@
 import { resolveAuthenticatedAgentId } from '../../lib/http-auth.js';
 
+function normalizeBoolean(value, fallback = false) {
+  if (typeof value === 'boolean') return value;
+  if (typeof value === 'string') {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'true') return true;
+    if (normalized === 'false') return false;
+  }
+  return fallback;
+}
+
+function normalizePositiveInteger(value, fallback = null) {
+  const normalized = Number(value);
+  if (!Number.isFinite(normalized) || normalized <= 0) return fallback;
+  return Math.floor(normalized);
+}
+
+function buildAbsoluteUrl(req, publicPath) {
+  return `${req.protocol}://${req.get('host')}${publicPath}`;
+}
+
+function normalizeShareCard(req, shareCard = undefined) {
+  if (shareCard === undefined) return undefined;
+  if (!shareCard || typeof shareCard !== 'object') return shareCard;
+
+  const card = shareCard.card && typeof shareCard.card === 'object' ? shareCard.card : null;
+  if (!card) return shareCard;
+
+  const imageUrl = card.imageUrl || (card.publicPath ? buildAbsoluteUrl(req, card.publicPath) : null);
+  const downloadUrl = card.downloadUrl || imageUrl;
+  if (!imageUrl && !downloadUrl) return shareCard;
+  return {
+    ...shareCard,
+    card: {
+      ...card,
+      ...(imageUrl ? { imageUrl } : {}),
+      ...(downloadUrl ? { downloadUrl } : {}),
+    },
+  };
+}
+
 function sendProfileError(res, error) {
   const status = Number.isInteger(error?.status) ? error.status : 500;
   if (error?.responseBody && typeof error.responseBody === 'object') {
@@ -17,6 +57,66 @@ function sendMissingAgentIdentity(res) {
 }
 
 export function registerPublicIdentityRoutes(app, { publicIdentityService, store }) {
+  app.get('/v1/profile', async (req, res) => {
+    const authAgent = resolveAuthenticatedAgentId({
+      store,
+      req,
+      providedAgentId: req.query.agentId,
+      fieldName: 'agentId',
+    });
+    if (!authAgent.ok) return res.status(authAgent.status).json(authAgent.body);
+    if (!authAgent.agentId) return sendMissingAgentIdentity(res);
+
+    try {
+      const result = await publicIdentityService.getProfile({
+        agentId: authAgent.agentId,
+        generateShareCard: normalizeBoolean(req.query.generateShareCard, false),
+        expiresInSeconds: normalizePositiveInteger(req.query.expiresInSeconds, null),
+        forceRegenerate: normalizeBoolean(req.query.forceRegenerate, true),
+      });
+      return res.json({
+        ...result,
+        ...(Object.prototype.hasOwnProperty.call(result, 'shareCard')
+          ? { shareCard: normalizeShareCard(req, result.shareCard) }
+          : {}),
+      });
+    } catch (error) {
+      return sendProfileError(res, error);
+    }
+  });
+
+  app.post('/v1/profile', async (req, res) => {
+    const authAgent = resolveAuthenticatedAgentId({
+      store,
+      req,
+      providedAgentId: req.body?.agentId,
+      fieldName: 'agentId',
+    });
+    if (!authAgent.ok) return res.status(authAgent.status).json(authAgent.body);
+    if (!authAgent.agentId) return sendMissingAgentIdentity(res);
+
+    try {
+      const action = String(req.body?.action || '').trim() || (req.body?.displayName ? 'update_identity' : 'view');
+      const result = await publicIdentityService.executeProfileAction({
+        action,
+        agentId: authAgent.agentId,
+        displayName: req.body?.displayName,
+        generateShareCard: normalizeBoolean(req.body?.generateShareCard, action === 'update_identity'),
+        expiresInSeconds: normalizePositiveInteger(req.body?.expiresInSeconds, null),
+        forceRegenerate: normalizeBoolean(req.body?.forceRegenerate, true),
+      });
+      return res.json({
+        action,
+        ...result,
+        ...(Object.prototype.hasOwnProperty.call(result, 'shareCard')
+          ? { shareCard: normalizeShareCard(req, result.shareCard) }
+          : {}),
+      });
+    } catch (error) {
+      return sendProfileError(res, error);
+    }
+  });
+
   app.get('/v1/profile/public-identity', (req, res) => {
     const authAgent = resolveAuthenticatedAgentId({
       store,

package/src/product-shell/profile/public-identity-service.js

@@ -49,9 +49,11 @@ function createInvalidPublicIdentityRequest(fieldId, message, code = 'invalid_pu
   return error;
 }
 
+const DEFAULT_PUBLIC_IDENTITY_NEXT_TOOL = 'claworld_profile';
+
 function createPublicIdentityIncompleteError(agent, {
   capability = null,
-  nextTool = 'claworld_update_public_identity',
+  nextTool = DEFAULT_PUBLIC_IDENTITY_NEXT_TOOL,
 } = {}) {
   const projected = projectPublicIdentityStatus(agent, { nextTool });
   const capabilityLabel = normalizeText(capability, 'this Claworld capability');
@@ -73,7 +75,7 @@ function createPublicIdentityIncompleteError(agent, {
 }
 
 function projectPublicIdentityStatus(agent, {
-  nextTool = 'claworld_update_public_identity',
+  nextTool = DEFAULT_PUBLIC_IDENTITY_NEXT_TOOL,
   conversationFeedbackService = null,
 } = {}) {
   const publicIdentity = resolvePublicIdentity(agent);

package/bin/claworld.mjs

@@ -1,9 +0,0 @@
-#!/usr/bin/env node
-
-import { runInstallerCli } from '../src/openclaw/installer/cli.js';
-
-runInstallerCli().catch((error) => {
-  console.error('Claworld CLI failed');
-  console.error(error.message || error);
-  process.exit(1);
-});