@xfxstudio/claworld 0.2.13 → 0.2.14

package/src/product-shell/social/friend-routes.js

@@ -1,82 +0,0 @@
-function sendFriendError(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 registerFriendRoutes(app, { friendService }) {
-  app.post('/v1/friend-requests', async (req, res) => {
-    try {
-      const result = await friendService.createFriendRequest({
-        fromAgentId: req.body?.fromAgentId,
-        targetAgentId: req.body?.targetAgentId,
-        message: req.body?.message,
-        metadata: req.body?.metadata,
-      });
-      res.status(result.created ? 201 : 200).json(result);
-    } catch (error) {
-      sendFriendError(res, error);
-    }
-  });
-
-  app.get('/v1/friend-requests', (req, res) => {
-    try {
-      const result = friendService.listFriendRequests({
-        agentId: req.query.agentId,
-        direction: req.query.direction,
-        status: req.query.status,
-      });
-      res.json(result);
-    } catch (error) {
-      sendFriendError(res, error);
-    }
-  });
-
-  app.post('/v1/friend-requests/:friendRequestId/accept', async (req, res) => {
-    try {
-      const result = await friendService.acceptFriendRequest(req.params.friendRequestId, {
-        actorAgentId: req.body?.actorAgentId,
-      });
-      res.json(result);
-    } catch (error) {
-      sendFriendError(res, error);
-    }
-  });
-
-  app.post('/v1/friend-requests/:friendRequestId/reject', async (req, res) => {
-    try {
-      const result = await friendService.rejectFriendRequest(req.params.friendRequestId, {
-        actorAgentId: req.body?.actorAgentId,
-      });
-      res.json(result);
-    } catch (error) {
-      sendFriendError(res, error);
-    }
-  });
-
-  app.get('/v1/friends', (req, res) => {
-    try {
-      const result = friendService.listFriends({
-        agentId: req.query.agentId,
-      });
-      res.json(result);
-    } catch (error) {
-      sendFriendError(res, error);
-    }
-  });
-
-  app.delete('/v1/friends/:peerAgentId', async (req, res) => {
-    try {
-      const result = await friendService.removeFriend({
-        actorAgentId: req.body?.actorAgentId || req.query.actorAgentId,
-        peerAgentId: req.params.peerAgentId,
-      });
-      res.json(result);
-    } catch (error) {
-      sendFriendError(res, error);
-    }
-  });
-}

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

@@ -1,557 +0,0 @@
-import { normalizeAgentProfile, resolveAgentDisplayName, resolveAgentVisibility } from '../../lib/agent-profile.js';
-import { createRelayPolicyHooks, evaluatePolicyHook } from '../../lib/policy.js';
-import { resolvePublicIdentity } from '../../lib/public-identity.js';
-
-function normalizeAgentId(agentId) {
-  const normalized = String(agentId || '').trim();
-  return normalized || null;
-}
-
-function normalizeDirection(direction) {
-  const normalized = String(direction || '').trim().toLowerCase();
-  return normalized === 'inbound' || normalized === 'outbound' ? normalized : null;
-}
-
-function normalizeStatus(status) {
-  const normalized = String(status || '').trim().toLowerCase();
-  return normalized || null;
-}
-
-function normalizeMessage(message) {
-  if (typeof message !== 'string') return null;
-  const normalized = message.trim();
-  return normalized || null;
-}
-
-function sortByRecency(items = [], ...fieldNames) {
-  return items.slice().sort((left, right) => {
-    for (const fieldName of fieldNames) {
-      const rightTs = Date.parse(right?.[fieldName] || '');
-      const leftTs = Date.parse(left?.[fieldName] || '');
-      const normalizedRightTs = Number.isFinite(rightTs) ? rightTs : -Infinity;
-      const normalizedLeftTs = Number.isFinite(leftTs) ? leftTs : -Infinity;
-      if (normalizedRightTs !== normalizedLeftTs) return normalizedRightTs - normalizedLeftTs;
-    }
-    return 0;
-  });
-}
-
-function createConfigurationError() {
-  const error = new Error('friend_store_unavailable');
-  error.code = 'friend_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 createTargetNotFoundError(targetAgentId) {
-  const error = new Error(`friend_target_not_found:${targetAgentId}`);
-  error.code = 'friend_target_not_found';
-  error.status = 404;
-  return error;
-}
-
-function createFriendRequestTargetOnlyError() {
-  const error = new Error('friend_request_target_only');
-  error.code = 'friend_request_target_only';
-  error.status = 403;
-  return error;
-}
-
-function createFriendRequestNotPendingError(friendRequestId, status) {
-  const error = new Error(`friend_request_not_pending:${friendRequestId}`);
-  error.code = 'friend_request_not_pending';
-  error.status = 400;
-  error.responseBody = {
-    error: error.code,
-    message: 'friend request is not pending',
-    friendRequestId,
-    status,
-  };
-  return error;
-}
-
-function createFriendRequestNotFoundError(friendRequestId) {
-  const error = new Error(`friend_request_not_found:${friendRequestId}`);
-  error.code = 'friend_request_not_found';
-  error.status = 404;
-  return error;
-}
-
-function createFriendshipNotFoundError(actorAgentId, peerAgentId) {
-  const error = new Error(`friendship_not_found:${actorAgentId}:${peerAgentId}`);
-  error.code = 'friendship_not_found';
-  error.status = 404;
-  return error;
-}
-
-function createSelfFriendRequestError() {
-  const error = new Error('self_friend_request_not_allowed');
-  error.code = 'self_friend_request_not_allowed';
-  error.status = 400;
-  return error;
-}
-
-function createReversePendingRequestError(request) {
-  const error = new Error('friend_request_pending_reverse');
-  error.code = 'friend_request_pending_reverse';
-  error.status = 409;
-  error.responseBody = {
-    error: error.code,
-    message: 'peer already has a pending friend request; accept that request instead of creating a new one',
-    pendingRequestId: request.friendRequestId,
-  };
-  return error;
-}
-
-function createPolicyDecisionError(decision, fallbackCode = 'friend_request_not_allowed') {
-  const errorCode = String(decision?.body?.error || fallbackCode).trim() || fallbackCode;
-  const error = new Error(errorCode);
-  error.code = errorCode;
-  error.status = Number.isInteger(decision?.status) ? decision.status : 403;
-  error.responseBody = decision?.body && typeof decision.body === 'object'
-    ? decision.body
-    : { error: errorCode };
-  return error;
-}
-
-function projectAgent(store, agentId) {
-  const agent = store.getAgent(agentId);
-  if (!agent) return null;
-  const visibility = resolveAgentVisibility(agent);
-  return {
-    agentId: agent.agentId,
-    displayName: resolveAgentDisplayName(agent),
-    publicIdentity: resolvePublicIdentity(agent),
-    profile: normalizeAgentProfile(agent.profile),
-    discoverable: visibility.discoverable,
-    contactable: visibility.contactable,
-    createdAt: agent.createdAt,
-    ...store.getPresence(agent.agentId),
-  };
-}
-
-function resolvePeerAgentId(friendship, viewerAgentId) {
-  if (friendship.agentAId === viewerAgentId) return friendship.agentBId;
-  if (friendship.agentBId === viewerAgentId) return friendship.agentAId;
-  return null;
-}
-
-export function createFriendService({ store = null, policy = null, publicIdentityService = null } = {}) {
-  const relayPolicy = createRelayPolicyHooks(policy);
-
-  function assertStore() {
-    if (!store) throw createConfigurationError();
-    return store;
-  }
-
-  function requireAgent(agentId) {
-    const normalizedAgentId = normalizeAgentId(agentId);
-    if (!normalizedAgentId) throw createAgentNotFoundError(agentId);
-    const agent = assertStore().getAgent(normalizedAgentId);
-    if (!agent) throw createAgentNotFoundError(normalizedAgentId);
-    return agent;
-  }
-
-  function resolveActiveFriendship(agentAId, agentBId) {
-    return sortByRecency(
-      assertStore().listFriendships({
-        agentId: agentAId,
-        peerAgentId: agentBId,
-        status: 'active',
-      }),
-      'updatedAt',
-      'acceptedAt',
-      'createdAt',
-    )[0] || null;
-  }
-
-  function resolveLatestFriendship(agentAId, agentBId) {
-    return sortByRecency(
-      assertStore().listFriendships({
-        agentId: agentAId,
-        peerAgentId: agentBId,
-      }),
-      'updatedAt',
-      'acceptedAt',
-      'createdAt',
-    )[0] || null;
-  }
-
-  function resolveFriendshipGrants(friendshipId) {
-    return assertStore()
-      .listApprovalGrants()
-      .filter((grant) => grant.metadata?.friendshipId === friendshipId);
-  }
-
-  function resolveActiveApprovalGrant(ownerAgentId, peerAgentId) {
-    return sortByRecency(
-      assertStore().listApprovalGrants({
-        ownerAgentId,
-        peerAgentId,
-        status: 'active',
-      }),
-      'updatedAt',
-      'createdAt',
-    )[0] || null;
-  }
-
-  function projectFriendRequest(request, viewerAgentId = null) {
-    return {
-      ...request,
-      direction:
-        viewerAgentId === request.fromAgentId
-          ? 'outbound'
-          : viewerAgentId === request.toAgentId
-            ? 'inbound'
-            : 'related',
-      fromAgent: projectAgent(assertStore(), request.fromAgentId),
-      toAgent: projectAgent(assertStore(), request.toAgentId),
-    };
-  }
-
-  function projectFriendship(friendship, viewerAgentId = null) {
-    const peerAgentId = viewerAgentId ? resolvePeerAgentId(friendship, viewerAgentId) : null;
-    const grants = resolveFriendshipGrants(friendship.friendshipId);
-    return {
-      ...friendship,
-      peerAgentId,
-      peerAgent: peerAgentId ? projectAgent(assertStore(), peerAgentId) : null,
-      participants: [
-        projectAgent(assertStore(), friendship.agentAId),
-        projectAgent(assertStore(), friendship.agentBId),
-      ],
-      approval: {
-        grantIds: grants.map((grant) => grant.grantId),
-      },
-    };
-  }
-
-  async function ensureFriendshipApprovalGrants(friendship, request) {
-    const friendshipStore = assertStore();
-    const now = friendshipStore.now();
-    const pairSpecs = [
-      {
-        ownerAgentId: request.fromAgentId,
-        peerAgentId: request.toAgentId,
-      },
-      {
-        ownerAgentId: request.toAgentId,
-        peerAgentId: request.fromAgentId,
-      },
-    ];
-    const grants = [];
-    let existingGrantUpdated = false;
-
-    for (const pair of pairSpecs) {
-      const existingGrant = friendshipStore
-        .listApprovalGrants({ ownerAgentId: pair.ownerAgentId, peerAgentId: pair.peerAgentId })
-        .find((grant) => grant.metadata?.friendshipId === friendship.friendshipId)
-        || null;
-
-      if (!existingGrant) {
-        grants.push(await friendshipStore.createApprovalGrant({
-          requestId: request.friendRequestId,
-          ownerAgentId: pair.ownerAgentId,
-          peerAgentId: pair.peerAgentId,
-          capabilities: {
-            directMessage: true,
-            friend: true,
-          },
-          metadata: {
-            friendshipId: friendship.friendshipId,
-            pairKey: friendship.pairKey,
-          },
-          source: 'friendship',
-        }));
-        continue;
-      }
-
-      existingGrant.requestId = request.friendRequestId;
-      existingGrant.status = 'active';
-      existingGrant.updatedAt = now;
-      existingGrant.acceptedAt = existingGrant.acceptedAt || now;
-      existingGrant.revokedAt = null;
-      existingGrant.source = 'friendship';
-      existingGrant.capabilities = {
-        ...(existingGrant.capabilities && typeof existingGrant.capabilities === 'object' ? existingGrant.capabilities : {}),
-        directMessage: true,
-        friend: true,
-      };
-      existingGrant.metadata = {
-        ...(existingGrant.metadata && typeof existingGrant.metadata === 'object' ? existingGrant.metadata : {}),
-        friendshipId: friendship.friendshipId,
-        pairKey: friendship.pairKey,
-      };
-      existingGrantUpdated = true;
-      grants.push(existingGrant);
-    }
-
-    if (existingGrantUpdated) {
-      await friendshipStore.markApprovalGrantUpdated();
-    }
-
-    return grants;
-  }
-
-  return {
-    async createFriendRequest({ fromAgentId, targetAgentId, message = null, metadata = {} } = {}) {
-      const friendshipStore = assertStore();
-      const fromAgent = requireAgent(fromAgentId);
-      publicIdentityService?.assertPublicIdentityReady?.({
-        agentId: fromAgent.agentId,
-        capability: 'send friend request',
-      });
-      const normalizedTargetAgentId = normalizeAgentId(targetAgentId);
-      if (!normalizedTargetAgentId) {
-        throw createTargetNotFoundError(targetAgentId);
-      }
-
-      const toAgent = friendshipStore.getAgent(normalizedTargetAgentId);
-      if (!toAgent) throw createTargetNotFoundError(normalizedTargetAgentId);
-
-      const canRequest = evaluatePolicyHook({
-        hook: relayPolicy.canRequest,
-        context: {
-          fromAgentId: fromAgent.agentId,
-          fromAgent,
-          targetAgentId: normalizedTargetAgentId,
-          toAgent,
-          requestContext: {
-            type: 'friend_request',
-            message: normalizeMessage(message),
-            metadata,
-          },
-          approvalGrant: resolveActiveApprovalGrant(toAgent.agentId, fromAgent.agentId),
-          store: friendshipStore,
-        },
-        hookName: 'canRequest',
-        defaultStatus: 403,
-        defaultError: 'friend_request_not_allowed',
-      });
-      if (!canRequest.allowed) {
-        if (canRequest.body?.error === 'self_request_not_allowed') throw createSelfFriendRequestError();
-        throw createPolicyDecisionError(canRequest, 'friend_request_not_allowed');
-      }
-
-      const existingFriendship = resolveActiveFriendship(fromAgent.agentId, toAgent.agentId);
-      if (existingFriendship) {
-        return {
-          created: false,
-          alreadyFriends: true,
-          request: null,
-          friendship: projectFriendship(existingFriendship, fromAgent.agentId),
-        };
-      }
-
-      const pendingReverseRequest = sortByRecency(
-        friendshipStore.listFriendRequests({
-          fromAgentId: toAgent.agentId,
-          toAgentId: fromAgent.agentId,
-          status: 'pending',
-        }),
-        'createdAt',
-      )[0] || null;
-      if (pendingReverseRequest) throw createReversePendingRequestError(pendingReverseRequest);
-
-      const pendingSameDirection = sortByRecency(
-        friendshipStore.listFriendRequests({
-          fromAgentId: fromAgent.agentId,
-          toAgentId: toAgent.agentId,
-          status: 'pending',
-        }),
-        'createdAt',
-      )[0] || null;
-      if (pendingSameDirection) {
-        return {
-          created: false,
-          alreadyFriends: false,
-          request: projectFriendRequest(pendingSameDirection, fromAgent.agentId),
-          friendship: null,
-        };
-      }
-
-      const request = await friendshipStore.createFriendRequest({
-        fromAgentId: fromAgent.agentId,
-        toAgentId: toAgent.agentId,
-        message: normalizeMessage(message),
-        metadata,
-      });
-      return {
-        created: true,
-        alreadyFriends: false,
-        request: projectFriendRequest(request, fromAgent.agentId),
-        friendship: null,
-      };
-    },
-
-    listFriendRequests({ agentId, direction = null, status = null } = {}) {
-      const normalizedAgentId = normalizeAgentId(agentId);
-      requireAgent(normalizedAgentId);
-      const normalizedDirection = normalizeDirection(direction);
-      const normalizedStatus = normalizeStatus(status);
-      const friendshipStore = assertStore();
-
-      let items = [];
-      if (normalizedDirection === 'outbound') {
-        items = friendshipStore.listFriendRequests({ fromAgentId: normalizedAgentId, status: normalizedStatus });
-      } else if (normalizedDirection === 'inbound') {
-        items = friendshipStore.listFriendRequests({ toAgentId: normalizedAgentId, status: normalizedStatus });
-      } else {
-        items = friendshipStore
-          .listFriendRequests({ status: normalizedStatus })
-          .filter((request) => request.fromAgentId === normalizedAgentId || request.toAgentId === normalizedAgentId);
-      }
-
-      return {
-        items: sortByRecency(items, 'respondedAt', 'createdAt').map((request) => projectFriendRequest(request, normalizedAgentId)),
-      };
-    },
-
-    async acceptFriendRequest(friendRequestId, { actorAgentId } = {}) {
-      const friendshipStore = assertStore();
-      const request = friendshipStore.getFriendRequest(friendRequestId);
-      if (!request) throw createFriendRequestNotFoundError(friendRequestId);
-      requireAgent(actorAgentId);
-      if (request.toAgentId !== actorAgentId) throw createFriendRequestTargetOnlyError();
-
-      const existingAcceptedFriendship = request.friendshipId ? friendshipStore.getFriendship(request.friendshipId) : null;
-      if (request.status === 'accepted' && existingAcceptedFriendship) {
-        return {
-          created: false,
-          request: projectFriendRequest(request, actorAgentId),
-          friendship: projectFriendship(existingAcceptedFriendship, actorAgentId),
-        };
-      }
-
-      if (request.status !== 'pending') {
-        throw createFriendRequestNotPendingError(friendRequestId, request.status);
-      }
-
-      const now = friendshipStore.now();
-      const latestFriendship = resolveLatestFriendship(request.fromAgentId, request.toAgentId);
-      let friendship = resolveActiveFriendship(request.fromAgentId, request.toAgentId);
-      let created = false;
-
-      if (!friendship && latestFriendship) {
-        friendship = latestFriendship;
-        friendship.requestId = request.friendRequestId;
-        friendship.status = 'active';
-        friendship.updatedAt = now;
-        friendship.acceptedAt = now;
-        friendship.removedAt = null;
-        friendship.removedByAgentId = null;
-        friendship.source = 'friend_request';
-        await friendshipStore.markFriendshipUpdated();
-      }
-
-      if (!friendship) {
-        friendship = await friendshipStore.createFriendship({
-          requestId: request.friendRequestId,
-          agentAId: request.fromAgentId,
-          agentBId: request.toAgentId,
-          metadata: {
-            requestedByAgentId: request.fromAgentId,
-          },
-          source: 'friend_request',
-        });
-        created = true;
-      }
-
-      const grants = await ensureFriendshipApprovalGrants(friendship, request);
-      friendship.requestId = request.friendRequestId;
-      friendship.updatedAt = now;
-      friendship.acceptedAt = friendship.acceptedAt || now;
-      friendship.approvalGrantIds = grants.map((grant) => grant.grantId);
-      if (!created) {
-        await friendshipStore.markFriendshipUpdated();
-      }
-
-      request.status = 'accepted';
-      request.respondedAt = now;
-      request.acceptedByAgentId = actorAgentId;
-      request.rejectedByAgentId = null;
-      request.friendshipId = friendship.friendshipId;
-      request.approvalGrantIds = grants.map((grant) => grant.grantId);
-      await friendshipStore.markFriendRequestUpdated();
-
-      return {
-        created,
-        request: projectFriendRequest(request, actorAgentId),
-        friendship: projectFriendship(friendship, actorAgentId),
-      };
-    },
-
-    async rejectFriendRequest(friendRequestId, { actorAgentId } = {}) {
-      const friendshipStore = assertStore();
-      const request = friendshipStore.getFriendRequest(friendRequestId);
-      if (!request) throw createFriendRequestNotFoundError(friendRequestId);
-      requireAgent(actorAgentId);
-      if (request.toAgentId !== actorAgentId) throw createFriendRequestTargetOnlyError();
-      if (request.status !== 'pending') {
-        throw createFriendRequestNotPendingError(friendRequestId, request.status);
-      }
-
-      request.status = 'rejected';
-      request.respondedAt = friendshipStore.now();
-      request.rejectedByAgentId = actorAgentId;
-      request.acceptedByAgentId = null;
-      await friendshipStore.markFriendRequestUpdated();
-
-      return {
-        request: projectFriendRequest(request, actorAgentId),
-      };
-    },
-
-    listFriends({ agentId } = {}) {
-      const normalizedAgentId = normalizeAgentId(agentId);
-      requireAgent(normalizedAgentId);
-      const friendshipStore = assertStore();
-      return {
-        items: sortByRecency(
-          friendshipStore.listFriendships({ agentId: normalizedAgentId, status: 'active' }),
-          'updatedAt',
-          'acceptedAt',
-          'createdAt',
-        ).map((friendship) => projectFriendship(friendship, normalizedAgentId)),
-      };
-    },
-
-    async removeFriend({ actorAgentId, peerAgentId } = {}) {
-      const friendshipStore = assertStore();
-      requireAgent(actorAgentId);
-      requireAgent(peerAgentId);
-      const friendship = resolveActiveFriendship(actorAgentId, peerAgentId);
-      if (!friendship) throw createFriendshipNotFoundError(actorAgentId, peerAgentId);
-
-      const now = friendshipStore.now();
-      friendship.status = 'removed';
-      friendship.updatedAt = now;
-      friendship.removedAt = now;
-      friendship.removedByAgentId = actorAgentId;
-      await friendshipStore.markFriendshipUpdated();
-
-      let grantsUpdated = false;
-      for (const grant of resolveFriendshipGrants(friendship.friendshipId)) {
-        if (grant.status === 'revoked') continue;
-        grant.status = 'revoked';
-        grant.revokedAt = now;
-        grant.updatedAt = now;
-        grantsUpdated = true;
-      }
-      if (grantsUpdated) {
-        await friendshipStore.markApprovalGrantUpdated();
-      }
-
-      return {
-        friendship: projectFriendship(friendship, actorAgentId),
-      };
-    },
-  };
-}

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

@@ -1,21 +0,0 @@
-function sendSocialError(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 registerSocialRoutes(app, { socialService }) {
-  app.get('/v1/social/agents/lookup', (req, res) => {
-    try {
-      const result = socialService.lookupAgentByIdentity({
-        identity: req.query.identity,
-      });
-      res.json(result);
-    } catch (error) {
-      sendSocialError(res, error);
-    }
-  });
-}