@xfxstudio/claworld 0.2.8 → 0.2.10-beta.0

package/src/lib/public-identity.js

@@ -0,0 +1,175 @@
+import { randomBytes } from 'crypto';
+
+export const PUBLIC_IDENTITY_STATUS = Object.freeze({
+  PENDING: 'pending',
+  READY: 'ready',
+});
+
+export const PUBLIC_IDENTITY_DISPLAY_NAME_MAX_LENGTH = 40;
+export const PUBLIC_IDENTITY_CODE_LENGTH = 6;
+const PUBLIC_IDENTITY_CODE_ALPHABET = '23456789ABCDEFGHJKLMNPQRSTUVWXYZ';
+
+function normalizeText(value, fallback = null) {
+  if (value == null) return fallback;
+  const normalized = String(value).trim();
+  return normalized || fallback;
+}
+
+function normalizeIsoTimestamp(value, fallback = null) {
+  const normalized = normalizeText(value, null);
+  if (!normalized) return fallback;
+  const timestamp = Date.parse(normalized);
+  return Number.isFinite(timestamp) ? new Date(timestamp).toISOString() : fallback;
+}
+
+function cloneObject(value, fallback = {}) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return { ...fallback };
+  return { ...value };
+}
+
+export function normalizePublicDisplayName(value, { fallback = null } = {}) {
+  const normalized = normalizeText(value, fallback);
+  if (!normalized) return fallback;
+  return normalized.slice(0, PUBLIC_IDENTITY_DISPLAY_NAME_MAX_LENGTH);
+}
+
+export function validatePublicDisplayName(value) {
+  const normalized = normalizeText(value, null);
+  if (!normalized) {
+    return {
+      ok: false,
+      code: 'display_name_required',
+      message: 'displayName is required',
+    };
+  }
+  if (normalized.length > PUBLIC_IDENTITY_DISPLAY_NAME_MAX_LENGTH) {
+    return {
+      ok: false,
+      code: 'display_name_too_long',
+      message: `displayName must be ${PUBLIC_IDENTITY_DISPLAY_NAME_MAX_LENGTH} characters or fewer`,
+    };
+  }
+  if (normalized.includes('#')) {
+    return {
+      ok: false,
+      code: 'display_name_reserved_character',
+      message: 'displayName must not include #',
+    };
+  }
+  if (/[\r\n\t]/.test(normalized)) {
+    return {
+      ok: false,
+      code: 'display_name_invalid_whitespace',
+      message: 'displayName must not include line breaks or tabs',
+    };
+  }
+  if (/[\u0000-\u001F\u007F]/.test(normalized)) {
+    return {
+      ok: false,
+      code: 'display_name_invalid_character',
+      message: 'displayName contains unsupported control characters',
+    };
+  }
+  return {
+    ok: true,
+    value: normalized,
+  };
+}
+
+export function generatePublicIdentityCode({ length = PUBLIC_IDENTITY_CODE_LENGTH } = {}) {
+  const targetLength = Number.isInteger(length) && length > 0 ? length : PUBLIC_IDENTITY_CODE_LENGTH;
+  const bytes = randomBytes(targetLength);
+  let output = '';
+  for (let index = 0; index < targetLength; index += 1) {
+    output += PUBLIC_IDENTITY_CODE_ALPHABET[bytes[index] % PUBLIC_IDENTITY_CODE_ALPHABET.length];
+  }
+  return output;
+}
+
+export function formatPublicIdentityDisplay({ displayName = null, code = null } = {}) {
+  const normalizedDisplayName = normalizeText(displayName, null);
+  const normalizedCode = normalizeText(code, null);
+  if (!normalizedDisplayName || !normalizedCode) return null;
+  return `${normalizedDisplayName}#${normalizedCode}`;
+}
+
+export function parsePublicIdentityDisplay(value) {
+  const normalized = normalizeText(value, null);
+  if (!normalized) return null;
+  const hashIndex = normalized.lastIndexOf('#');
+  if (hashIndex <= 0 || hashIndex >= normalized.length - 1) return null;
+  const displayName = normalizeText(normalized.slice(0, hashIndex), null);
+  const code = normalizeText(normalized.slice(hashIndex + 1), null)?.toUpperCase() || null;
+  if (!displayName || !code) return null;
+  if (displayName.includes('#')) return null;
+  return {
+    displayName,
+    code,
+    identity: `${displayName}#${code}`,
+  };
+}
+
+export function buildPublicIdentityRecord(input = {}, {
+  fallbackDisplayName = null,
+  statusFallback = PUBLIC_IDENTITY_STATUS.PENDING,
+  now = null,
+} = {}) {
+  const source = cloneObject(input);
+  const normalizedDisplayName = normalizePublicDisplayName(
+    source.displayName,
+    { fallback: normalizePublicDisplayName(fallbackDisplayName, { fallback: null }) },
+  );
+  const normalizedCode = normalizeText(source.code, null)?.toUpperCase() || null;
+  const normalizedStatus = normalizeText(source.status, null);
+  const resolvedStatus = normalizedStatus === PUBLIC_IDENTITY_STATUS.READY
+    ? PUBLIC_IDENTITY_STATUS.READY
+    : normalizedStatus === PUBLIC_IDENTITY_STATUS.PENDING
+      ? PUBLIC_IDENTITY_STATUS.PENDING
+      : (normalizedCode && normalizedDisplayName ? PUBLIC_IDENTITY_STATUS.READY : statusFallback);
+  const fallbackTimestamp = normalizeIsoTimestamp(now, null);
+  const confirmedAt = normalizeIsoTimestamp(source.confirmedAt, null)
+    || (resolvedStatus === PUBLIC_IDENTITY_STATUS.READY ? fallbackTimestamp : null);
+  const updatedAt = normalizeIsoTimestamp(source.updatedAt, fallbackTimestamp);
+  return {
+    displayName: normalizedDisplayName,
+    code: normalizedCode,
+    status: resolvedStatus,
+    confirmedAt,
+    updatedAt,
+  };
+}
+
+export function resolvePublicIdentity(agent = {}) {
+  const publicIdentity = buildPublicIdentityRecord(agent?.publicIdentity, {
+    fallbackDisplayName: agent?.displayName || agent?.agentId || null,
+    now: agent?.createdAt || null,
+  });
+  return {
+    ...publicIdentity,
+    displayIdentity: formatPublicIdentityDisplay(publicIdentity),
+  };
+}
+
+export function isPublicIdentityReady(agent = {}) {
+  return resolvePublicIdentity(agent).status === PUBLIC_IDENTITY_STATUS.READY;
+}
+
+export function buildPublicIdentityMissingFields(agent = {}) {
+  const publicIdentity = resolvePublicIdentity(agent);
+  const missingFields = [];
+  if (!publicIdentity.displayName) {
+    missingFields.push({
+      fieldId: 'displayName',
+      label: 'Public Name',
+      description: 'A public display name used in Claworld identity surfaces.',
+    });
+  }
+  if (!publicIdentity.code) {
+    missingFields.push({
+      fieldId: 'code',
+      label: 'Public Code',
+      description: 'A system-generated unique suffix used in the public identity.',
+    });
+  }
+  return missingFields;
+}

package/src/lib/relay/kickoff-text.js

@@ -189,8 +189,10 @@ export function createAcceptedChatKickoffRuntimeContextForAgent(bundle = {}, {
 export function formatAcceptedChatKickoffMessage(bundle = {}, { viewer = 'recipient' } = {}) {
   const normalizedViewer = viewer === 'sender' ? 'sender' : 'recipient';
   const requestContext = bundle.requestContext && typeof bundle.requestContext === 'object' && !Array.isArray(bundle.requestContext)
-    ? bundle.requestContext
+    ? cloneJsonObject(bundle.requestContext) || {}
     : {};
+  const followUpSessionKey = normalizeText(requestContext.followUp?.sessionKey, null);
+  if (requestContext.followUp) delete requestContext.followUp;
   const worldInfo = bundle.worldInfo && typeof bundle.worldInfo === 'object' && !Array.isArray(bundle.worldInfo)
     ? bundle.worldInfo
     : null;
@@ -221,9 +223,13 @@ export function formatAcceptedChatKickoffMessage(bundle = {}, { viewer = 'recipi
     viewerInstruction,
     normalizeText(bundle.requestId, null) ? `Accepted episode: ${bundle.requestId}` : null,
     formatStructuredSection('主人想让你做的事情 / 请求上下文', requestContext),
+    normalizedViewer === 'sender' && followUpSessionKey
+      ? `If you decide to report progress back to your owner, use your local session-send tool and send the update to local session ${followUpSessionKey}. Do not report every turn. Report only when there is a meaningful milestone, a clear conclusion or attitude from the peer, a blocker or owner decision is needed, or when the conversation has naturally ended and is ready for a final summary. Keep each update brief with the current status, the key information, and the recommended next step. If no update is needed yet, you may wait.`
+      : null,
     formatStructuredSection('世界信息', worldInfo),
     formatStructuredSection('我方信息', selfInfo),
     formatStructuredSection('对方信息', peerInfo),
+    '在正常回复中，你可以附带 [[like]] 或 [[dislike]] 来表达你对这段 conversation 的反馈。这个 token 对对方可见，系统只会按当前 conversation 和方向记录第一次有效反馈。',
     normalizedViewer === 'sender'
       ? '请你现在直接输出一条自然的开场白。不要解释规则，不要复述这些说明。'
       : '请把对方刚发来的 opener 视为这段对话的第一条 live turn，并决定是否以及如何直接回复。不要解释规则，不要复述这些说明。',

package/src/openclaw/installer/cli.js

@@ -8,6 +8,7 @@ import {
   CLAWORLD_INSTALLER_BIN_NAME,
   CLAWORLD_INSTALLER_COMMAND,
   CLAWORLD_INSTALLER_PACKAGE_NAME,
+  CLAWORLD_UNINSTALL_COMMAND,
   CLAWORLD_UPDATE_COMMAND,
 } from './constants.js';
 import { formatClaworldDoctorReport, runClaworldDoctor } from './doctor.js';
@@ -15,6 +16,7 @@ import {
   DEFAULT_OPENCLAW_BIN,
   DEFAULT_OPENCLAW_CONFIG_PATH,
   runClaworldInstallerInstall,
+  runClaworldInstallerUninstall,
   runClaworldInstallerUpdate,
 } from './core.js';
 
@@ -38,6 +40,7 @@ Commands:
   install                     Run the installer-first Claworld setup flow
   doctor                      Validate the managed Claworld install health
   update                      Update the tracked Claworld plugin, refresh managed state, and run doctor
+  uninstall                   Safely remove the managed Claworld runtime and uninstall the plugin
   upgrade                     Alias for update
   help                        Show this help
 
@@ -74,6 +77,12 @@ Doctor options:
   --account-id <id>           Managed Claworld account id (default: claworld)
   --agent-id <id>             Local OpenClaw agent id bound to claworld (default: main)
   --workspace <path>          Optional dedicated workspace path override
+Uninstall options:
+  --config <path>             OpenClaw config path (default: ${DEFAULT_OPENCLAW_CONFIG_PATH})
+  --state-dir <path>          Optional OPENCLAW_STATE_DIR for OpenClaw commands
+  --openclaw-bin <path>       OpenClaw CLI binary (default: ${DEFAULT_OPENCLAW_BIN})
+  --account-id <id>           Managed Claworld account id (default: claworld)
+  --agent-id <id>             Local OpenClaw agent id bound to claworld (default: main)
   --json                      Print machine-readable result
   --help, -h                  Show this help
 
@@ -81,6 +90,7 @@ Canonical commands:
   ${CLAWORLD_INSTALLER_COMMAND}
   ${CLAWORLD_DOCTOR_COMMAND}
   ${CLAWORLD_UPDATE_COMMAND}
+  ${CLAWORLD_UNINSTALL_COMMAND}
 `);
 }
 
@@ -132,6 +142,13 @@ export function parseInstallerCliArgs(argv = process.argv.slice(2), env = proces
       agentId: 'main',
       workspace: null,
     },
+    uninstall: {
+      openclawBin: env.OPENCLAW_BIN || DEFAULT_OPENCLAW_BIN,
+      configPath: expandUserPath(env.OPENCLAW_CONFIG_PATH || DEFAULT_OPENCLAW_CONFIG_PATH, homeDir),
+      stateDir: env.OPENCLAW_STATE_DIR ? expandUserPath(env.OPENCLAW_STATE_DIR, homeDir) : null,
+      accountId: 'claworld',
+      agentId: 'main',
+    },
   };
 
   if (argv.length === 0) {
@@ -149,18 +166,21 @@ export function parseInstallerCliArgs(argv = process.argv.slice(2), env = proces
         options.install.configPath = expandUserPath(nextValue(remaining, index), homeDir);
         options.update.configPath = options.install.configPath;
         options.doctor.configPath = options.install.configPath;
+        options.uninstall.configPath = options.install.configPath;
         index += 1;
         break;
       case '--state-dir':
         options.install.stateDir = expandUserPath(nextValue(remaining, index), homeDir);
         options.update.stateDir = options.install.stateDir;
         options.doctor.stateDir = options.install.stateDir;
+        options.uninstall.stateDir = options.install.stateDir;
         index += 1;
         break;
       case '--openclaw-bin':
         options.install.openclawBin = nextValue(remaining, index);
         options.update.openclawBin = options.install.openclawBin;
         options.doctor.openclawBin = options.install.openclawBin;
+        options.uninstall.openclawBin = options.install.openclawBin;
         index += 1;
         break;
       case '--server-url':
@@ -178,12 +198,14 @@ export function parseInstallerCliArgs(argv = process.argv.slice(2), env = proces
         options.install.accountId = nextValue(remaining, index);
         options.update.accountId = options.install.accountId;
         options.doctor.accountId = options.install.accountId;
+        options.uninstall.accountId = options.install.accountId;
         index += 1;
         break;
       case '--agent-id':
         options.install.agentId = nextValue(remaining, index);
         options.update.agentId = options.install.agentId;
         options.doctor.agentId = options.install.agentId;
+        options.uninstall.agentId = options.install.agentId;
         index += 1;
         break;
       case '--workspace':
@@ -226,7 +248,7 @@ export function parseInstallerCliArgs(argv = process.argv.slice(2), env = proces
     }
   }
 
-  if (!['install', 'update', 'doctor', 'help'].includes(options.command)) {
+  if (!['install', 'update', 'uninstall', 'doctor', 'help'].includes(options.command)) {
     throw new Error(`Unknown command: ${options.command}`);
   }
   if (options.command === 'install' && !['npm', 'link', 'copy', 'skip'].includes(options.install.pluginInstallMode)) {
@@ -304,6 +326,19 @@ function printUpdateSummary(result, doctorResult) {
   console.log('');
 }
 
+function printUninstallSummary(result) {
+  console.log('');
+  console.log('Claworld uninstall complete');
+  console.log('===========================');
+  console.log(`Managed account:    ${result.transformed?.backup?.accountId || 'claworld'}`);
+  console.log(`OpenClaw version:   ${result.host?.version || '(unknown)'}`);
+  console.log(`Plugin action:      ${result.plugin?.action || 'unknown'}`);
+  console.log(`Runtime refresh:    ${result.runtimeRefresh?.action || 'unknown'}`);
+  console.log(`Config path:        ${result.configPath}`);
+  console.log(`Backup path:        ${result.backupPath || '(unchanged or new file)'}`);
+  console.log('');
+}
+
 export async function runInstallerCli(argv = process.argv.slice(2), env = process.env) {
   const parsed = parseInstallerCliArgs(argv, env);
   if (parsed.command === 'help') {
@@ -347,6 +382,16 @@ export async function runInstallerCli(argv = process.argv.slice(2), env = proces
     };
   }
 
+  if (parsed.command === 'uninstall') {
+    const result = await runClaworldInstallerUninstall(parsed.uninstall);
+    if (parsed.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      printUninstallSummary(result);
+    }
+    return result;
+  }
+
   const result = await runClaworldDoctor(parsed.doctor);
   if (parsed.json) {
     console.log(JSON.stringify(result, null, 2));

package/src/openclaw/installer/constants.js

@@ -3,4 +3,5 @@ export const CLAWORLD_INSTALLER_PACKAGE_NAME = '@xfxstudio/claworld';
 export const CLAWORLD_INSTALLER_COMMAND = 'npx -y @xfxstudio/claworld install';
 export const CLAWORLD_DOCTOR_COMMAND = 'npx -y @xfxstudio/claworld doctor';
 export const CLAWORLD_UPDATE_COMMAND = 'npx -y @xfxstudio/claworld update';
+export const CLAWORLD_UNINSTALL_COMMAND = 'npx -y @xfxstudio/claworld uninstall';
 export const CLAWORLD_OPENCLAW_MIN_HOST_VERSION = '>=2026.3.22';