@xfxstudio/claworld 0.2.8 → 0.2.10-beta.0

package/src/product-shell/index.js

@@ -6,6 +6,8 @@ import { createWorldBroadcastService } from './worlds/world-broadcast-service.js
 import { DEFAULT_WORLD_MANIFESTS } from './catalog/default-world-catalog.js';
 import { createOnboardingService } from './onboarding/onboarding-service.js';
 import { registerOnboardingRoutes } from './onboarding/onboarding-routes.js';
+import { createPublicIdentityService } from './profile/public-identity-service.js';
+import { registerPublicIdentityRoutes } from './profile/public-identity-routes.js';
 import { createMembershipService } from './membership/membership-service.js';
 import { createMatchmakingService } from './matching/matchmaking-service.js';
 import { createWorldSearchService } from './search/search-service.js';
@@ -18,6 +20,7 @@ import { createChatRequestService } from './social/chat-request-service.js';
 import { registerChatRequestRoutes } from './social/chat-request-routes.js';
 import { createFeedbackService } from './feedback/feedback-service.js';
 import { registerFeedbackRoutes } from './feedback/feedback-routes.js';
+import { createConversationFeedbackService } from './conversation-feedback/conversation-feedback-service.js';
 
 export function createClaworldProductShell({
   worldCatalog = DEFAULT_WORLD_MANIFESTS,
@@ -27,20 +30,42 @@ export function createClaworldProductShell({
 } = {}) {
   const worldService = createWorldService({ worldCatalog, store });
   const onboardingService = createOnboardingService({ worldService, store });
-  const membershipService = createMembershipService({ worldService, store });
+  const publicIdentityService = createPublicIdentityService({ store });
+  const membershipService = createMembershipService({ worldService, store, publicIdentityService });
   const worldAuthorizationService = createWorldAuthorizationService({
     worldService,
     membershipService,
   });
-  const matchmakingService = createMatchmakingService({ worldService, worldAuthorizationService, store, presence });
-  const searchService = createWorldSearchService({ worldService, worldAuthorizationService, store, presence });
-  const worldAdminService = createWorldAdminService({ worldService, worldAuthorizationService, store });
+  const conversationFeedbackService = createConversationFeedbackService({ store });
+  const matchmakingService = createMatchmakingService({
+    worldService,
+    worldAuthorizationService,
+    store,
+    presence,
+    conversationFeedbackService,
+  });
+  const searchService = createWorldSearchService({
+    worldService,
+    worldAuthorizationService,
+    store,
+    presence,
+    conversationFeedbackService,
+  });
+  const worldAdminService = createWorldAdminService({
+    worldService,
+    worldAuthorizationService,
+    store,
+    publicIdentityService,
+    conversationFeedbackService,
+  });
   const chatRequestService = createChatRequestService({
     store,
     relay,
     presence,
     worldService,
     worldAuthorizationService,
+    publicIdentityService,
+    conversationFeedbackService,
   });
   const worldBroadcastService = createWorldBroadcastService({
     worldService,
@@ -49,13 +74,14 @@ export function createClaworldProductShell({
     chatRequestService,
     store,
   });
-  const friendService = createFriendService({ store, policy: relay?.policy });
+  const friendService = createFriendService({ store, policy: relay?.policy, publicIdentityService });
   const socialLookupService = createSocialService({ worldService, store });
   const feedbackService = createFeedbackService({ store });
+  const profileService = createPublicIdentityService({ store, conversationFeedbackService });
   const socialService = {
     ...friendService,
-    lookupAgentByCode(input) {
-      return socialLookupService.lookupAgentByCode(input);
+    lookupAgentByIdentity(input) {
+      return socialLookupService.lookupAgentByIdentity(input);
     },
   };
   const worldConversationOrchestrator = createWorldConversationOrchestrator({
@@ -65,6 +91,7 @@ export function createClaworldProductShell({
   const productShell = {
     contexts: {
       onboarding: onboardingService,
+      profile: profileService,
       worlds: worldService,
       worldAuthorization: worldAuthorizationService,
       membership: membershipService,
@@ -75,10 +102,12 @@ export function createClaworldProductShell({
       chatRequests: chatRequestService,
       moderation: worldAdminService,
       feedback: feedbackService,
+      conversationFeedback: conversationFeedbackService,
       orchestration: worldConversationOrchestrator,
     },
     registerRoutes(app) {
       registerOnboardingRoutes(app, { onboardingService, store });
+      registerPublicIdentityRoutes(app, { publicIdentityService: profileService, store });
       registerFriendRoutes(app, { friendService });
       registerChatRequestRoutes(app, { chatRequestService, store });
       registerWorldRoutes(app, {
@@ -101,6 +130,7 @@ export function createClaworldProductShell({
         compatibleWith: ['relay_backend', 'openclaw_channel_plugin'],
         boundedContexts: [
           'onboarding',
+          'profile',
           'worlds',
           'membership',
           'matchmaking',
@@ -110,6 +140,7 @@ export function createClaworldProductShell({
           'chatRequests',
           'moderation',
           'feedback',
+          'conversationFeedback',
           'orchestration',
         ],
         routes: [
@@ -117,6 +148,8 @@ export function createClaworldProductShell({
           'GET /v1/meta/install',
           'GET /v1/onboarding/plan',
           'POST /v1/onboarding/activate',
+          'GET /v1/profile/public-identity',
+          'PUT /v1/profile/public-identity',
           'POST /v1/friend-requests',
           'GET /v1/friend-requests',
           'POST /v1/friend-requests/:friendRequestId/accept',

package/src/product-shell/matching/matchmaking-service.js

@@ -263,6 +263,7 @@ function buildDatingDemoFeed({
   limit,
   worldAuthorizationService,
   resolvePresence,
+  conversationFeedbackService = null,
 }) {
   const { viewerMembership, activeMemberships, normalizedLimit, baseFeed } = buildBaseFeed({
     world,
@@ -278,6 +279,13 @@ function buildDatingDemoFeed({
       const candidateMembership = membershipById.get(candidate.sourceMembershipId);
       return {
         ...candidate,
+        worldFeedbackSummary: conversationFeedbackService?.summarizeWorldAgent?.({
+          worldId: world.worldId,
+          agentId: candidate.targetAgentId,
+        }) || {
+          likesReceived: 0,
+          dislikesReceived: 0,
+        },
         ...buildDatingDemoScoreDetails(viewerMembership, candidateMembership),
       };
     })
@@ -306,6 +314,7 @@ export function createMatchmakingService({
   worldAuthorizationService,
   store = null,
   presence = null,
+  conversationFeedbackService = null,
 } = {}) {
   function assertStore() {
     if (!store) throw createConfigurationError();
@@ -345,6 +354,7 @@ export function createMatchmakingService({
           limit,
           worldAuthorizationService,
           resolvePresence,
+          conversationFeedbackService,
         });
       }
 
@@ -364,7 +374,18 @@ export function createMatchmakingService({
         candidateSource: 'active_memberships_online',
         strategy: buildStrategy(world),
         totalCandidates: baseFeed.candidates.length,
-        candidates: baseFeed.candidates.slice(0, normalizedLimit),
+        candidates: baseFeed.candidates
+          .slice(0, normalizedLimit)
+          .map((candidate) => ({
+            ...candidate,
+            worldFeedbackSummary: conversationFeedbackService?.summarizeWorldAgent?.({
+              worldId: world.worldId,
+              agentId: candidate.targetAgentId,
+            }) || {
+              likesReceived: 0,
+              dislikesReceived: 0,
+            },
+          })),
       };
     },
     listCandidates(options = {}) {

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

@@ -65,7 +65,7 @@ function buildNextStageSummary() {
   };
 }
 
-export function createMembershipService({ worldService, store = null } = {}) {
+export function createMembershipService({ worldService, store = null, publicIdentityService = null } = {}) {
   function assertStore() {
     if (!store) throw createConfigurationError();
     return store;
@@ -193,6 +193,10 @@ export function createMembershipService({ worldService, store = null } = {}) {
 
       const agent = membershipStore.getAgent(normalizedAgentId);
       if (!agent) throw createAgentNotFoundError(normalizedAgentId);
+      publicIdentityService?.assertPublicIdentityReady?.({
+        agentId: normalizedAgentId,
+        capability: 'join world',
+      });
 
       const normalizedParticipantContextText = resolveNormalizedParticipantContextText({
         world,

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

@@ -1,9 +1,9 @@
-import { randomUUID } from 'crypto';
 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';
 
@@ -55,10 +55,6 @@ function createInvalidActivationRequestError(fieldId, message) {
   return error;
 }
 
-function createHiddenActivationAgentCode() {
-  return `claworld_install_${randomUUID().replace(/-/g, '').slice(0, 20)}`;
-}
-
 function createActivatedResponse({ agent, appToken, created, bindingSource }) {
   return {
     status: 'activated',
@@ -66,7 +62,6 @@ function createActivatedResponse({ agent, appToken, created, bindingSource }) {
     bindingSource: normalizeText(bindingSource, null),
     agentId: normalizeText(agent?.agentId, null),
     appToken: normalizeText(appToken, null),
-    agentCode: null,
   };
 }
 
@@ -74,7 +69,6 @@ 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'],
-    ['agentCode', 'dialog-first activation must not receive a user-provided agentCode'],
     ['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'],
   ];
@@ -91,19 +85,13 @@ function validateActivationInput(input = {}) {
 }
 
 function createActivatedAgent({ store, displayName }) {
-  for (let attempt = 0; attempt < 5; attempt += 1) {
-    try {
-      return store.createAgent({
-        agentCode: createHiddenActivationAgentCode(),
-        displayName,
-      });
-    } catch (error) {
-      if (error?.message === 'address already exists') continue;
-      throw error;
-    }
-  }
-
-  throw new Error('failed_to_generate_activation_identity');
+  return store.createAgent({
+    displayName,
+    publicIdentity: {
+      displayName,
+      status: 'pending',
+    },
+  });
 }
 
 export function createOnboardingService({ worldService, store = null } = {}) {
@@ -127,6 +115,7 @@ export function createOnboardingService({ worldService, store = null } = {}) {
             install: CLAWORLD_INSTALLER_COMMAND,
             doctor: CLAWORLD_DOCTOR_COMMAND,
             update: CLAWORLD_UPDATE_COMMAND,
+            uninstall: CLAWORLD_UNINSTALL_COMMAND,
           },
         },
         plugin: {
@@ -163,7 +152,7 @@ export function createOnboardingService({ worldService, store = null } = {}) {
           requiresUserCode: false,
           canonicalIdentityField: 'agentId',
           credentialField: 'appToken',
-          responseFields: ['status', 'agentId', 'appToken', 'agentCode'],
+          responseFields: ['status', 'agentId', 'appToken'],
         },
         verification: {
           statusRoute: '/plugins/claworld/status',

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

@@ -0,0 +1,60 @@
+import { resolveAuthenticatedAgentId } from '../../lib/http-auth.js';
+
+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/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);
+    }
+  });
+}

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

@@ -0,0 +1,190 @@
+import {
+  buildPublicIdentityMissingFields,
+  formatPublicIdentityDisplay,
+  generatePublicIdentityCode,
+  PUBLIC_IDENTITY_STATUS,
+  resolvePublicIdentity,
+  validatePublicDisplayName,
+} from '../../lib/public-identity.js';
+
+function normalizeText(value, fallback = null) {
+  if (value == null) return fallback;
+  const normalized = String(value).trim();
+  return normalized || fallback;
+}
+
+function createConfigurationError() {
+  const error = new Error('public_identity_store_unavailable');
+  error.code = 'public_identity_store_unavailable';
+  error.status = 500;
+  return error;
+}
+
+function createAgentNotFoundError(agentId) {
+  const error = new Error(`agent_not_found:${agentId}`);
+  error.code = 'agent_not_found';
+  error.status = 404;
+  error.responseBody = {
+    error: error.code,
+    message: 'agent not found',
+    agentId: normalizeText(agentId, null),
+  };
+  return error;
+}
+
+function createInvalidPublicIdentityRequest(fieldId, message, code = 'invalid_public_identity') {
+  const error = new Error(code);
+  error.code = code;
+  error.status = 400;
+  error.responseBody = {
+    error: code,
+    message: 'public identity request is invalid',
+    fieldErrors: [
+      {
+        fieldId,
+        message,
+      },
+    ],
+  };
+  return error;
+}
+
+function createPublicIdentityIncompleteError(agent, {
+  capability = null,
+  nextTool = 'claworld_update_public_identity',
+} = {}) {
+  const projected = projectPublicIdentityStatus(agent, { nextTool });
+  const capabilityLabel = normalizeText(capability, 'this Claworld capability');
+  const error = new Error(`public_identity_incomplete:${agent?.agentId || 'unknown'}`);
+  error.code = 'public_identity_incomplete';
+  error.status = 409;
+  error.responseBody = {
+    status: 'blocked',
+    error: error.code,
+    message: `${capabilityLabel} requires a public Claworld identity`,
+    agentId: normalizeText(agent?.agentId, null),
+    requiredAction: projected.requiredAction,
+    nextAction: projected.nextAction,
+    nextTool: projected.nextTool,
+    missingFields: projected.missingFields,
+    publicIdentity: projected.publicIdentity,
+  };
+  return error;
+}
+
+function projectPublicIdentityStatus(agent, {
+  nextTool = 'claworld_update_public_identity',
+  conversationFeedbackService = null,
+} = {}) {
+  const publicIdentity = resolvePublicIdentity(agent);
+  const ready = publicIdentity.status === PUBLIC_IDENTITY_STATUS.READY;
+  return {
+    status: ready ? 'ready' : 'pending',
+    agentId: normalizeText(agent?.agentId, null),
+    ready,
+    publicIdentity: {
+      status: publicIdentity.status,
+      displayName: publicIdentity.displayName,
+      code: publicIdentity.code,
+      displayIdentity: formatPublicIdentityDisplay(publicIdentity),
+      confirmedAt: publicIdentity.confirmedAt,
+      updatedAt: publicIdentity.updatedAt,
+    },
+    recommendedDisplayName: normalizeText(agent?.displayName, publicIdentity.displayName || null),
+    nextAction: ready ? 'continue_claworld_flow' : 'set_public_identity',
+    requiredAction: ready ? null : 'set_public_identity',
+    nextTool: ready ? null : nextTool,
+    missingFields: ready ? [] : buildPublicIdentityMissingFields(agent),
+    feedbackSummary: conversationFeedbackService?.summarizeAgent?.({ agentId: agent?.agentId }) || {
+      totalLikesReceived: 0,
+      totalDislikesReceived: 0,
+      totalLikesGiven: 0,
+      totalDislikesGiven: 0,
+    },
+  };
+}
+
+export function createPublicIdentityService({ store = null, conversationFeedbackService = null } = {}) {
+  function assertStore() {
+    if (!store) throw createConfigurationError();
+    return store;
+  }
+
+  function requireAgent(agentId) {
+    const normalizedAgentId = normalizeText(agentId, null);
+    if (!normalizedAgentId) {
+      throw createInvalidPublicIdentityRequest('agentId', 'agentId is required');
+    }
+    const agent = assertStore().getAgent(normalizedAgentId);
+    if (!agent) throw createAgentNotFoundError(normalizedAgentId);
+    return agent;
+  }
+
+  function codeExists(code, excludeAgentId = null) {
+    return assertStore()
+      .listAgents()
+      .some((agent) => agent.agentId !== excludeAgentId && resolvePublicIdentity(agent).code === code);
+  }
+
+  function issueStableCode(agentId) {
+    for (let attempt = 0; attempt < 32; attempt += 1) {
+      const code = generatePublicIdentityCode();
+      if (!codeExists(code, agentId)) return code;
+    }
+    throw new Error('public_identity_code_generation_failed');
+  }
+
+  function isPublicIdentityCodeConflict(error) {
+    return error?.code === 'public_identity_code_conflict';
+  }
+
+  return {
+    getPublicIdentityStatus({ agentId } = {}) {
+      const agent = requireAgent(agentId);
+      return projectPublicIdentityStatus(agent, { conversationFeedbackService });
+    },
+
+    async updatePublicIdentity({ agentId, displayName } = {}) {
+      const agent = requireAgent(agentId);
+      const validation = validatePublicDisplayName(displayName);
+      if (!validation.ok) {
+        throw createInvalidPublicIdentityRequest('displayName', validation.message, validation.code);
+      }
+      const existingIdentity = resolvePublicIdentity(agent);
+      const stableCode = existingIdentity.code || null;
+
+      for (let attempt = 0; attempt < 32; attempt += 1) {
+        const now = assertStore().now();
+        const nextCode = stableCode || issueStableCode(agent.agentId);
+        try {
+          const updatedAgent = await assertStore().updateAgent(agent.agentId, {
+            displayName: validation.value,
+            publicIdentity: {
+              displayName: validation.value,
+              code: nextCode,
+              status: PUBLIC_IDENTITY_STATUS.READY,
+              confirmedAt: existingIdentity.confirmedAt || now,
+              updatedAt: now,
+            },
+          });
+          return projectPublicIdentityStatus(updatedAgent, { conversationFeedbackService });
+        } catch (error) {
+          if (!stableCode && isPublicIdentityCodeConflict(error)) {
+            continue;
+          }
+          throw error;
+        }
+      }
+
+      throw new Error('public_identity_code_generation_failed');
+    },
+
+    assertPublicIdentityReady({ agentId, capability = null } = {}) {
+      const agent = requireAgent(agentId);
+      if (resolvePublicIdentity(agent).status !== PUBLIC_IDENTITY_STATUS.READY) {
+        throw createPublicIdentityIncompleteError(agent, { capability });
+      }
+      return projectPublicIdentityStatus(agent, { conversationFeedbackService });
+    },
+  };
+}

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

@@ -255,6 +255,7 @@ export function createWorldSearchService({
   worldAuthorizationService,
   store = null,
   presence = null,
+  conversationFeedbackService = null,
 } = {}) {
   function assertStore() {
     if (!store) throw createConfigurationError();
@@ -339,9 +340,8 @@ export function createWorldSearchService({
             playerId: candidateAgent.agentId,
             membershipId: membership.membershipId,
             worldId: world.worldId,
-            displayName: normalizeText(candidateAgent.displayName, candidateAgent.agentCode),
+            displayName: normalizeText(candidateAgent.displayName, candidateAgent.agentId),
             headline: normalizeText(membership.profileSnapshot?.headline, null),
-            address: candidateAgent.address,
             online: presenceState.online === true,
             connectedAt: presenceState.connectedAt,
             lastHeartbeatAt: presenceState.lastHeartbeatAt,
@@ -352,6 +352,13 @@ export function createWorldSearchService({
             reasonSummary: summarizeMatchedFields(matchedFields),
             joinedAt: membership.joinedAt,
             profileSummary: projectProfileSummary(world, membership.profileSnapshot || {}, candidateAgent),
+            worldFeedbackSummary: conversationFeedbackService?.summarizeWorldAgent?.({
+              worldId: world.worldId,
+              agentId: candidateAgent.agentId,
+            }) || {
+              likesReceived: 0,
+              dislikesReceived: 0,
+            },
           };
         })
         .filter(Boolean);

package/src/product-shell/social/chat-request-routes.js

@@ -56,7 +56,10 @@ export function registerChatRequestRoutes(app, { chatRequestService, store }) {
         targetAgentId: req.body?.targetAgentId,
         kickoffBrief: req.body?.kickoffBrief,
         openingMessage: req.body?.openingMessage,
+        openingPayload: req.body?.openingPayload,
         worldId: req.body?.worldId,
+        requestContext: req.body?.requestContext,
+        source: req.body?.source,
       });
       res.status(201).json(result);
     } catch (error) {
@@ -75,7 +78,7 @@ export function registerChatRequestRoutes(app, { chatRequestService, store }) {
     if (!authAgent.agentId) return sendMissingAgentIdentity(res);
 
     try {
-      const result = chatRequestService.listChatRequests({
+      const result = chatRequestService.listChatInbox({
         agentId: authAgent.agentId,
         direction: req.query.direction,
       });