@xfxstudio/claworld 0.2.13 → 0.2.14

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

@@ -1,136 +0,0 @@
-import {
-  normalizeAgentProfile,
-  resolveAgentDisplayName,
-  resolveAgentVisibility,
-} from '../../lib/agent-profile.js';
-import { parsePublicIdentityDisplay, resolvePublicIdentity } 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('social_lookup_store_unavailable');
-  error.code = 'social_lookup_store_unavailable';
-  error.status = 500;
-  return error;
-}
-
-function createInvalidPublicIdentityError(identity) {
-  const error = new Error('invalid_public_identity');
-  error.code = 'invalid_public_identity';
-  error.status = 400;
-  error.responseBody = {
-    error: error.code,
-    message: 'identity must use displayName#code',
-    identity: normalizeText(identity, null),
-    fieldErrors: [
-      {
-        fieldId: 'identity',
-        message: 'identity must use displayName#code',
-      },
-    ],
-  };
-  return error;
-}
-
-function createAgentNotFoundError(identity) {
-  const error = new Error(`agent_not_found:${identity}`);
-  error.code = 'agent_not_found';
-  error.status = 404;
-  error.responseBody = {
-    error: error.code,
-    message: 'no agent found for public identity',
-    identity,
-  };
-  return error;
-}
-
-function createNotDiscoverableError(identity) {
-  const error = new Error(`not_discoverable:${identity}`);
-  error.code = 'not_discoverable';
-  error.status = 403;
-  error.responseBody = {
-    error: error.code,
-    message: 'agent is not discoverable',
-    identity,
-  };
-  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 {
-    lookupAgentByIdentity({ identity } = {}) {
-      const socialStore = assertStore();
-      const parsedIdentity = parsePublicIdentityDisplay(identity);
-      if (!parsedIdentity) {
-        throw createInvalidPublicIdentityError(identity);
-      }
-
-      const agent = socialStore
-        .listAgents()
-        .find((candidate) => {
-          const candidateIdentity = resolvePublicIdentity(candidate);
-          return candidateIdentity.status === 'ready'
-            && candidateIdentity.code === parsedIdentity.code;
-        }) || null;
-      if (!agent) {
-        throw createAgentNotFoundError(parsedIdentity.identity);
-      }
-
-      const visibility = resolveAgentVisibility(agent);
-      if (!visibility.discoverable) {
-        throw createNotDiscoverableError(parsedIdentity.identity);
-      }
-
-      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: {
-          agentId: agent.agentId,
-          identity: resolvePublicIdentity(agent).displayIdentity || parsedIdentity.identity,
-          displayName: resolveAgentDisplayName(agent),
-          code: resolvePublicIdentity(agent).code,
-          profile: normalizeAgentProfile(agent.profile),
-          discoverable: visibility.discoverable,
-          contactable: visibility.contactable,
-        },
-        activeWorlds: {
-          totalCount: activeWorlds.length,
-          items: activeWorlds,
-        },
-      };
-    },
-  };
-}

package/src/product-shell/worlds/world-admin-service.js

@@ -1,486 +0,0 @@
-import { WORLD_ACTIONS, WORLD_ROLES } from './world-authorization.js';
-import { buildWorldContextText } from './world-text.js';
-
-function normalizeText(value, fallback = null) {
-  if (value == null) return fallback;
-  const normalized = String(value).trim();
-  return normalized || fallback;
-}
-
-function normalizeBoolean(value, fallback = false) {
-  if (typeof value === 'boolean') return value;
-  return fallback;
-}
-
-const OWNER_WORLD_STATUSES = new Set(['draft', 'enabled', 'paused', 'closed', 'disabled']);
-
-function normalizeOwnerWorldStatus(value, fallback = null) {
-  const normalized = normalizeText(value, fallback);
-  return OWNER_WORLD_STATUSES.has(normalized) ? normalized : fallback;
-}
-
-function inferEnabledFromOwnerWorldStatus(status, fallback = null) {
-  const normalizedStatus = normalizeOwnerWorldStatus(status, null);
-  if (!normalizedStatus) return fallback;
-  return normalizedStatus === 'enabled';
-}
-
-function projectOwnerWorldMetaStatus(status, enabled) {
-  const normalizedStatus = normalizeOwnerWorldStatus(status, enabled === true ? 'enabled' : 'draft');
-  switch (normalizedStatus) {
-    case 'enabled':
-      return 'creator_enabled';
-    case 'paused':
-      return 'creator_paused';
-    case 'closed':
-      return 'creator_closed';
-    case 'disabled':
-      return 'creator_disabled';
-    case 'draft':
-    default:
-      return 'creator_draft';
-  }
-}
-
-function summarizeWorldContextText(worldContextText, fallback = null) {
-  const normalized = normalizeText(worldContextText, null);
-  if (!normalized) return fallback;
-  const firstLine = normalized
-    .split('\n')
-    .map((line) => line.trim())
-    .find(Boolean);
-  return firstLine || fallback;
-}
-
-function slugify(value, fallback = 'world') {
-  const normalized = normalizeText(value, fallback)
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '');
-  return normalized || fallback;
-}
-
-function createConfigurationError() {
-  const error = new Error('world_store_unavailable');
-  error.code = 'world_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;
-  return error;
-}
-
-function createWorldActionNotAllowedError({
-  worldId,
-  agentId,
-  action,
-  actorRole = null,
-  allowedRoles = [],
-} = {}) {
-  const error = new Error(`world_action_not_allowed:${action}:${worldId}:${agentId}`);
-  error.code = 'world_action_not_allowed';
-  error.status = 403;
-  const messageByAction = {
-    [WORLD_ACTIONS.VIEW_MANAGEMENT]: 'agent does not have permission to access world management',
-    [WORLD_ACTIONS.MANAGE_WORLD]: 'agent does not have permission to manage this world',
-    [WORLD_ACTIONS.CHANGE_ENABLED_STATE]: 'only the world owner can enable or disable this world',
-  };
-  error.responseBody = {
-    error: error.code,
-    message: messageByAction[action] || 'agent does not have permission to manage this world',
-    worldId,
-    agentId,
-    action,
-    actorRole,
-    allowedRoles,
-  };
-  return error;
-}
-
-function createInvalidWorldRequestError(fieldId, message = `${fieldId} is required`) {
-  const error = new Error(`invalid_world_request:${fieldId}`);
-  error.code = 'invalid_world_request';
-  error.status = 400;
-  error.responseBody = {
-    error: error.code,
-    message: 'world request is invalid',
-    fieldErrors: [
-      {
-        fieldId,
-        message,
-      },
-    ],
-  };
-  return error;
-}
-
-function normalizeAgentId(agentId) {
-  return normalizeText(agentId, null);
-}
-
-function normalizeWorldRole(worldRole, fallback = null) {
-  const normalized = normalizeText(worldRole, fallback);
-  return [WORLD_ROLES.OWNER, WORLD_ROLES.MEMBER].includes(normalized) ? normalized : fallback;
-}
-
-function buildDefaultEntryProfileField() {
-  return {
-    fieldId: 'participantContextText',
-    label: 'Entry Profile',
-    type: 'string',
-    required: true,
-    searchable: true,
-    description: 'Free-form participant profile/context text used for world join, search, and candidate review.',
-    examples: [],
-  };
-}
-
-function buildSearchSchema() {
-  return {
-    mode: 'profile_overlap_search',
-    inputFieldIds: ['participantContextText'],
-    summary:
-      'Manual world search over active online members using participantContextText. Candidate feed review is the canonical path before request_chat.',
-    onlineOnly: true,
-    defaultLimit: 10,
-  };
-}
-
-function buildMatchingStrategy() {
-  return {
-    mode: 'profile_overlap',
-    cadence: 'on_demand',
-    strategySummary:
-      'Rank active online world members by overlap on participantContextText, deliver candidate summaries first, and let members request_chat after review.',
-    candidateSources: ['active_memberships_online'],
-  };
-}
-
-function buildConversationTemplate(interactionRules, prohibitedRules, { existingConversationTemplate = null } = {}) {
-  return {
-    mode: normalizeText(existingConversationTemplate?.mode, 'a2a'),
-    worldRules: {
-      openingText: interactionRules,
-      turnMessageRules: Array.isArray(existingConversationTemplate?.worldRules?.turnMessageRules)
-        ? existingConversationTemplate.worldRules.turnMessageRules
-        : [],
-      convergence: existingConversationTemplate?.worldRules?.convergence || {},
-      stateChangeMessages: existingConversationTemplate?.worldRules?.stateChangeMessages || {},
-    },
-  };
-}
-
-function buildWorldRecord({
-  worldId,
-  creatorAgentId,
-  displayName,
-  summary,
-  worldContextText = null,
-  enabled = true,
-  status = null,
-  existingMetrics = null,
-} = {}) {
-  const resolvedStatus = normalizeOwnerWorldStatus(status, enabled ? 'enabled' : 'draft');
-  const participantContextField = buildDefaultEntryProfileField();
-  const resolvedWorldContextText = buildWorldContextText({
-    worldId,
-    displayName,
-    summary,
-    worldContextText,
-    interactionRules: null,
-    prohibitedRules: null,
-  });
-
-  return {
-    worldId,
-    slug: slugify(displayName, worldId),
-    displayName,
-    summary,
-    description: resolvedWorldContextText,
-    category: 'ugc',
-    lifecycle: 'creator_managed',
-    tags: ['ugc', 'creator-managed'],
-    interactionRules: null,
-    prohibitedRules: null,
-    worldContextText: resolvedWorldContextText,
-    joinSchema: {
-      requiredFields: [participantContextField],
-      optionalFields: [],
-      hints: [],
-    },
-    searchSchema: buildSearchSchema(),
-    matching: buildMatchingStrategy(),
-    conversationTemplate: buildConversationTemplate(null, null),
-    meta: {
-      status: projectOwnerWorldMetaStatus(resolvedStatus, enabled),
-      persistence: 'store',
-    },
-    creatorAgentId,
-    eligibility: 'active',
-    broadcast: {
-      enabled: false,
-      audience: 'members',
-      replyPolicy: 'zero',
-      excludeSelf: true,
-    },
-    status: resolvedStatus,
-    enabled,
-    schemaVersion: 1,
-    metrics: existingMetrics || {
-      totalConversationCount: 0,
-    },
-  };
-}
-
-function projectParticipantContextField(world = {}) {
-  const requiredFields = Array.isArray(world.joinSchema?.requiredFields) ? world.joinSchema.requiredFields : [];
-  const field = requiredFields[0] || buildDefaultEntryProfileField();
-  return {
-    fieldId: field.fieldId,
-    label: field.label,
-    description: field.description || null,
-  };
-}
-
-function projectWorldStats(store, world = {}, conversationFeedbackService = null) {
-  const totalParticipants = store.countMemberships({ worldId: world.worldId });
-  const activeParticipants = store.countMemberships({ worldId: world.worldId, status: 'active' });
-  const feedbackSummary = conversationFeedbackService?.summarizeWorld?.({ worldId: world.worldId }) || {
-    totalLikes: 0,
-    totalDislikes: 0,
-  };
-  return {
-    totalParticipants,
-    activeParticipants,
-    totalConversationCount: Number(world.metrics?.totalConversationCount || 0),
-    totalLikes: feedbackSummary.totalLikes,
-    totalDislikes: feedbackSummary.totalDislikes,
-  };
-}
-
-function projectManagedWorldSummary(store, world = {}, { worldRole = null, conversationFeedbackService = null } = {}) {
-  return {
-    worldId: world.worldId,
-    displayName: world.displayName,
-    worldContextText: world.worldContextText || '',
-    ownerAgentId: world.creatorAgentId || null,
-    enabled: world.enabled === true,
-    status: world.status || 'draft',
-    worldRole: normalizeWorldRole(worldRole, null),
-    createdAt: world.createdAt || null,
-    updatedAt: world.updatedAt || null,
-    stats: projectWorldStats(store, world, conversationFeedbackService),
-  };
-}
-
-function projectManagedWorld(store, world = {}, { worldRole = null, conversationFeedbackService = null } = {}) {
-  return {
-    worldId: world.worldId,
-    displayName: world.displayName,
-    worldContextText: world.worldContextText || '',
-    ownerAgentId: world.creatorAgentId || null,
-    enabled: world.enabled === true,
-    status: world.status || 'draft',
-    worldRole: normalizeWorldRole(worldRole, null),
-    schemaVersion: Number(world.schemaVersion || 1),
-    createdAt: world.createdAt || null,
-    updatedAt: world.updatedAt || null,
-    participantContextField: projectParticipantContextField(world),
-    stats: projectWorldStats(store, world, conversationFeedbackService),
-  };
-}
-
-function buildWorldId(displayName, existingIds = []) {
-  const base = `ugc-${slugify(displayName, 'world')}`;
-  if (!existingIds.includes(base)) return base;
-
-  let counter = 2;
-  while (existingIds.includes(`${base}-${counter}`)) {
-    counter += 1;
-  }
-  return `${base}-${counter}`;
-}
-
-export function createWorldAdminService({
-  worldService,
-  worldAuthorizationService,
-  store = null,
-  publicIdentityService = null,
-  conversationFeedbackService = null,
-} = {}) {
-  function assertStore() {
-    if (!store) throw createConfigurationError();
-    return store;
-  }
-
-  function assertActorAgent(agentId) {
-    const actorAgentId = normalizeAgentId(agentId);
-    if (!actorAgentId) throw createInvalidWorldRequestError('agentId', 'agentId is required');
-    const agent = assertStore().getAgent(actorAgentId);
-    if (!agent) throw createAgentNotFoundError(actorAgentId);
-    return actorAgentId;
-  }
-
-  function requireWorldOwner({ worldId, actorAgentId } = {}) {
-    const authorization = worldAuthorizationService.evaluateWorldAction({
-      worldId,
-      actorAgentId,
-      action: WORLD_ACTIONS.MANAGE_WORLD,
-      includeDisabled: true,
-    });
-    if (!authorization.allowed) {
-      throw createWorldActionNotAllowedError({
-        worldId: authorization.world.worldId,
-        agentId: actorAgentId,
-        action: WORLD_ACTIONS.MANAGE_WORLD,
-        actorRole: authorization.worldRole,
-        allowedRoles: authorization.allowedRoles,
-      });
-    }
-    return authorization;
-  }
-
-  function hasManageWorldChanges(changes = null) {
-    if (!changes || typeof changes !== 'object' || Array.isArray(changes)) return false;
-    return Object.keys(changes).length > 0;
-  }
-
-  return {
-    async createWorld({
-      ownerAgentId,
-      creatorAgentId,
-      displayName,
-      worldContextText,
-      enabled = true,
-      status = null,
-    } = {}) {
-      const storeBacked = assertStore();
-      const resolvedOwnerAgentId = assertActorAgent(ownerAgentId || creatorAgentId);
-      publicIdentityService?.assertPublicIdentityReady?.({
-        agentId: resolvedOwnerAgentId,
-        capability: 'create world',
-      });
-      const resolvedDisplayName = normalizeText(displayName, null);
-      if (!resolvedDisplayName) throw createInvalidWorldRequestError('displayName');
-      const resolvedWorldContextText = normalizeText(worldContextText, null);
-      if (!resolvedWorldContextText) throw createInvalidWorldRequestError('worldContextText');
-
-      const worldId = buildWorldId(resolvedDisplayName, worldService.listWorldIds());
-      const worldRecord = buildWorldRecord({
-        worldId,
-        creatorAgentId: resolvedOwnerAgentId,
-        displayName: resolvedDisplayName,
-        summary: summarizeWorldContextText(resolvedWorldContextText, resolvedDisplayName),
-        worldContextText: resolvedWorldContextText,
-        enabled: normalizeBoolean(enabled, true),
-        status: normalizeOwnerWorldStatus(status, normalizeBoolean(enabled, true) ? 'enabled' : 'draft'),
-      });
-
-      const created = await storeBacked.createWorldConfig(worldRecord);
-      const normalizedWorld = worldService.requireWorld(created.worldId, { includeDisabled: true });
-
-      return projectManagedWorld(storeBacked, normalizedWorld, {
-        worldRole: WORLD_ROLES.OWNER,
-        conversationFeedbackService,
-      });
-    },
-    listManagedWorlds({ actorAgentId, creatorAgentId, includeDisabled = true } = {}) {
-      const storeBacked = assertStore();
-      const resolvedActorAgentId = assertActorAgent(actorAgentId || creatorAgentId);
-      return worldService
-        .listOwnedWorlds({ creatorAgentId: resolvedActorAgentId, includeDisabled })
-        .map((world) => worldAuthorizationService.resolveWorldActorContext({
-          worldId: world.worldId,
-          actorAgentId: resolvedActorAgentId,
-          includeDisabled,
-        }))
-        .map((context) => projectManagedWorldSummary(storeBacked, context.world, {
-          worldRole: context.worldRole,
-          conversationFeedbackService,
-        }));
-    },
-    listOwnedWorlds(input = {}) {
-      return this.listManagedWorlds(input);
-    },
-    getManagedWorld({ actorAgentId, creatorAgentId, worldId } = {}) {
-      const storeBacked = assertStore();
-      const resolvedActorAgentId = assertActorAgent(actorAgentId || creatorAgentId);
-      const authorization = requireWorldOwner({
-        worldId,
-        actorAgentId: resolvedActorAgentId,
-      });
-      return projectManagedWorld(storeBacked, authorization.world, {
-        worldRole: authorization.worldRole,
-        conversationFeedbackService,
-      });
-    },
-    async manageWorld({ actorAgentId, creatorAgentId, worldId, changes = null, enabled = null, status = null } = {}) {
-      const storeBacked = assertStore();
-      const resolvedActorAgentId = assertActorAgent(actorAgentId || creatorAgentId);
-      const hasChanges = changes && typeof changes === 'object' && !Array.isArray(changes);
-      const normalizedStatus = normalizeOwnerWorldStatus(status, null);
-      const resolvedEnabled = normalizedStatus != null
-        ? inferEnabledFromOwnerWorldStatus(normalizedStatus, null)
-        : (enabled == null ? null : normalizeBoolean(enabled, false));
-
-      const authorization = requireWorldOwner({
-        worldId,
-        actorAgentId: resolvedActorAgentId,
-      });
-
-      const existingWorld = authorization.world;
-      if (!hasChanges && resolvedEnabled == null && normalizedStatus == null) {
-        return projectManagedWorld(storeBacked, existingWorld, {
-          worldRole: authorization.worldRole,
-          conversationFeedbackService,
-        });
-      }
-
-      let nextRecord = existingWorld;
-
-      if (hasChanges) {
-        const nextDisplayName = normalizeText(changes.displayName, existingWorld.displayName);
-        const nextWorldContextText = Object.prototype.hasOwnProperty.call(changes, 'worldContextText')
-          ? normalizeText(changes.worldContextText, null)
-          : existingWorld.worldContextText;
-        nextRecord = buildWorldRecord({
-          worldId: existingWorld.worldId,
-          creatorAgentId: existingWorld.creatorAgentId,
-          displayName: nextDisplayName,
-          summary: summarizeWorldContextText(nextWorldContextText, nextDisplayName),
-          worldContextText: nextWorldContextText,
-          enabled: resolvedEnabled == null ? existingWorld.enabled === true : resolvedEnabled,
-          status: normalizedStatus || (
-            resolvedEnabled == null
-              ? existingWorld.status
-              : (resolvedEnabled ? 'enabled' : 'disabled')
-          ),
-          existingMetrics: existingWorld.metrics || null,
-        });
-      } else if (resolvedEnabled != null || normalizedStatus != null) {
-        const nextEnabled = resolvedEnabled == null ? existingWorld.enabled === true : resolvedEnabled;
-        const nextStatus = normalizedStatus || (nextEnabled ? 'enabled' : 'disabled');
-        nextRecord = {
-          ...existingWorld,
-          enabled: nextEnabled,
-          status: nextStatus,
-          meta: {
-            ...(existingWorld.meta || {}),
-            status: projectOwnerWorldMetaStatus(nextStatus, nextEnabled),
-          },
-        };
-      }
-
-      const updated = await storeBacked.updateWorldConfig(existingWorld.worldId, nextRecord);
-      const normalizedWorld = worldService.requireWorld(updated.worldId, { includeDisabled: true });
-      return projectManagedWorld(storeBacked, normalizedWorld, {
-        worldRole: authorization.worldRole,
-        conversationFeedbackService,
-      });
-    },
-  };
-}