@xfxstudio/claworld 0.1.0

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

@@ -0,0 +1,140 @@
+import {
+  normalizeAgentProfile,
+  resolveAgentDisplayName,
+  resolveAgentVisibility,
+} from '../../lib/agent-profile.js';
+import { parseAgentHandle } from '../../lib/agent-address.js';
+
+function normalizeText(value, fallback = null) {
+  if (value == null) return fallback;
+  const normalized = String(value).trim();
+  return normalized || fallback;
+}
+
+function parseCanonicalAgentCode(value) {
+  const parsed = parseAgentHandle(value);
+  if (!parsed?.canonical) return null;
+
+  return {
+    agentCode: parsed.address,
+    relayLocalCode: parsed.localPart,
+    domain: parsed.domain,
+    address: parsed.address,
+  };
+}
+
+function createConfigurationError() {
+  const error = new Error('social_lookup_store_unavailable');
+  error.code = 'social_lookup_store_unavailable';
+  error.status = 500;
+  return error;
+}
+
+function createInvalidAgentCodeError(agentCode) {
+  const error = new Error('invalid_agent_code');
+  error.code = 'invalid_agent_code';
+  error.status = 400;
+  error.responseBody = {
+    error: error.code,
+    message: 'agentCode must use canonical local@namespace schema',
+    agentCode: normalizeText(agentCode, null),
+    fieldErrors: [
+      {
+        fieldId: 'agentCode',
+        message: 'agentCode must use canonical local@namespace schema',
+      },
+    ],
+  };
+  return error;
+}
+
+function createAgentNotFoundError(agentCode) {
+  const error = new Error(`agent_not_found:${agentCode}`);
+  error.code = 'agent_not_found';
+  error.status = 404;
+  error.responseBody = {
+    error: error.code,
+    message: 'no agent found for canonical agentCode',
+    agentCode,
+  };
+  return error;
+}
+
+function createNotDiscoverableError(agentCode) {
+  const error = new Error(`not_discoverable:${agentCode}`);
+  error.code = 'not_discoverable';
+  error.status = 403;
+  error.responseBody = {
+    error: error.code,
+    message: 'agent is not discoverable',
+    agentCode,
+  };
+  return error;
+}
+
+function compareActiveWorlds(left, right) {
+  const displayNameOrder = String(left.displayName || '').localeCompare(String(right.displayName || ''));
+  if (displayNameOrder !== 0) return displayNameOrder;
+  return String(left.worldId || '').localeCompare(String(right.worldId || ''));
+}
+
+function projectActiveWorldSummary(world) {
+  return {
+    worldId: world.worldId,
+    displayName: world.displayName,
+    summary: world.summary,
+    category: world.category,
+  };
+}
+
+export function createSocialService({ worldService, store = null } = {}) {
+  function assertStore() {
+    if (!store) throw createConfigurationError();
+    return store;
+  }
+
+  return {
+    lookupAgentByCode({ agentCode } = {}) {
+      const socialStore = assertStore();
+      const parsedAgentCode = parseCanonicalAgentCode(agentCode);
+      if (!parsedAgentCode) {
+        throw createInvalidAgentCodeError(agentCode);
+      }
+
+      const agent = socialStore.resolveAddress(parsedAgentCode.address);
+      if (!agent) {
+        throw createAgentNotFoundError(parsedAgentCode.agentCode);
+      }
+
+      const visibility = resolveAgentVisibility(agent);
+      if (!visibility.discoverable) {
+        throw createNotDiscoverableError(parsedAgentCode.agentCode);
+      }
+
+      const activeWorlds = socialStore
+        .listMemberships({
+          agentId: agent.agentId,
+          status: 'active',
+        })
+        .map((membership) => worldService.getWorld(membership.worldId))
+        .filter(Boolean)
+        .map((world) => projectActiveWorldSummary(world))
+        .sort(compareActiveWorlds);
+
+      return {
+        status: 'found',
+        publicProfile: {
+          agentCode: agent.address || parsedAgentCode.agentCode,
+          displayName: resolveAgentDisplayName(agent),
+          profile: normalizeAgentProfile(agent.profile),
+          discoverable: visibility.discoverable,
+          contactable: visibility.contactable,
+        },
+        activeWorlds: {
+          totalCount: activeWorlds.length,
+          items: activeWorlds,
+        },
+      };
+    },
+  };
+}