@xfxstudio/claworld 0.2.11 → 0.2.13

package/src/product-shell/agent-cards/storage/local-public-storage.js

@@ -0,0 +1,74 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+function normalizeText(value, fallback = null) {
+  if (value == null) return fallback;
+  const normalized = String(value).trim();
+  return normalized || fallback;
+}
+
+function normalizePublicPath(filePath = '') {
+  return String(filePath).split(path.sep).join('/');
+}
+
+function parseExpiryEpochSeconds(value) {
+  const parsed = Number.parseInt(String(value || '').trim(), 10);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+}
+
+export function extractAgentCardExpiryEpochSeconds(relativeOrPublicPath = '') {
+  const normalizedPath = normalizePublicPath(String(relativeOrPublicPath || '')).replace(/^\/+/, '');
+  const parts = normalizedPath.split('/').filter(Boolean);
+  if (parts[0] !== 'ephemeral') return null;
+  return parseExpiryEpochSeconds(parts[1]);
+}
+
+export function createLocalPublicAgentCardStorage({
+  publicDir,
+  publicBasePath = '/public/agent-cards',
+} = {}) {
+  const normalizedPublicDir = normalizeText(publicDir, null);
+  if (!normalizedPublicDir) {
+    throw new Error('agent_card_public_dir_required');
+  }
+
+  return {
+    describeTarget({ contentHash, templateVersion = 'v1', expiresAt = null } = {}) {
+      const normalizedHash = normalizeText(contentHash, null);
+      if (!normalizedHash) throw new Error('agent_card_content_hash_required');
+      const expiresAtEpochSeconds = expiresAt ? parseExpiryEpochSeconds(Math.floor(Date.parse(expiresAt) / 1000)) : null;
+      const relativePath = expiresAtEpochSeconds
+        ? path.join(
+            'ephemeral',
+            String(expiresAtEpochSeconds),
+            normalizeText(templateVersion, 'v1'),
+            normalizedHash.slice(0, 2),
+            normalizedHash.slice(2, 4),
+            `${normalizedHash}.png`,
+          )
+        : path.join(
+            normalizeText(templateVersion, 'v1'),
+            normalizedHash.slice(0, 2),
+            normalizedHash.slice(2, 4),
+            `${normalizedHash}.png`,
+          );
+      return {
+        contentHash: normalizedHash,
+        expiresAt: expiresAtEpochSeconds ? new Date(expiresAtEpochSeconds * 1000).toISOString() : null,
+        expiresAtEpochSeconds,
+        isEphemeral: Boolean(expiresAtEpochSeconds),
+        relativePath,
+        absolutePath: path.join(normalizedPublicDir, relativePath),
+        publicPath: `${normalizeText(publicBasePath, '/public/agent-cards')}/${normalizePublicPath(relativePath)}`,
+      };
+    },
+    async exists(target) {
+      return await fs.pathExists(target.absolutePath);
+    },
+    async writePng(target, pngBuffer) {
+      await fs.ensureDir(path.dirname(target.absolutePath));
+      await fs.writeFile(target.absolutePath, pngBuffer);
+      return target;
+    },
+  };
+}

package/src/product-shell/agent-cards/svg-renderer.js

@@ -0,0 +1,325 @@
+import { Resvg } from '@resvg/resvg-js';
+import QRCode from 'qrcode';
+
+function normalizeText(value, fallback = null) {
+  if (value == null) return fallback;
+  const normalized = String(value).trim();
+  return normalized || fallback;
+}
+
+function escapeXml(value) {
+  return String(value || '')
+    .replaceAll('&', '&')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&apos;');
+}
+
+function truncateText(value, maxLength, fallback = '') {
+  const normalized = normalizeText(value, fallback) || fallback;
+  if (normalized.length <= maxLength) return normalized;
+  return `${normalized.slice(0, Math.max(1, maxLength - 1)).trimEnd()}…`;
+}
+
+function buildCtaMarkup(lines = []) {
+  return lines
+    .map((line, index) => {
+      const dy = index === 0 ? '0' : '48';
+      return `<tspan x="96" dy="${dy}">${escapeXml(truncateText(line, 84, ''))}</tspan>`;
+    })
+    .join('');
+}
+
+function buildSubtitleMarkup(text) {
+  const normalized = truncateText(text, 180, 'Agent-to-agent worlds on OpenClaw.');
+  const words = normalized.split(/\s+/g).filter(Boolean);
+  const lines = [];
+  let currentLine = '';
+
+  for (const word of words) {
+    const nextLine = currentLine ? `${currentLine} ${word}` : word;
+    if (nextLine.length > 42 && currentLine) {
+      lines.push(currentLine);
+      currentLine = word;
+      continue;
+    }
+    currentLine = nextLine;
+  }
+
+  if (currentLine) lines.push(currentLine);
+
+  return lines.slice(0, 3).map((line, index) => {
+    const dy = index === 0 ? '0' : '46';
+    return `<tspan x="96" dy="${dy}">${escapeXml(line)}</tspan>`;
+  }).join('');
+}
+
+async function buildQrDataUrl(targetUrl) {
+  return await QRCode.toDataURL(targetUrl, {
+    errorCorrectionLevel: 'M',
+    margin: 1,
+    width: 220,
+    color: {
+      dark: '#10203a',
+      light: '#0000',
+    },
+  });
+}
+
+function applyTemplate(source, replacements) {
+  return Object.entries(replacements).reduce(
+    (result, [token, value]) => result.replaceAll(`{{${token}}}`, value),
+    source,
+  );
+}
+
+function splitGraphemes(value) {
+  const normalized = String(value || '');
+  if (!normalized) return [];
+  if (typeof Intl?.Segmenter === 'function') {
+    const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
+    return Array.from(segmenter.segment(normalized), ({ segment }) => segment);
+  }
+  return Array.from(normalized);
+}
+
+function isFullWidthCodePoint(codePoint) {
+  return (
+    (codePoint >= 0x1100 && codePoint <= 0x115f) ||
+    (codePoint >= 0x2329 && codePoint <= 0x232a) ||
+    (codePoint >= 0x2e80 && codePoint <= 0xa4cf) ||
+    (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+    (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+    (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+    (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+    (codePoint >= 0xff01 && codePoint <= 0xff60) ||
+    (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+    (codePoint >= 0x1f300 && codePoint <= 0x1fbff)
+  );
+}
+
+function estimateGlyphWidthUnits(grapheme) {
+  if (!grapheme) return 0;
+  if (/^\s$/u.test(grapheme)) return 0.32;
+  if (/^[.,:;!|`'"’“”‘]$/u.test(grapheme)) return 0.28;
+  if (/^[()\[\]{}]$/u.test(grapheme)) return 0.36;
+  if (/^[-_=+\\/<>]$/u.test(grapheme)) return 0.48;
+  if (/^[#@%&*]$/u.test(grapheme)) return 0.72;
+  if (/^[0-9]$/u.test(grapheme)) return 0.56;
+  if (/^[A-Z]$/u.test(grapheme)) return /[MW]/u.test(grapheme) ? 0.9 : 0.68;
+  if (/^[a-z]$/u.test(grapheme)) return /[mw]/u.test(grapheme) ? 0.78 : 0.56;
+
+  const codePoint = grapheme.codePointAt(0);
+  if (codePoint == null) return 0.6;
+  if (isFullWidthCodePoint(codePoint)) return 1;
+  return 0.62;
+}
+
+export function estimateTextWidth(text, fontSize, { letterSpacing = 0 } = {}) {
+  if (!text || !fontSize) return 0;
+  const graphemes = splitGraphemes(text);
+  const glyphUnits = graphemes.reduce((total, grapheme) => total + estimateGlyphWidthUnits(grapheme), 0);
+  const spacingWidth = Math.max(0, graphemes.length - 1) * letterSpacing;
+  return (glyphUnits * fontSize) + spacingWidth;
+}
+
+function parseNumericAttribute(value, fallback = null) {
+  if (value == null) return fallback;
+  const parsed = Number.parseFloat(String(value));
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function parseLetterSpacing(value, fontSize) {
+  if (!value) return 0;
+  const normalized = String(value).trim();
+  if (!normalized || normalized === 'normal') return 0;
+  if (normalized.endsWith('em')) return parseNumericAttribute(normalized.slice(0, -2), 0) * fontSize;
+  if (normalized.endsWith('px')) return parseNumericAttribute(normalized.slice(0, -2), 0);
+  return parseNumericAttribute(normalized, 0);
+}
+
+function formatFontSize(value) {
+  const rounded = Math.round(value * 10) / 10;
+  return Number.isInteger(rounded) ? String(rounded) : String(rounded);
+}
+
+function shrinkTextToFitSingleLine(value, {
+  maxWidth,
+  maxFontSize,
+  minFontSize,
+  letterSpacing = 0,
+} = {}) {
+  const text = String(value || '');
+  if (!text) {
+    return {
+      text,
+      fontSize: formatFontSize(maxFontSize || minFontSize || 16),
+    };
+  }
+
+  const widthAtMax = estimateTextWidth(text, maxFontSize, { letterSpacing });
+  if (!maxWidth || !maxFontSize || widthAtMax <= maxWidth) {
+    return {
+      text,
+      fontSize: formatFontSize(maxFontSize || minFontSize || 16),
+    };
+  }
+
+  const scaledFontSize = Math.max(
+    minFontSize || maxFontSize,
+    Math.min(maxFontSize, (maxFontSize * maxWidth) / Math.max(widthAtMax, 1)),
+  );
+
+  if (scaledFontSize > (minFontSize || maxFontSize)) {
+    return {
+      text,
+      fontSize: formatFontSize(scaledFontSize),
+    };
+  }
+
+  if (estimateTextWidth(text, minFontSize, { letterSpacing }) <= maxWidth) {
+    return {
+      text,
+      fontSize: formatFontSize(minFontSize),
+    };
+  }
+
+  const graphemes = splitGraphemes(text);
+  let keptLength = graphemes.length;
+  while (keptLength > 1) {
+    const candidate = `${graphemes.slice(0, keptLength).join('').trimEnd()}…`;
+    if (estimateTextWidth(candidate, minFontSize, { letterSpacing }) <= maxWidth) {
+      return {
+        text: candidate,
+        fontSize: formatFontSize(minFontSize),
+      };
+    }
+    keptLength -= 1;
+  }
+
+  return {
+    text: '…',
+    fontSize: formatFontSize(minFontSize || maxFontSize || 16),
+  };
+}
+
+function parseTextTagAttributes(attributeSource) {
+  const attributes = {};
+  const pattern = /([:@\w.-]+)\s*=\s*(['"])(.*?)\2/gs;
+  for (const match of attributeSource.matchAll(pattern)) {
+    attributes[match[1]] = match[3];
+  }
+  return attributes;
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function setSvgAttribute(attributeSource, name, value) {
+  const replacement = `${name}="${value}"`;
+  const escapedName = escapeRegExp(name);
+  const pattern = new RegExp(`(^|\\s)(${escapedName}\\s*=\\s*)(['"]).*?\\3`, 's');
+  if (pattern.test(attributeSource)) {
+    return attributeSource.replace(pattern, (match, prefix) => `${prefix}${replacement}`);
+  }
+  return `${attributeSource} ${replacement}`;
+}
+
+function resolveSlotTextValue({ field, token, spec }) {
+  const fieldValue = field ? spec?.[field] : undefined;
+  if (fieldValue != null && fieldValue !== '') return String(fieldValue);
+
+  switch (token) {
+    case 'DISPLAY_NAME':
+      return spec?.displayName ?? 'Claworld Agent';
+    case 'PUBLIC_HANDLE':
+      return spec?.publicHandle ?? 'agent#0000';
+    case 'TITLE':
+      return spec?.title ?? 'Claworld Agent Card';
+    case 'BADGE_TEXT':
+      return spec?.badgeText ?? 'Preview';
+    case 'FOOTER_LABEL':
+      return spec?.footerLabel ?? 'claworld.love';
+    case 'AVATAR_INITIALS':
+      return spec?.avatarInitials ?? 'C';
+    default:
+      return null;
+  }
+}
+
+export function applyAdaptiveTextSlots(source, { spec } = {}) {
+  if (!source || !spec) return source;
+
+  return source.replace(/<text\b(?<attributes>[^>]*)>(?<content>[\s\S]*?)<\/text>/g, (fullMatch, rawAttributes, rawContent) => {
+    const attributes = parseTextTagAttributes(rawAttributes);
+    const token = attributes['data-token'];
+    const field = attributes['data-field'];
+    if (!token && !field) return fullMatch;
+
+    const resolvedValue = resolveSlotTextValue({ field, token, spec });
+    if (resolvedValue == null) return fullMatch;
+
+    const trimWhitespace = attributes['data-trim-whitespace'] === 'true';
+    const normalizedValue = trimWhitespace ? normalizeText(resolvedValue, '') || '' : String(resolvedValue);
+    const layout = attributes['data-layout'];
+    const overflow = attributes['data-overflow'];
+
+    let nextText = normalizedValue;
+    let nextAttributes = rawAttributes;
+
+    if (layout === 'single-line' && overflow === 'shrink-font-only') {
+      const maxWidth = parseNumericAttribute(attributes['data-max-width']);
+      const maxFontSize = parseNumericAttribute(attributes['data-max-font-size'], parseNumericAttribute(attributes['font-size'], 16));
+      const minFontSize = parseNumericAttribute(attributes['data-min-font-size'], maxFontSize);
+      const letterSpacing = parseLetterSpacing(attributes['letter-spacing'], maxFontSize);
+      const fitted = shrinkTextToFitSingleLine(normalizedValue, {
+        maxWidth,
+        maxFontSize,
+        minFontSize,
+        letterSpacing,
+      });
+      nextText = fitted.text;
+      nextAttributes = setSvgAttribute(nextAttributes, 'font-size', fitted.fontSize);
+    }
+
+    return `<text${nextAttributes}>${escapeXml(nextText)}</text>`;
+  });
+}
+
+export function createAgentCardSvgRenderer() {
+  return {
+    async renderCard({ template, spec } = {}) {
+      if (!template?.source) throw new Error('agent_card_template_source_missing');
+      if (!spec || typeof spec !== 'object') throw new Error('agent_card_spec_missing');
+
+      const qrDataUrl = await buildQrDataUrl(spec.qrTargetUrl);
+      const svg = applyTemplate(applyAdaptiveTextSlots(template.source, { spec }), {
+        DISPLAY_NAME: escapeXml(truncateText(spec.displayName, 40, 'Claworld Agent')),
+        PUBLIC_HANDLE: escapeXml(truncateText(spec.publicHandle, 48, 'agent#0000')),
+        TITLE: escapeXml(truncateText(spec.title, 56, 'Claworld Agent Card')),
+        SUBTITLE_LINES: buildSubtitleMarkup(spec.subtitle),
+        CTA_LINES: buildCtaMarkup(spec.ctaLines),
+        FOOTER_LABEL: escapeXml(truncateText(spec.footerLabel, 80, 'claworld.love')),
+        BADGE_TEXT: escapeXml(truncateText(spec.badgeText, 24, 'Preview')),
+        AVATAR_INITIALS: escapeXml(truncateText(spec.avatarInitials, 2, 'C')),
+        QR_DATA_URL: escapeXml(qrDataUrl),
+      });
+
+      const resvg = new Resvg(svg, {
+        fitTo: {
+          mode: 'width',
+          value: template.width || 1200,
+        },
+        font: {
+          loadSystemFonts: true,
+          defaultFontFamily: 'Arial',
+        },
+      });
+
+      const image = resvg.render();
+      return image.asPng();
+    },
+  };
+}

package/src/product-shell/agent-cards/template-registry.js

@@ -0,0 +1,131 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const TEMPLATE_DEFINITIONS = Object.freeze([
+  {
+    templateId: 'agent-card.figma-v2',
+    templateVersion: 'v1',
+    width: 1077,
+    height: 1443,
+    templatePath: path.join(__dirname, 'templates', 'agent-card.figma-v2.svg'),
+    description: 'Embedded Figma-export card with centered name/handle over the illustrated shrimp poster.',
+  },
+  {
+    templateId: 'agent-card.slot-01',
+    templateVersion: 'v1',
+    width: 1792,
+    height: 2400,
+    templatePath: path.join(__dirname, 'templates', 'agent-card.slot-01.svg'),
+    description: 'Slot-driven poster card with wide centered name/handle fields and shrink-to-fit metadata.',
+  },
+  {
+    templateId: 'agent-card.slot-02',
+    templateVersion: 'v1',
+    width: 1792,
+    height: 2400,
+    templatePath: path.join(__dirname, 'templates', 'agent-card.slot-02.svg'),
+    description: 'Slot-driven right-side card with centered adaptive text fields and tighter width constraints.',
+  },
+  {
+    templateId: 'agent-card.slot-03',
+    templateVersion: 'v1',
+    width: 1792,
+    height: 2400,
+    templatePath: path.join(__dirname, 'templates', 'agent-card.slot-03.svg'),
+    description: 'Slot-driven wide centered card with larger adaptive text fields over an embedded background.',
+  },
+  {
+    templateId: 'agent-card.slot-04',
+    templateVersion: 'v1',
+    width: 1792,
+    height: 2400,
+    templatePath: path.join(__dirname, 'templates', 'agent-card.slot-04.svg'),
+    description: 'Slot-driven centered card with compact adaptive text fields over an embedded earthy background.',
+  },
+  {
+    templateId: 'agent-card.slot-05',
+    templateVersion: 'v1',
+    width: 1792,
+    height: 2400,
+    templatePath: path.join(__dirname, 'templates', 'agent-card.slot-05.svg'),
+    description: 'Figma-adjusted poster card with left-anchored adaptive name and handle slots.',
+  },
+  {
+    templateId: 'agent-card.slot-06',
+    templateVersion: 'v1',
+    width: 1792,
+    height: 2400,
+    templatePath: path.join(__dirname, 'templates', 'agent-card.slot-06.svg'),
+    description: 'Slot-driven right-column card with centered adaptive text fields over an embedded background.',
+  },
+  {
+    templateId: 'agent-card.slot-07',
+    templateVersion: 'v1',
+    width: 1792,
+    height: 2400,
+    templatePath: path.join(__dirname, 'templates', 'agent-card.slot-07.svg'),
+    description: 'Figma-adjusted warm poster card with large left-anchored adaptive name and handle slots.',
+  },
+  {
+    templateId: 'agent-card.slot-08',
+    templateVersion: 'v1',
+    width: 1792,
+    height: 2400,
+    templatePath: path.join(__dirname, 'templates', 'agent-card.slot-08.svg'),
+    description: 'Figma-adjusted rotated poster card with adaptive slanted name and handle slots.',
+  },
+]);
+
+function normalizeText(value, fallback = null) {
+  if (value == null) return fallback;
+  const normalized = String(value).trim();
+  return normalized || fallback;
+}
+
+export function createAgentCardTemplateRegistry() {
+  const sourceCache = new Map();
+  const templatesById = new Map(TEMPLATE_DEFINITIONS.map((template) => [template.templateId, template]));
+
+  async function loadSource(template) {
+    const cached = sourceCache.get(template.templateId);
+    if (cached) return cached;
+    const source = await fs.readFile(template.templatePath, 'utf8');
+    sourceCache.set(template.templateId, source);
+    return source;
+  }
+
+  return {
+    listTemplates() {
+      return TEMPLATE_DEFINITIONS.map((template) => ({
+        templateId: template.templateId,
+        templateVersion: template.templateVersion,
+        width: template.width,
+        height: template.height,
+        description: template.description,
+      }));
+    },
+    async getTemplate(templateId = TEMPLATE_DEFINITIONS[0].templateId) {
+      const normalizedTemplateId = normalizeText(templateId, TEMPLATE_DEFINITIONS[0].templateId);
+      const template = templatesById.get(normalizedTemplateId) || null;
+      if (!template) {
+        const error = new Error(`unknown_agent_card_template:${normalizedTemplateId}`);
+        error.code = 'unknown_agent_card_template';
+        error.status = 404;
+        error.responseBody = {
+          error: error.code,
+          message: 'agent card template not found',
+          templateId: normalizedTemplateId,
+        };
+        throw error;
+      }
+
+      return {
+        ...template,
+        source: await loadSource(template),
+      };
+    },
+  };
+}

package/src/product-shell/index.js

@@ -7,6 +7,7 @@ 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 { createProfileService } from './profile/profile-service.js';
 import { registerPublicIdentityRoutes } from './profile/public-identity-routes.js';
 import { createMembershipService } from './membership/membership-service.js';
 import { createMatchmakingService } from './matching/matchmaking-service.js';
@@ -21,22 +22,25 @@ 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';
+import { createAgentCardService } from './agent-cards/card-service.js';
+import { registerAgentCardRoutes } from './agent-cards/card-routes.js';
 
 export function createClaworldProductShell({
   worldCatalog = DEFAULT_WORLD_MANIFESTS,
   relay = null,
   store = null,
   presence = null,
+  agentCard = {},
 } = {}) {
   const worldService = createWorldService({ worldCatalog, store });
+  const conversationFeedbackService = createConversationFeedbackService({ store });
   const onboardingService = createOnboardingService({ worldService, store });
-  const publicIdentityService = createPublicIdentityService({ store });
+  const publicIdentityService = createPublicIdentityService({ store, conversationFeedbackService });
   const membershipService = createMembershipService({ worldService, store, publicIdentityService });
   const worldAuthorizationService = createWorldAuthorizationService({
     worldService,
     membershipService,
   });
-  const conversationFeedbackService = createConversationFeedbackService({ store });
   const matchmakingService = createMatchmakingService({
     worldService,
     worldAuthorizationService,
@@ -77,7 +81,14 @@ export function createClaworldProductShell({
   const friendService = createFriendService({ store, policy: relay?.policy, publicIdentityService });
   const socialLookupService = createSocialService({ worldService, store });
   const feedbackService = createFeedbackService({ store });
-  const profileService = createPublicIdentityService({ store, conversationFeedbackService });
+  const agentCardService = createAgentCardService({
+    store,
+    ...agentCard,
+  });
+  const profileService = createProfileService({
+    publicIdentityService,
+    agentCardService,
+  });
   const socialService = {
     ...friendService,
     lookupAgentByIdentity(input) {
@@ -103,6 +114,8 @@ export function createClaworldProductShell({
       moderation: worldAdminService,
       feedback: feedbackService,
       conversationFeedback: conversationFeedbackService,
+      agentCards: agentCardService,
+      conversationFeedback: conversationFeedbackService,
       orchestration: worldConversationOrchestrator,
     },
     registerRoutes(app) {
@@ -123,6 +136,7 @@ export function createClaworldProductShell({
       });
       registerSocialRoutes(app, { socialService: socialLookupService });
       registerFeedbackRoutes(app, { store, feedbackService });
+      registerAgentCardRoutes(app, { store, agentCardService });
     },
     describe() {
       return {
@@ -141,11 +155,18 @@ export function createClaworldProductShell({
           'moderation',
           'feedback',
           'conversationFeedback',
+          'agentCards',
+          'conversationFeedback',
+          'agentCards',
           'orchestration',
         ],
         routes: [
           'GET /v1/meta/product-shell',
+          'GET /v1/meta/agent-cards',
           'GET /v1/meta/install',
+          'POST /v1/agent-cards/render',
+          'GET /v1/profile',
+          'POST /v1/profile',
           'GET /v1/onboarding/plan',
           'POST /v1/onboarding/activate',
           'GET /v1/profile/public-identity',