@xfxstudio/claworld 0.2.12 → 0.2.14

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

@@ -1,37 +0,0 @@
-import { authenticateAppTokenRequest } from '../../lib/http-auth.js';
-
-function sendOnboardingError(res, error) {
-  const status = Number.isInteger(error?.status) ? error.status : 500;
-  if (error?.responseBody && typeof error.responseBody === 'object') {
-    return res.status(status).json(error.responseBody);
-  }
-  const code = typeof error?.code === 'string' ? error.code : 'internal_error';
-  return res.status(status).json({ error: code, message: error?.message || code });
-}
-
-export function registerOnboardingRoutes(app, { onboardingService, store = null }) {
-  app.get('/v1/meta/install', (_req, res) => {
-    res.json(onboardingService.getInstallManifest());
-  });
-
-  app.get('/v1/onboarding/plan', (req, res) => {
-    res.json(onboardingService.getFirstRunPlan({ worldId: req.query.worldId }));
-  });
-
-  app.post('/v1/onboarding/activate', (req, res) => {
-    const auth = authenticateAppTokenRequest({ store, req });
-    if (auth.present && !auth.ok) {
-      return res.status(401).json(auth.error);
-    }
-
-    try {
-      const result = onboardingService.activateInstallation({
-        auth,
-        input: req.body || {},
-      });
-      return res.status(result.created ? 201 : 200).json(result);
-    } catch (error) {
-      return sendOnboardingError(res, error);
-    }
-  });
-}

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

@@ -1,220 +0,0 @@
-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';
-
-function normalizeText(value, fallback = null) {
-  if (value == null) return fallback;
-  const normalized = String(value).trim();
-  return normalized || fallback;
-}
-
-function projectRecommendedWorld(world = {}) {
-  return {
-    worldId: world.worldId,
-    displayName: world.displayName,
-    summary: world.summary,
-    category: world.category,
-  };
-}
-
-function createConfigurationError() {
-  const error = new Error('onboarding_store_unavailable');
-  error.code = 'onboarding_store_unavailable';
-  error.status = 500;
-  error.responseBody = {
-    error: error.code,
-    message: 'onboarding activation requires a configured metadata store',
-  };
-  return error;
-}
-
-function createInvalidActivationRequestError(fieldId, message) {
-  const error = new Error(`invalid_onboarding_activation:${fieldId}`);
-  error.code = 'invalid_onboarding_activation';
-  error.status = 400;
-  error.responseBody = {
-    error: error.code,
-    message: 'dialog-first onboarding activation only accepts backend-issued identity flow inputs',
-    fieldErrors: [
-      {
-        fieldId,
-        message,
-      },
-    ],
-  };
-  return error;
-}
-
-function createActivatedResponse({ agent, appToken, created, bindingSource }) {
-  return {
-    status: 'activated',
-    created: created === true,
-    bindingSource: normalizeText(bindingSource, null),
-    agentId: normalizeText(agent?.agentId, null),
-    appToken: normalizeText(appToken, null),
-  };
-}
-
-function validateActivationInput(input = {}) {
-  const normalizedInput = input && typeof input === 'object' && !Array.isArray(input) ? input : {};
-  const blockedFields = [
-    ['agentId', 'dialog-first activation must not receive a user-provided agentId'],
-    ['code', 'dialog-first activation must not receive a user-provided code'],
-    ['appToken', 'dialog-first activation must not receive a user-provided appToken in the request body'],
-  ];
-
-  for (const [fieldId, message] of blockedFields) {
-    if (normalizeText(normalizedInput[fieldId], null)) {
-      throw createInvalidActivationRequestError(fieldId, message);
-    }
-  }
-
-  return {
-    displayName: normalizeText(normalizedInput.displayName, DEFAULT_ACTIVATION_DISPLAY_NAME),
-  };
-}
-
-function createActivatedAgent({ store, displayName }) {
-  return store.createAgent({
-    displayName,
-    publicIdentity: {
-      displayName,
-      status: 'pending',
-    },
-  });
-}
-
-export function createOnboardingService({ worldService, store = null } = {}) {
-  function assertStore() {
-    if (!store) throw createConfigurationError();
-    return store;
-  }
-
-  return {
-    getInstallManifest() {
-      const recommendedWorlds = worldService.listWorlds().slice(0, 3).map((world) => projectRecommendedWorld(world));
-      return {
-        product: 'claworld',
-        mode: 'agent_install',
-        installer: {
-          command: CLAWORLD_INSTALLER_COMMAND,
-          packageName: CLAWORLD_INSTALLER_PACKAGE_NAME,
-          minHostVersion: CLAWORLD_OPENCLAW_MIN_HOST_VERSION,
-          canonicalFlow: 'installer_first',
-          lifecycle: {
-            install: CLAWORLD_INSTALLER_COMMAND,
-            doctor: CLAWORLD_DOCTOR_COMMAND,
-            update: CLAWORLD_UPDATE_COMMAND,
-            uninstall: CLAWORLD_UNINSTALL_COMMAND,
-          },
-        },
-        plugin: {
-          pluginId: DEFAULT_INSTALL_CHANNEL_ID,
-          packageName: CLAWORLD_INSTALLER_PACKAGE_NAME,
-          installMode: 'npm',
-          minHostVersion: CLAWORLD_OPENCLAW_MIN_HOST_VERSION,
-        },
-        setup: {
-          channelId: DEFAULT_INSTALL_CHANNEL_ID,
-          defaultAccountId: DEFAULT_INSTALL_ACCOUNT_ID,
-          defaultLocalAgentId: DEFAULT_INSTALL_LOCAL_AGENT_ID,
-          configPath: 'channels.claworld.accounts.<accountId>',
-          credentialField: 'appToken',
-          managedBy: 'host_agent_or_openclaw_runtime',
-          userInput: {
-            requiresCode: false,
-            requiresAgentId: false,
-            requiresToken: false,
-          },
-        },
-        compatibility: {
-          nativeOpenclaw: {
-            status: 'compatibility_only',
-            commands: [
-              'openclaw onboard',
-              'openclaw channels add claworld --app-token <token>',
-            ],
-          },
-        },
-        activation: {
-          endpoint: '/v1/onboarding/activate',
-          method: 'POST',
-          requiresUserCode: false,
-          canonicalIdentityField: 'agentId',
-          credentialField: 'appToken',
-          responseFields: ['status', 'agentId', 'appToken'],
-        },
-        verification: {
-          statusRoute: '/plugins/claworld/status',
-          pairTool: 'claworld_pair_agent',
-          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_profile with action=update_identity',
-          'claworld_profile(action=update_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`,
-        ],
-        recommendedWorlds,
-        status: 'ready',
-      };
-    },
-    getFirstRunPlan({ worldId = null } = {}) {
-      const preferredWorld = worldId ? worldService.getWorld(worldId) : null;
-      const fallbackWorld = worldService.getWorld('dating-demo-world');
-      const selectedWorld = preferredWorld || fallbackWorld || worldService.getWorld(worldService.listWorldIds()[0]);
-
-      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_profile with action=update_identity',
-          'claworld_profile(action=update_identity) activates the backend binding when needed and persists the returned appToken',
-          'collect required world profile fields',
-          'validate world membership eligibility',
-          'start the first A2A loop or deliver world content',
-        ],
-        status: 'ready',
-      };
-    },
-    activateInstallation({ auth = null, input = {} } = {}) {
-      const activationInput = validateActivationInput(input);
-      assertStore();
-
-      if (auth?.ok) {
-        return createActivatedResponse({
-          agent: auth.agent,
-          appToken: auth.token,
-          created: false,
-          bindingSource: 'provided_app_token',
-        });
-      }
-
-      const createdAgent = createActivatedAgent({
-        store,
-        displayName: activationInput.displayName,
-      });
-      return createActivatedResponse({
-        agent: createdAgent,
-        appToken: createdAgent.bootstrapCredential?.token || null,
-        created: true,
-        bindingSource: 'created_agent_app_token',
-      });
-    },
-  };
-}

package/src/product-shell/orchestration/world-conversation-orchestrator.js

@@ -1,28 +0,0 @@
-import { createSystemMessageOrchestrator } from './world-conversation-text.js';
-
-export function createWorldConversationOrchestrator({
-  worldService,
-  systemMessages = createSystemMessageOrchestrator(),
-} = {}) {
-  return {
-    previewConversation({ worldId, conversationKey = 'cnv_preview' } = {}) {
-      const world = worldService.requireWorld(worldId);
-      const openingPlan = systemMessages.planMessages({
-        conversationId: conversationKey,
-        trigger: 'conversation_started',
-        worldRules: world.conversationTemplate.worldRules,
-      });
-      const convergencePlan = [];
-
-      return {
-        worldId: world.worldId,
-        conversationTemplate: {
-          mode: world.conversationTemplate.mode,
-        },
-        openingPlan,
-        convergencePlan,
-        status: 'preview_ready',
-      };
-    },
-  };
-}

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

@@ -1,142 +0,0 @@
-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,160 +0,0 @@
-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') {
-    return res.status(status).json(error.responseBody);
-  }
-  const code = typeof error?.code === 'string' ? error.code : 'internal_error';
-  return res.status(status).json({ error: code, message: error?.message || code });
-}
-
-function sendMissingAgentIdentity(res) {
-  return res.status(401).json({
-    error: 'not_authenticated',
-    reason: 'agent_identity_required',
-  });
-}
-
-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,
-      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 = publicIdentityService.getPublicIdentityStatus({
-        agentId: authAgent.agentId,
-      });
-      return res.json(result);
-    } catch (error) {
-      return sendProfileError(res, error);
-    }
-  });
-
-  app.put('/v1/profile/public-identity', 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 result = await publicIdentityService.updatePublicIdentity({
-        agentId: authAgent.agentId,
-        displayName: req.body?.displayName,
-      });
-      return res.json(result);
-    } catch (error) {
-      return sendProfileError(res, error);
-    }
-  });
-}