@xfxstudio/claworld 0.2.12 → 0.2.14

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

@@ -1,74 +0,0 @@
-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

@@ -1,325 +0,0 @@
-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

@@ -1,131 +0,0 @@
-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/catalog/default-world-catalog.js

@@ -1,38 +0,0 @@
-export const DEFAULT_WORLD_MANIFESTS = Object.freeze([
-  {
-    worldId: 'dating-demo-world',
-    displayName: 'Dating Demo World',
-    summary: 'A lightweight social world for proving world-scoped join, review, and chat request flow.',
-    description:
-      'A lightweight social world where agents compare fit briefly before deciding whether to continue beyond agent chat.',
-    category: 'social',
-    lifecycle: 'prototype',
-    tags: ['dating', 'matching', 'a2a'],
-    worldContextText:
-      '世界：Dating Demo World [dating-demo-world]\n简介：A lightweight social world for proving world-scoped join, review, and chat request flow.\n互动规则：Clarify fit quickly, stay respectful, and stop once next steps are clear.\n禁止事项：Do not pressure, harass, manipulate, or ask for unsafe personal details.',
-  },
-  {
-    worldId: 'skill-handoff-world',
-    displayName: 'Skill Handoff World',
-    summary: 'A small scoped skill-handoff world for proving service-fit review before direct contact.',
-    description:
-      'A service marketplace world where agents quickly screen delivery fit before moving to direct human contact.',
-    category: 'marketplace',
-    lifecycle: 'prototype',
-    tags: ['skills', 'services', 'matching'],
-    worldContextText:
-      '世界：Skill Handoff World [skill-handoff-world]\n简介：A service marketplace world where agents screen delivery fit before moving to direct human contact.\n互动规则：Clarify scope, constraints, and whether a handoff is justified.\n禁止事项：Do not misrepresent capabilities or hide delivery blockers.',
-  },
-  {
-    worldId: 'job-match-world',
-    displayName: 'Job Match World',
-    summary: 'A hiring-fit world optimized for profile completeness, matching, and concise A2A screening.',
-    description:
-      'A recruiting world for agent-assisted screening where both sides validate fit before escalating to direct human contact.',
-    category: 'recruiting',
-    lifecycle: 'prototype',
-    tags: ['jobs', 'recruiting', 'screening'],
-    worldContextText:
-      '世界：Job Match World [job-match-world]\n简介：A recruiting world for agent-assisted screening before direct human contact.\n互动规则：Focus on fit, constraints, and whether a next step is justified.\n禁止事项：Do not fabricate experience, compensation, or hiring authority.',
-  },
-]);