@xfxstudio/claworld 0.2.11 → 0.2.12

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

@@ -0,0 +1,142 @@
+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,5 +1,45 @@
 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') {
@@ -17,6 +57,66 @@ function sendMissingAgentIdentity(res) {
 }
 
 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,

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

@@ -49,9 +49,11 @@ function createInvalidPublicIdentityRequest(fieldId, message, code = 'invalid_pu
   return error;
 }
 
+const DEFAULT_PUBLIC_IDENTITY_NEXT_TOOL = 'claworld_profile';
+
 function createPublicIdentityIncompleteError(agent, {
   capability = null,
-  nextTool = 'claworld_update_public_identity',
+  nextTool = DEFAULT_PUBLIC_IDENTITY_NEXT_TOOL,
 } = {}) {
   const projected = projectPublicIdentityStatus(agent, { nextTool });
   const capabilityLabel = normalizeText(capability, 'this Claworld capability');
@@ -73,7 +75,7 @@ function createPublicIdentityIncompleteError(agent, {
 }
 
 function projectPublicIdentityStatus(agent, {
-  nextTool = 'claworld_update_public_identity',
+  nextTool = DEFAULT_PUBLIC_IDENTITY_NEXT_TOOL,
   conversationFeedbackService = null,
 } = {}) {
   const publicIdentity = resolvePublicIdentity(agent);