@xfxstudio/claworld 2026.4.14-testing.1 → 2026.4.16-testing.1

package/src/openclaw/runtime/world-moderation-helper.js

@@ -1,508 +0,0 @@
-import { resolveClaworldRuntimeConfig } from '../plugin/config-schema.js';
-import { buildRuntimeAuthHeaders } from '../plugin/account-identity.js';
-import { createRuntimeBoundaryError } from '../../lib/runtime-errors.js';
-import { extractBackendErrorContext } from './backend-error-context.js';
-import { normalizeWorldJoinResponse } from './product-shell-helper.js';
-
-function normalizeText(value, fallback = null) {
-  if (value == null) return fallback;
-  const normalized = String(value).trim();
-  return normalized || fallback;
-}
-
-function normalizeInteger(value, fallback = 0) {
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed)) return fallback;
-  return Math.max(0, Math.trunc(parsed));
-}
-
-function normalizeOptionalBoolean(value, fallback = null) {
-  if (typeof value === 'boolean') return value;
-  return fallback;
-}
-
-function normalizeOptionalInteger(value, fallback = null) {
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed)) return fallback;
-  return Math.trunc(parsed);
-}
-
-function normalizePositiveInteger(value, fallback = null) {
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
-  return Math.max(1, Math.trunc(parsed));
-}
-
-function normalizeStringList(values = []) {
-  if (!Array.isArray(values)) return [];
-  return [...new Set(values.map((value) => normalizeText(value, null)).filter(Boolean))];
-}
-
-function normalizeParticipantContextField(field = {}, index = 0) {
-  return {
-    fieldId: normalizeText(field.fieldId, `field_${index + 1}`),
-    label: normalizeText(field.label, `Field ${index + 1}`),
-    type: normalizeText(field.type, 'string'),
-    required: typeof field.required === 'boolean' ? field.required : null,
-    searchable: typeof field.searchable === 'boolean' ? field.searchable : null,
-    description: normalizeText(field.description, null),
-    examples: normalizeStringList(field.examples),
-  };
-}
-
-function normalizeParticipantContextFieldPayload(field = null) {
-  if (!field || typeof field !== 'object' || Array.isArray(field)) return null;
-  return normalizeParticipantContextField(field);
-}
-
-function normalizeWorldStats(stats = null) {
-  if (!stats || typeof stats !== 'object' || Array.isArray(stats)) return null;
-  return {
-    totalParticipants: normalizeOptionalInteger(stats.totalParticipants, null),
-    activeParticipants: normalizeOptionalInteger(stats.activeParticipants, null),
-    totalConversationCount: normalizeOptionalInteger(stats.totalConversationCount, null),
-  };
-}
-
-function normalizeWorldRole(worldRole, fallback = null) {
-  const normalized = normalizeText(worldRole, fallback);
-  return ['owner', 'member'].includes(normalized) ? normalized : fallback;
-}
-
-function normalizeBroadcastAudience(value, fallback = 'members') {
-  const normalized = normalizeText(value, fallback);
-  if (normalized === 'admins') return 'admins';
-  if (normalized === 'admins_and_owner') return 'admins_and_owner';
-  return 'members';
-}
-
-function normalizeBroadcastReplyPolicy(value, fallback = 'zero') {
-  const normalized = normalizeText(value, fallback);
-  if (normalized === 'at_most_one') return 'at_most_one';
-  return 'zero';
-}
-
-function normalizeWorldBroadcastConfig(broadcast = null) {
-  if (!broadcast || typeof broadcast !== 'object' || Array.isArray(broadcast)) return null;
-  return {
-    enabled: normalizeOptionalBoolean(broadcast.enabled, null),
-    audience: normalizeBroadcastAudience(broadcast.audience, 'members'),
-    replyPolicy: normalizeBroadcastReplyPolicy(broadcast.replyPolicy, 'zero'),
-    excludeSelf: normalizeOptionalBoolean(broadcast.excludeSelf, null),
-  };
-}
-
-function normalizeManagedWorld(payload = {}) {
-  return {
-    worldId: normalizeText(payload.worldId, null),
-    displayName: normalizeText(payload.displayName, null),
-    worldContextText: normalizeText(payload.worldContextText, null),
-    ownerAgentId: normalizeText(payload.ownerAgentId, null),
-    enabled: normalizeOptionalBoolean(payload.enabled, null),
-    status: normalizeText(payload.status, null),
-    worldRole: normalizeWorldRole(payload.worldRole, null),
-    schemaVersion: normalizeOptionalInteger(payload.schemaVersion, null),
-    createdAt: normalizeText(payload.createdAt, null),
-    updatedAt: normalizeText(payload.updatedAt, null),
-    participantContextField: normalizeParticipantContextFieldPayload(payload.participantContextField),
-    broadcast: normalizeWorldBroadcastConfig(payload.broadcast),
-    stats: normalizeWorldStats(payload.stats),
-  };
-}
-
-function normalizeCreatedWorld(payload = {}) {
-  const world = normalizeManagedWorld(payload);
-  return {
-    ...world,
-    ownerJoin:
-      payload.ownerJoin && typeof payload.ownerJoin === 'object'
-        ? normalizeWorldJoinResponse(payload.ownerJoin, {
-          worldId: world.worldId,
-          agentId: world.ownerAgentId,
-        })
-        : null,
-  };
-}
-
-function normalizeOwnedWorldSummary(payload = {}) {
-  return {
-    worldId: normalizeText(payload.worldId, null),
-    displayName: normalizeText(payload.displayName, null),
-    worldContextText: normalizeText(payload.worldContextText, null),
-    ownerAgentId: normalizeText(payload.ownerAgentId, null),
-    enabled: normalizeOptionalBoolean(payload.enabled, null),
-    status: normalizeText(payload.status, null),
-    worldRole: normalizeWorldRole(payload.worldRole, null),
-    createdAt: normalizeText(payload.createdAt, null),
-    updatedAt: normalizeText(payload.updatedAt, null),
-    broadcast: normalizeWorldBroadcastConfig(payload.broadcast),
-    stats: normalizeWorldStats(payload.stats),
-  };
-}
-
-function normalizeWorldBroadcastRequestItem(item = {}) {
-  return {
-    agentId: normalizeText(item.agentId, null),
-    status: normalizeText(item.status, null),
-    verdict: normalizeText(item.verdict, null),
-    chatRequest: item.chatRequest && typeof item.chatRequest === 'object' && !Array.isArray(item.chatRequest)
-      ? item.chatRequest
-      : null,
-    kickoff: item.kickoff && typeof item.kickoff === 'object' && !Array.isArray(item.kickoff)
-      ? item.kickoff
-      : null,
-  };
-}
-
-function normalizeWorldBroadcastFailureItem(item = {}) {
-  return {
-    agentId: normalizeText(item.agentId, null),
-    status: normalizeText(item.status, 'failed'),
-    httpStatus: normalizeOptionalInteger(item.httpStatus, null),
-    error: normalizeText(item.error, null),
-    reason: normalizeText(item.reason, null),
-    message: normalizeText(item.message, null),
-  };
-}
-
-function normalizeWorldBroadcastResponse(payload = {}) {
-  return {
-    status: normalizeText(payload.status, null),
-    worldId: normalizeText(payload.worldId, null),
-    senderAgentId: normalizeText(payload.senderAgentId, null),
-    senderRole: normalizeWorldRole(payload.senderRole, null),
-    audience: normalizeBroadcastAudience(payload.audience, 'members'),
-    excludeSelf: normalizeOptionalBoolean(payload.excludeSelf, null),
-    eligibility: normalizeText(payload.eligibility, null),
-    broadcastId: normalizeText(payload.broadcastId, null),
-    totalTargets: normalizeOptionalInteger(payload.totalTargets, null),
-    createdCount: normalizeOptionalInteger(payload.createdCount, null),
-    failedCount: normalizeOptionalInteger(payload.failedCount, null),
-    pendingCount: normalizeOptionalInteger(payload.pendingCount, null),
-    autoAcceptedCount: normalizeOptionalInteger(payload.autoAcceptedCount, null),
-    rejectedCount: normalizeOptionalInteger(payload.rejectedCount, null),
-    nextAction: normalizeText(payload.nextAction, null),
-    requests: Array.isArray(payload.requests)
-      ? payload.requests.map((item) => normalizeWorldBroadcastRequestItem(item))
-      : [],
-    failures: Array.isArray(payload.failures)
-      ? payload.failures.map((item) => normalizeWorldBroadcastFailureItem(item))
-      : [],
-  };
-}
-
-async function fetchJson(fetchImpl, url, init = {}) {
-  let response;
-  try {
-    response = await fetchImpl(url, init);
-  } catch (error) {
-    throw createRuntimeBoundaryError({
-      code: 'relay_fetch_failed',
-      category: 'transport',
-      status: 502,
-      message: `fetch failed: ${error?.message || String(error)}`,
-      publicMessage: 'relay fetch failed',
-      recoverable: true,
-      context: {
-        fetchUrl: url,
-        fetchMethod: init?.method || 'GET',
-      },
-      cause: error,
-    });
-  }
-  let body = null;
-  try {
-    body = await response.json();
-  } catch {
-    body = null;
-  }
-  return { ok: response.ok, status: response.status, body };
-}
-
-function normalizeRelayHttpBaseUrl(serverUrl) {
-  const parsed = new URL(serverUrl);
-  if (parsed.protocol === 'ws:') parsed.protocol = 'http:';
-  if (parsed.protocol === 'wss:') parsed.protocol = 'https:';
-  parsed.pathname = '';
-  parsed.search = '';
-  parsed.hash = '';
-  return parsed.toString().replace(/\/$/, '');
-}
-
-function inferHttpErrorCategory(status) {
-  if (status === 401) return 'auth';
-  if (status === 403) return 'policy';
-  if (status === 409) return 'conflict';
-  if (status >= 400 && status < 500) return 'input';
-  return 'runtime';
-}
-
-function createModerationHttpError(action, response, { accountId = null, worldId = null } = {}) {
-  const backendCode = normalizeText(response?.body?.error, null);
-  const backendMessage = normalizeText(response?.body?.message, `claworld world ${action} failed`);
-
-  return createRuntimeBoundaryError({
-    code: backendCode || `claworld_world_${action}_failed`,
-    category: inferHttpErrorCategory(response?.status),
-    status: response?.status ?? 500,
-    message: `claworld world ${action} failed: ${response?.status ?? 500}`,
-    publicMessage: backendMessage,
-    recoverable: Number(response?.status) >= 400 && Number(response?.status) < 500,
-    context: {
-      action: `world_${action}`,
-      accountId,
-      ...(worldId ? { worldId } : {}),
-      httpStatus: response?.status ?? 500,
-      ...extractBackendErrorContext(response?.body),
-    },
-  });
-}
-
-export async function createModeratedWorld({
-  cfg = {},
-  accountId = null,
-  runtimeConfig = null,
-  agentId = null,
-  displayName = null,
-  worldContextText = null,
-  participantContextText = null,
-  enabled = true,
-  fetchImpl,
-  logger = console,
-} = {}) {
-  if (typeof fetchImpl !== 'function') {
-    throw new Error('fetch is unavailable for claworld world creation helper');
-  }
-
-  const resolvedAgentId = normalizeText(agentId, null);
-  if (!resolvedAgentId) {
-    throw new Error('claworld world creation helper requires agentId');
-  }
-
-  const resolvedRuntimeConfig = runtimeConfig || resolveClaworldRuntimeConfig(cfg, accountId);
-  const baseUrl = normalizeRelayHttpBaseUrl(resolvedRuntimeConfig.serverUrl);
-  const created = await fetchJson(fetchImpl, `${baseUrl}/v1/worlds`, {
-    method: 'POST',
-    headers: buildRuntimeAuthHeaders(resolvedRuntimeConfig, {
-      accept: 'application/json',
-      'content-type': 'application/json',
-      ...(resolvedRuntimeConfig.apiKey ? { 'x-api-key': resolvedRuntimeConfig.apiKey } : {}),
-    }),
-    body: JSON.stringify({
-      agentId: resolvedAgentId,
-      displayName,
-      worldContextText,
-      participantContextText: normalizeText(participantContextText, null),
-      enabled,
-    }),
-  });
-
-  if (!created.ok) {
-    logger.error?.('[claworld:moderation] world create failed', {
-      status: created.status,
-      accountId: resolvedRuntimeConfig.accountId || accountId || null,
-      body: created.body,
-    });
-    throw createModerationHttpError('create', created, {
-      accountId: resolvedRuntimeConfig.accountId || accountId || null,
-    });
-  }
-
-  return normalizeCreatedWorld(created.body);
-}
-
-export async function fetchOwnedWorlds({
-  cfg = {},
-  accountId = null,
-  runtimeConfig = null,
-  agentId = null,
-  includeDisabled = true,
-  fetchImpl,
-  logger = console,
-} = {}) {
-  if (typeof fetchImpl !== 'function') {
-    throw new Error('fetch is unavailable for claworld owned-worlds helper');
-  }
-
-  const resolvedAgentId = normalizeText(agentId, null);
-  if (!resolvedAgentId) {
-    throw new Error('claworld owned-worlds helper requires agentId');
-  }
-
-  const resolvedRuntimeConfig = runtimeConfig || resolveClaworldRuntimeConfig(cfg, accountId);
-  const baseUrl = normalizeRelayHttpBaseUrl(resolvedRuntimeConfig.serverUrl);
-  const requestUrl = new URL(`${baseUrl}/v1/moderation/worlds`);
-  requestUrl.searchParams.set('agentId', resolvedAgentId);
-  requestUrl.searchParams.set('includeDisabled', includeDisabled ? 'true' : 'false');
-  const result = await fetchJson(fetchImpl, requestUrl.toString(), {
-    headers: buildRuntimeAuthHeaders(resolvedRuntimeConfig, {
-      accept: 'application/json',
-      ...(resolvedRuntimeConfig.apiKey ? { 'x-api-key': resolvedRuntimeConfig.apiKey } : {}),
-    }),
-  });
-
-  if (!result.ok) {
-    logger.error?.('[claworld:moderation] managed worlds fetch failed', {
-      status: result.status,
-      accountId: resolvedRuntimeConfig.accountId || accountId || null,
-      body: result.body,
-    });
-    throw createModerationHttpError('list', result, {
-      accountId: resolvedRuntimeConfig.accountId || accountId || null,
-    });
-  }
-
-  return {
-    items: Array.isArray(result.body?.items) ? result.body.items.map((item) => normalizeOwnedWorldSummary(item)) : [],
-  };
-}
-
-export async function manageModeratedWorld({
-  cfg = {},
-  accountId = null,
-  runtimeConfig = null,
-  agentId = null,
-  worldId = null,
-  mode = 'get',
-  changes = null,
-  enabled = null,
-  status = null,
-  fetchImpl,
-  logger = console,
-} = {}) {
-  if (typeof fetchImpl !== 'function') {
-    throw new Error('fetch is unavailable for claworld world management helper');
-  }
-
-  const resolvedAgentId = normalizeText(agentId, null);
-  if (!resolvedAgentId) {
-    throw new Error('claworld world management helper requires agentId');
-  }
-  const resolvedWorldId = normalizeText(worldId, null);
-  if (!resolvedWorldId) {
-    throw new Error('claworld world management helper requires worldId');
-  }
-
-  const resolvedRuntimeConfig = runtimeConfig || resolveClaworldRuntimeConfig(cfg, accountId);
-  const baseUrl = normalizeRelayHttpBaseUrl(resolvedRuntimeConfig.serverUrl);
-
-  if (normalizeText(mode, 'get') === 'get') {
-    const requestUrl = new URL(`${baseUrl}/v1/moderation/worlds/${encodeURIComponent(resolvedWorldId)}`);
-    requestUrl.searchParams.set('agentId', resolvedAgentId);
-    const result = await fetchJson(fetchImpl, requestUrl.toString(), {
-      headers: buildRuntimeAuthHeaders(resolvedRuntimeConfig, {
-        accept: 'application/json',
-        ...(resolvedRuntimeConfig.apiKey ? { 'x-api-key': resolvedRuntimeConfig.apiKey } : {}),
-      }),
-    });
-
-    if (!result.ok) {
-      logger.error?.('[claworld:moderation] managed world fetch failed', {
-        status: result.status,
-        worldId: resolvedWorldId,
-        accountId: resolvedRuntimeConfig.accountId || accountId || null,
-        body: result.body,
-      });
-      throw createModerationHttpError('get', result, {
-        accountId: resolvedRuntimeConfig.accountId || accountId || null,
-        worldId: resolvedWorldId,
-      });
-    }
-
-    return normalizeManagedWorld(result.body);
-  }
-
-  const result = await fetchJson(fetchImpl, `${baseUrl}/v1/moderation/worlds/${encodeURIComponent(resolvedWorldId)}`, {
-    method: 'PATCH',
-    headers: buildRuntimeAuthHeaders(resolvedRuntimeConfig, {
-      accept: 'application/json',
-      'content-type': 'application/json',
-      ...(resolvedRuntimeConfig.apiKey ? { 'x-api-key': resolvedRuntimeConfig.apiKey } : {}),
-    }),
-    body: JSON.stringify({
-      agentId: resolvedAgentId,
-      ...(changes && typeof changes === 'object' ? { changes } : {}),
-      ...(enabled == null ? {} : { enabled }),
-      ...(normalizeText(status, null) ? { status: normalizeText(status, null) } : {}),
-    }),
-  });
-
-  if (!result.ok) {
-    logger.error?.('[claworld:moderation] managed world update failed', {
-      status: result.status,
-      worldId: resolvedWorldId,
-      accountId: resolvedRuntimeConfig.accountId || accountId || null,
-      body: result.body,
-    });
-    throw createModerationHttpError('update', result, {
-      accountId: resolvedRuntimeConfig.accountId || accountId || null,
-      worldId: resolvedWorldId,
-    });
-  }
-
-  return normalizeManagedWorld(result.body);
-}
-
-export async function broadcastModeratedWorld({
-  cfg = {},
-  accountId = null,
-  runtimeConfig = null,
-  agentId = null,
-  worldId = null,
-  announcementText = null,
-  audience = null,
-  excludeSelf = null,
-  fetchImpl,
-  logger = console,
-} = {}) {
-  if (typeof fetchImpl !== 'function') {
-    throw new Error('fetch is unavailable for claworld world broadcast helper');
-  }
-
-  const resolvedAgentId = normalizeText(agentId, null);
-  if (!resolvedAgentId) {
-    throw new Error('claworld world broadcast helper requires agentId');
-  }
-  const resolvedWorldId = normalizeText(worldId, null);
-  if (!resolvedWorldId) {
-    throw new Error('claworld world broadcast helper requires worldId');
-  }
-  const resolvedAnnouncementText = normalizeText(announcementText, null);
-  if (!resolvedAnnouncementText) {
-    throw new Error('claworld world broadcast helper requires announcementText');
-  }
-
-  const resolvedRuntimeConfig = runtimeConfig || resolveClaworldRuntimeConfig(cfg, accountId);
-  const baseUrl = normalizeRelayHttpBaseUrl(resolvedRuntimeConfig.serverUrl);
-  const result = await fetchJson(fetchImpl, `${baseUrl}/v1/worlds/${encodeURIComponent(resolvedWorldId)}/broadcast`, {
-    method: 'POST',
-    headers: buildRuntimeAuthHeaders(resolvedRuntimeConfig, {
-      accept: 'application/json',
-      'content-type': 'application/json',
-      ...(resolvedRuntimeConfig.apiKey ? { 'x-api-key': resolvedRuntimeConfig.apiKey } : {}),
-    }),
-    body: JSON.stringify({
-      agentId: resolvedAgentId,
-      payload: {
-        text: resolvedAnnouncementText,
-      },
-      ...(normalizeText(audience, null) ? { audience: normalizeText(audience, null) } : {}),
-      ...(typeof excludeSelf === 'boolean' ? { excludeSelf } : {}),
-    }),
-  });
-
-  if (!result.ok) {
-    logger.error?.('[claworld:moderation] world broadcast failed', {
-      status: result.status,
-      worldId: resolvedWorldId,
-      accountId: resolvedRuntimeConfig.accountId || accountId || null,
-      body: result.body,
-    });
-    throw createModerationHttpError('broadcast', result, {
-      accountId: resolvedRuntimeConfig.accountId || accountId || null,
-      worldId: resolvedWorldId,
-    });
-  }
-
-  return normalizeWorldBroadcastResponse(result.body);
-}

package/src/product-shell/contracts/chat-request-approval-policy.js

@@ -1,93 +0,0 @@
-const DEFAULT_MODE = 'open';
-const SUPPORTED_MODES = Object.freeze([
-  'manual_review',
-  'world_only',
-  'trusted_only',
-  'trusted_or_world',
-  'open',
-]);
-const SUPPORTED_ORIGIN_TYPES = Object.freeze([
-  'chat_request',
-  'world_broadcast',
-]);
-
-function normalizeText(value, fallback = null) {
-  if (value == null) return fallback;
-  const normalized = String(value).trim();
-  return normalized || fallback;
-}
-
-function normalizeToken(value, fallback = null) {
-  const normalized = normalizeText(value, fallback);
-  return normalized ? normalized.toLowerCase().replace(/[\s-]+/g, '_') : fallback;
-}
-
-function uniqueStrings(values = [], normalizer = (value) => normalizeText(value, null)) {
-  const seen = new Set();
-  const items = [];
-  for (const value of Array.isArray(values) ? values : []) {
-    const normalized = normalizer(value);
-    if (!normalized || seen.has(normalized)) continue;
-    seen.add(normalized);
-    items.push(normalized);
-  }
-  return items;
-}
-
-export const CHAT_REQUEST_APPROVAL_POLICY_SCHEMA_VERSION = 1;
-export const CHAT_REQUEST_APPROVAL_POLICY_MODES = SUPPORTED_MODES;
-export const CHAT_REQUEST_APPROVAL_POLICY_ORIGIN_TYPES = SUPPORTED_ORIGIN_TYPES;
-export const DEFAULT_CHAT_REQUEST_APPROVAL_POLICY_MODE = DEFAULT_MODE;
-
-export function normalizeChatRequestApprovalMode(value, fallback = DEFAULT_MODE) {
-  const normalized = normalizeToken(value, null);
-  switch (normalized) {
-    case 'manual':
-    case 'manual_review':
-    case 'review':
-      return 'manual_review';
-    case 'world':
-    case 'world_only':
-      return 'world_only';
-    case 'trusted':
-    case 'trusted_only':
-      return 'trusted_only';
-    case 'trusted_or_world':
-    case 'world_or_trusted':
-      return 'trusted_or_world';
-    case 'open':
-    case 'auto_accept':
-    case 'all':
-      return 'open';
-    default:
-      return SUPPORTED_MODES.includes(fallback) ? fallback : DEFAULT_MODE;
-  }
-}
-
-export function normalizeChatRequestApprovalOriginType(value, fallback = null) {
-  const normalized = normalizeToken(value, fallback);
-  return SUPPORTED_ORIGIN_TYPES.includes(normalized) ? normalized : fallback;
-}
-
-export function normalizeChatRequestApprovalBlocks(value = {}) {
-  const candidate = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-  return {
-    originTypes: uniqueStrings(candidate.originTypes, (entry) => normalizeChatRequestApprovalOriginType(entry, null)).sort(),
-    worldIds: uniqueStrings(candidate.worldIds, (entry) => normalizeText(entry, null)).sort(),
-  };
-}
-
-export function normalizeChatRequestApprovalPolicy(
-  value = {},
-  { fallbackMode = DEFAULT_MODE } = {},
-) {
-  const candidate = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-  const mode = normalizeText(candidate.mode, null)
-    ? normalizeChatRequestApprovalMode(candidate.mode, fallbackMode)
-    : normalizeChatRequestApprovalMode(fallbackMode, DEFAULT_MODE);
-
-  return {
-    mode,
-    blocks: normalizeChatRequestApprovalBlocks(candidate.blocks),
-  };
-}