@xfxstudio/claworld 0.1.4 → 0.2.0

package/src/openclaw/plugin/config-schema.js

@@ -99,7 +99,7 @@ const SINGLE_ACCOUNT_PROPERTIES = {
   toolProfile: {
     type: 'string',
     enum: ['minimal', 'default', 'world', 'full'],
-    description: 'Managed Claworld tool visibility profile. Legacy "world" normalizes to "default".',
+    description: 'Legacy ignored field retained for backward-compatible config parsing.',
   },
   heartbeatSeconds: {
     type: 'integer',
@@ -119,7 +119,7 @@ const SINGLE_ACCOUNT_PROPERTIES = {
       sessionTarget: {
         type: 'string',
         enum: ['subagent', 'mainagent'],
-        default: 'subagent',
+        default: 'mainagent',
       },
       fallbackTarget: {
         type: 'string',
@@ -169,18 +169,6 @@ const SINGLE_ACCOUNT_PROPERTIES = {
         description: 'Legacy alias. `true` maps to `approval.mode = "open"` and `false` maps to `approval.mode = "manual_review"`.',
         default: false,
       },
-      maxTurns: {
-        type: 'integer',
-        minimum: 1,
-        description: 'Legacy ignored field. Approval policy no longer carries session turn controls.',
-        default: 4,
-      },
-      turnTimeoutMs: {
-        type: 'integer',
-        minimum: 1000,
-        description: 'Legacy ignored field. Approval policy no longer carries session timeout controls.',
-        default: 30000,
-      },
     },
   },
   testing: {
@@ -230,7 +218,7 @@ export const claworldChannelConfigSchema = {
   description:
     '最小 OpenClaw claworld channel 配置；支持单账号或 accounts.<id> 多账号模式。canonical flow uses appToken + registration, while relay/localAgent fields remain compatibility aliases.',
   routingShape: {
-    sessionTarget: 'subagent',
+    sessionTarget: 'mainagent',
     fallbackTarget: 'mainagent',
     allowHumanInterrupt: true,
   },
@@ -344,7 +332,7 @@ export function validateClaworldChannelConfig(config = {}, accountId = null) {
     errors.push({ code: 'invalid_heartbeat_seconds', value: candidate.heartbeatSeconds });
   }
 
-  const sessionTarget = candidate.routing?.sessionTarget || 'subagent';
+  const sessionTarget = candidate.routing?.sessionTarget || 'mainagent';
   const fallbackTarget = candidate.routing?.fallbackTarget || 'mainagent';
   if (!['subagent', 'mainagent'].includes(sessionTarget)) {
     errors.push({ code: 'invalid_session_target', value: sessionTarget });

package/src/openclaw/plugin/managed-config.js

@@ -13,13 +13,15 @@ import {
   normalizeChatRequestApprovalMode,
 } from '../../product-shell/contracts/chat-request-approval-policy.js';
 
-export const DEFAULT_CLAWORLD_SERVER_URL = 'https://claworld.zy-sj.com';
+export const DEFAULT_CLAWORLD_SERVER_URL = 'https://clawold.love';
 export const DEFAULT_CLAWORLD_API_KEY = 'local-test';
-export const DEFAULT_CLAWORLD_AGENT_ID = 'claworld';
+export const DEFAULT_CLAWORLD_AGENT_ID = 'main';
 export const DEFAULT_CLAWORLD_ACCOUNT_ID = 'claworld';
 export const DEFAULT_CLAWORLD_TOOL_PROFILE = 'default';
 export const DEFAULT_CLAWORLD_DM_SCOPE = 'per-channel-peer';
 export const DEFAULT_CLAWORLD_APPROVAL_MODE = DEFAULT_CHAT_REQUEST_APPROVAL_POLICY_MODE;
+export const DEFAULT_CLAWORLD_SESSION_TARGET = 'mainagent';
+export const DEFAULT_CLAWORLD_FALLBACK_TARGET = 'mainagent';
 
 export const TOOL_PROFILES = CLAWORLD_TOOL_PROFILES;
 
@@ -107,24 +109,61 @@ function findManagedAccountEntry(config = {}, accountId) {
   return {};
 }
 
+function inferExistingAgentId(config = {}, accountId = DEFAULT_CLAWORLD_ACCOUNT_ID) {
+  const bindings = Array.isArray(config?.bindings) ? config.bindings : [];
+  const bindingMatch = bindings
+    .map((item) => ensureObject(item))
+    .find((item) => ensureObject(item.match).channel === 'claworld'
+      && normalizeText(ensureObject(item.match).accountId, null) === accountId
+      && normalizeText(item.agentId, null));
+  if (bindingMatch?.agentId) return normalizeText(bindingMatch.agentId, null);
+
+  const agents = Array.isArray(config?.agents?.list) ? config.agents.list : [];
+  if (agents.some((item) => ensureObject(item).id === DEFAULT_CLAWORLD_AGENT_ID)) {
+    return DEFAULT_CLAWORLD_AGENT_ID;
+  }
+  if (agents.length === 1) {
+    return normalizeText(ensureObject(agents[0]).id, DEFAULT_CLAWORLD_AGENT_ID);
+  }
+  return DEFAULT_CLAWORLD_AGENT_ID;
+}
+
+const MANAGED_LEGACY_BUNDLED_SKILL_NAMES = Object.freeze([
+  'claworld-join-and-chat',
+  'claworld-manage-worlds',
+  'claworld-help',
+]);
+
+function hasOnlyManagedBundledSkills(value) {
+  if (!Array.isArray(value) || value.length === 0) return false;
+  return value.every((skillName) => MANAGED_LEGACY_BUNDLED_SKILL_NAMES.includes(skillName));
+}
+
 function buildManagedAgentEntry(options = {}) {
-  const managedSkills = resolveManagedAgentSkills({ toolProfile: options.toolProfile });
   return {
     id: options.agentId,
     workspace: options.workspace,
-    ...(managedSkills === undefined ? {} : { skills: managedSkills }),
     ...(options.agentDirExplicit && options.agentDir ? { agentDir: options.agentDir } : {}),
   };
 }
 
+function buildManagedRoutingEntry(options = {}, existingRouting = {}) {
+  return {
+    ...ensureObject(existingRouting),
+    sessionTarget: normalizeText(options.sessionTarget, DEFAULT_CLAWORLD_SESSION_TARGET),
+    fallbackTarget: normalizeText(options.fallbackTarget, DEFAULT_CLAWORLD_FALLBACK_TARGET),
+    allowHumanInterrupt: existingRouting?.allowHumanInterrupt !== false,
+  };
+}
+
 function buildManagedAccountEntry(options = {}) {
   const base = {
     enabled: true,
     serverUrl: options.serverUrl,
     apiKey: options.apiKey,
     accountId: options.accountId,
-    toolProfile: options.toolProfile,
     name: normalizeText(options.name, normalizeText(options.displayName, null)),
+    routing: buildManagedRoutingEntry(options),
     approval: {
       mode: normalizeChatRequestApprovalMode(options.approvalMode, DEFAULT_CLAWORLD_APPROVAL_MODE),
     },
@@ -162,8 +201,8 @@ function buildMergedAccountEntry(existingAccount = {}, options = {}) {
     serverUrl: options.serverUrl,
     apiKey: options.apiKey,
     accountId: options.accountId,
-    toolProfile: options.toolProfile,
     name: normalizeText(options.name, normalizeText(existingAccount.name, normalizeText(options.displayName, null))),
+    routing: buildManagedRoutingEntry(options, existingAccount.routing),
     approval: {
       ...existingApproval,
       mode: normalizeChatRequestApprovalMode(options.approvalMode, DEFAULT_CLAWORLD_APPROVAL_MODE),
@@ -179,6 +218,7 @@ function buildMergedAccountEntry(existingAccount = {}, options = {}) {
         ? { relay: existingRelay }
         : {}),
   };
+  delete merged.toolProfile;
 
   if (options.appToken) {
     return {
@@ -344,7 +384,7 @@ ${identityLine}
 
 Use this file for durable Claworld-specific notes only.
 
-- keep world rules, pairing context, and recurring counterpart preferences here when they help future Claworld sessions
+- keep world rules, pairing context, and recurring counterpart preferences here when they help future Claworld conversations
 - do not duplicate a full standalone OpenClaw bootstrap/persona here
 - prefer channel/world-specific memory over general-purpose assistant memory
 `;
@@ -380,15 +420,24 @@ export function resolveClaworldManagedRuntimeOptions({
   overrides = {},
 } = {}) {
   const resolvedAccountId = normalizeText(accountId, DEFAULT_CLAWORLD_ACCOUNT_ID);
-  const agentId = normalizeText(overrides.agentId, resolvedAccountId);
+  const attachToExistingAgent = overrides.attachToExistingAgent !== false;
+  const inferredAgentId = inferExistingAgentId(cfg, resolvedAccountId);
+  const agentId = normalizeText(overrides.agentId, inferredAgentId);
   const existingAgent = findAgentEntry(cfg, agentId);
   const existingAccount = findManagedAccountEntry(cfg, resolvedAccountId);
   const replaceManagedRuntime = overrides.replaceManagedRuntime !== false;
-  const defaultWorkspace = resolveDefaultManagedWorkspace(agentId);
+  const explicitWorkspace = normalizeText(overrides.workspace, null);
+  const manageAgentEntry = overrides.manageAgentEntry === true
+    || overrides.agentDirExplicit === true
+    || attachToExistingAgent !== true;
+  const manageWorkspace = overrides.manageWorkspace === true
+    || Boolean(explicitWorkspace)
+    || attachToExistingAgent !== true;
+  const defaultWorkspace = manageWorkspace ? resolveDefaultManagedWorkspace(agentId) : null;
   const workspace = normalizeText(
-    overrides.workspace,
+    explicitWorkspace,
     replaceManagedRuntime
-      ? defaultWorkspace
+      ? normalizeText(existingAgent?.workspace, defaultWorkspace)
       : normalizeText(existingAgent?.workspace, defaultWorkspace),
   );
   const serverUrl = normalizeText(
@@ -421,10 +470,6 @@ export function resolveClaworldManagedRuntimeOptions({
     normalizeText(input.name, resolveDefaultManagedDisplayName(resolvedAccountId)),
   );
   const name = normalizeText(overrides.name, displayName);
-  const explicitToolProfile = normalizeText(
-    overrides.toolProfile,
-    normalizeText(input.toolProfile, null),
-  );
   const existingRegistrationAgentCode = normalizeRegistrationAgentCode(
     existingAccount?.registration?.agentCode,
     normalizeRegistrationAgentCode(existingAccount?.localAgent?.agentCode, null),
@@ -449,9 +494,12 @@ export function resolveClaworldManagedRuntimeOptions({
 
   return {
     repoRoot: normalizeText(overrides.repoRoot, null),
+    attachToExistingAgent,
     agentId,
     accountId: resolvedAccountId,
     workspace,
+    manageAgentEntry,
+    manageWorkspace,
     agentDir: normalizeText(overrides.agentDir, null),
     agentDirExplicit: overrides.agentDirExplicit === true,
     serverUrl,
@@ -461,11 +509,6 @@ export function resolveClaworldManagedRuntimeOptions({
     displayName,
     name,
     defaultToAddress: normalizeText(overrides.defaultToAddress, null),
-    toolProfile: resolveManagedToolProfile({
-      cfg,
-      existingAccount,
-      explicitToolProfile,
-    }),
     approvalMode,
     sessionDmScope: normalizeText(
       overrides.sessionDmScope,
@@ -476,37 +519,45 @@ export function resolveClaworldManagedRuntimeOptions({
     forceDefaultAccount: overrides.forceDefaultAccount === true,
     pluginInstallMode: normalizeText(overrides.pluginInstallMode, 'skip'),
     installPlugin: overrides.installPlugin !== false,
+    sessionTarget: normalizeText(overrides.sessionTarget, DEFAULT_CLAWORLD_SESSION_TARGET),
+    fallbackTarget: normalizeText(overrides.fallbackTarget, DEFAULT_CLAWORLD_FALLBACK_TARGET),
   };
 }
 
 export function applyClaworldManagedRuntimeConfig(inputConfig = {}, options = {}) {
   const config = JSON.parse(JSON.stringify(ensureObject(inputConfig)));
-  const toolProfile = normalizeClaworldToolProfile(options.toolProfile);
-  const toolNames = resolveToolNames({ toolProfile });
   const summary = [];
   const replaceManagedRuntime = options.replaceManagedRuntime !== false;
   const preserveDefaultAccount = options.preserveDefaultAccount === true;
   const sessionDmScope = normalizeText(options.sessionDmScope, DEFAULT_CLAWORLD_DM_SCOPE);
+  const manageAgentEntry = options.manageAgentEntry === true;
 
   if (!options.appToken && !normalizeText(options.registrationAgentCode, null)) {
     throw new Error('claworld registration agentCode is required when appToken is absent');
   }
 
-  config.tools = ensureObject(config.tools);
   const removedManagedToolNames = new Set([
+    ...CLAWORLD_PUBLIC_TOOL_NAMES,
     ...CLAWORLD_COMPATIBILITY_TOOL_NAMES,
     ...CLAWORLD_RETIRED_PUBLIC_TOOL_NAMES,
   ]);
-  const existingAllow = asStringArray(config.tools.allow);
-  const removedHelperTools = existingAllow.filter((toolName) => removedManagedToolNames.has(toolName));
-  config.tools.allow = uniqueStrings([
-    ...existingAllow.filter((toolName) => !removedManagedToolNames.has(toolName)),
-    ...toolNames,
-  ]);
-  if (removedHelperTools.length > 0) {
-    summary.push(`tools.allow removed optional helper entries (${removedHelperTools.join(',')})`);
+  if (inputConfig?.tools && typeof inputConfig.tools === 'object') {
+    config.tools = ensureObject(config.tools);
+    const existingAllow = asStringArray(config.tools.allow);
+    const filteredAllow = existingAllow.filter((toolName) => !removedManagedToolNames.has(toolName));
+    const removedManagedTools = existingAllow.filter((toolName) => removedManagedToolNames.has(toolName));
+    if (removedManagedTools.length > 0) {
+      if (filteredAllow.length > 0) {
+        config.tools.allow = uniqueStrings(filteredAllow);
+      } else {
+        delete config.tools.allow;
+      }
+      summary.push(`tools.allow removed managed claworld entries (${removedManagedTools.join(',')})`);
+    }
+    if (Object.keys(config.tools).length === 0) {
+      delete config.tools;
+    }
   }
-  summary.push(`tools.allow updated for ${toolProfile} profile (${describeToolAllowEntries(toolNames)})`);
 
   config.session = ensureObject(config.session);
   if (!Object.prototype.hasOwnProperty.call(config.session, 'dmScope')) {
@@ -516,51 +567,53 @@ export function applyClaworldManagedRuntimeConfig(inputConfig = {}, options = {}
 
   config.agents = ensureObject(config.agents);
   const existingAgentList = Array.isArray(config.agents.list) ? [...config.agents.list] : [];
-  const managedAgentEntry = buildManagedAgentEntry(options);
-  if (replaceManagedRuntime) {
-    const removedAgentEntries = existingAgentList.filter((item) => ensureObject(item).id === options.agentId).length;
-    config.agents.list = [
-      ...existingAgentList.filter((item) => ensureObject(item).id !== options.agentId),
-      managedAgentEntry,
-    ];
-    summary.push(
-      removedAgentEntries > 0
-        ? `replaced managed agent entry ${options.agentId}`
-        : `added workspace-scoped agent entry ${options.agentId}`,
-    );
-  } else {
-    const agentIndex = findAgentIndex(existingAgentList, options.agentId);
-    if (agentIndex >= 0) {
-      const existingAgent = ensureObject(existingAgentList[agentIndex]);
-      const existingAgentDir = normalizeText(existingAgent.agentDir, null);
-      const managedSkills = resolveManagedAgentSkills({ toolProfile: options.toolProfile });
-      const keepExistingAgentDir = Boolean(
-        existingAgentDir
-        && (
-          options.agentDirExplicit
-          || existingAgentDir !== normalizeText(options.agentDir, null)
-        ),
+  if (manageAgentEntry) {
+    const managedAgentEntry = buildManagedAgentEntry(options);
+    if (replaceManagedRuntime) {
+      const removedAgentEntries = existingAgentList.filter((item) => ensureObject(item).id === options.agentId).length;
+      config.agents.list = [
+        ...existingAgentList.filter((item) => ensureObject(item).id !== options.agentId),
+        managedAgentEntry,
+      ];
+      summary.push(
+        removedAgentEntries > 0
+          ? `replaced managed agent entry ${options.agentId}`
+          : `added workspace-scoped agent entry ${options.agentId}`,
       );
-      const nextAgentEntry = {
-        ...existingAgent,
-        id: options.agentId,
-        workspace: normalizeText(existingAgent.workspace, options.workspace),
-        ...(keepExistingAgentDir ? { agentDir: existingAgentDir } : {}),
-        ...(managedSkills === undefined ? {} : { skills: managedSkills }),
-      };
-      if (!keepExistingAgentDir) {
-        delete nextAgentEntry.agentDir;
-      }
-      if (managedSkills === undefined) {
-        delete nextAgentEntry.skills;
-      }
-      existingAgentList[agentIndex] = nextAgentEntry;
-      summary.push(`updated existing agent entry ${options.agentId}`);
     } else {
-      existingAgentList.push(managedAgentEntry);
-      summary.push(`added workspace-scoped agent entry ${options.agentId}`);
+      const agentIndex = findAgentIndex(existingAgentList, options.agentId);
+      if (agentIndex >= 0) {
+        const existingAgent = ensureObject(existingAgentList[agentIndex]);
+        const existingAgentDir = normalizeText(existingAgent.agentDir, null);
+        const keepExistingAgentDir = Boolean(
+          existingAgentDir
+          && (
+            options.agentDirExplicit
+            || existingAgentDir !== normalizeText(options.agentDir, null)
+          ),
+        );
+        const nextAgentEntry = {
+          ...existingAgent,
+          id: options.agentId,
+          workspace: normalizeText(existingAgent.workspace, options.workspace),
+          ...(keepExistingAgentDir ? { agentDir: existingAgentDir } : {}),
+        };
+        if (!keepExistingAgentDir) {
+          delete nextAgentEntry.agentDir;
+        }
+        if (hasOnlyManagedBundledSkills(existingAgent.skills)) {
+          delete nextAgentEntry.skills;
+        }
+        existingAgentList[agentIndex] = nextAgentEntry;
+        summary.push(`updated existing agent entry ${options.agentId}`);
+      } else {
+        existingAgentList.push(managedAgentEntry);
+        summary.push(`added workspace-scoped agent entry ${options.agentId}`);
+      }
+      config.agents.list = existingAgentList;
     }
-    config.agents.list = existingAgentList;
+  } else {
+    summary.push(`attached claworld account ${options.accountId} to existing local agent ${options.agentId}`);
   }
 
   config.channels = ensureObject(config.channels);
@@ -619,7 +672,6 @@ export function applyClaworldManagedRuntimeConfig(inputConfig = {}, options = {}
 
   return {
     config,
-    toolNames,
     summary,
     canonicalAgentCode: canonicalRelayAgentCode(
       options.registrationAgentCode,

package/src/openclaw/plugin/onboarding.js

@@ -200,15 +200,19 @@ async function applyManagedOnboardingConfig({
 } = {}) {
   const managedOptions = resolveManagedOptionsFromContext({ cfg, accountId, input });
   const next = applyClaworldManagedRuntimeConfig(cfg, managedOptions);
-  await ensureManagedWorkspaceSeed(managedOptions);
+  if (managedOptions.manageWorkspace) {
+    await ensureManagedWorkspaceSeed(managedOptions);
+  }
 
   const noteLines = [
-    `Managed local agent/account: ${managedOptions.agentId}`,
+    `Bound local agent/account: ${managedOptions.agentId}`,
     `Remote backend: ${managedOptions.serverUrl}`,
     managedOptions.registrationAgentCode
       ? `Bootstrap mode: registration (${managedOptions.registrationAgentCode})`
       : 'Bootstrap mode: appToken/manual binding',
-    'This flow only refreshes plugin-side config and workspace files. It does not start a backend service.',
+    managedOptions.manageWorkspace
+      ? 'This flow refreshes plugin-side config and the dedicated claworld workspace contract. It does not start a backend service.'
+      : 'This flow refreshes plugin-side config and binds claworld onto the existing local agent. It does not start a backend service.',
   ];
   await prompter.note(
     noteLines.join('\n'),