@xfxstudio/claworld 0.1.4 → 0.2.0

package/src/openclaw/installer/doctor.js

@@ -3,9 +3,11 @@ import path from 'path';
 import { inspectClaworldChannelAccount } from '../plugin/config-schema.js';
 import {
   DEFAULT_CLAWORLD_ACCOUNT_ID,
+  DEFAULT_CLAWORLD_AGENT_ID,
   DEFAULT_CLAWORLD_SERVER_URL,
   expandUserPath,
   normalizeText,
+  resolveClaworldManagedRuntimeOptions,
 } from '../plugin/managed-config.js';
 import {
   CLAWORLD_DOCTOR_COMMAND,
@@ -195,7 +197,7 @@ export async function runClaworldDoctor({
   configPath = DEFAULT_OPENCLAW_CONFIG_PATH,
   stateDir = DEFAULT_OPENCLAW_STATE_DIR,
   accountId = DEFAULT_CLAWORLD_ACCOUNT_ID,
-  agentId = DEFAULT_CLAWORLD_ACCOUNT_ID,
+  agentId = DEFAULT_CLAWORLD_AGENT_ID,
   workspace = null,
   serverUrl = null,
   fetchImpl = globalThis.fetch?.bind(globalThis),
@@ -209,26 +211,39 @@ export async function runClaworldDoctor({
   const configState = await loadConfigFromDisk(resolvedConfigPath);
   const config = configState.config;
   const configuredAccount = inspectClaworldChannelAccount(config, accountId);
+  const managedOptions = resolveClaworldManagedRuntimeOptions({
+    cfg: config,
+    accountId,
+    overrides: {
+      agentId,
+      workspace,
+    },
+  });
   const rawManagedAccount = config?.channels?.claworld?.accounts?.[configuredAccount.accountId] || null;
   const configuredApiKey = normalizeText(rawManagedAccount?.apiKey, 'local-test');
-  const resolvedAgentId = normalizeText(agentId, normalizeText(configuredAccount.accountId, DEFAULT_CLAWORLD_ACCOUNT_ID));
-  const resolvedWorkspace = normalizeText(
-    workspace,
-    normalizeText(findManagedAgentEntry(config, resolvedAgentId)?.workspace, `~/.openclaw/workspace-${resolvedAgentId}`),
-  );
+  const resolvedAgentId = normalizeText(managedOptions.agentId, DEFAULT_CLAWORLD_AGENT_ID);
+  const resolvedWorkspace = normalizeText(managedOptions.workspace, null);
   const effectiveServerUrl = normalizeText(
     serverUrl,
     normalizeText(configuredAccount.serverUrl, DEFAULT_CLAWORLD_SERVER_URL),
   );
-  const workspaceInspection = await inspectManagedWorkspaceContract({
-    agentId: resolvedAgentId,
-    accountId: normalizeText(accountId, configuredAccount.accountId || DEFAULT_CLAWORLD_ACCOUNT_ID),
-    workspace: resolvedWorkspace,
-    serverUrl: effectiveServerUrl,
-    appToken: configuredAccount.appToken,
-    registrationAgentCode: configuredAccount.registration?.agentCode || null,
-    defaultToAddress: configuredAccount.relay?.defaultToAddress || null,
-  });
+  const workspaceInspection = managedOptions.manageWorkspace
+    ? await inspectManagedWorkspaceContract({
+      agentId: resolvedAgentId,
+      accountId: normalizeText(accountId, configuredAccount.accountId || DEFAULT_CLAWORLD_ACCOUNT_ID),
+      workspace: resolvedWorkspace,
+      serverUrl: effectiveServerUrl,
+      appToken: configuredAccount.appToken,
+      registrationAgentCode: configuredAccount.registration?.agentCode || null,
+      defaultToAddress: configuredAccount.relay?.defaultToAddress || null,
+    })
+    : {
+      ok: true,
+      workspacePath: resolvedWorkspace,
+      metadataPath: null,
+      files: [],
+      issues: [],
+    };
 
   const checks = [];
   const facts = {
@@ -362,15 +377,31 @@ export async function runClaworldDoctor({
   checks.push(createCheck({
     id: 'managed-agent',
     category: 'Managed config',
-    label: 'Managed local agent entry',
-    status: agentEntry && agentWorkspace === resolvedWorkspace ? 'pass' : 'fail',
-    summary: agentEntry && agentWorkspace === resolvedWorkspace
-      ? `Managed agent \`${resolvedAgentId}\` points at \`${resolvedWorkspace}\`.`
-      : agentEntry
-        ? `Managed agent \`${resolvedAgentId}\` exists but points at \`${agentWorkspace || 'missing workspace'}\`.`
-        : `Managed agent \`${resolvedAgentId}\` is missing from agents.list.`,
-    action: `Rerun \`${CLAWORLD_INSTALLER_COMMAND}\` to reconcile the managed agent entry.`,
-    details: { expectedWorkspace: resolvedWorkspace, actualWorkspace: agentWorkspace },
+    label: managedOptions.manageAgentEntry ? 'Managed local agent entry' : 'Bound local agent target',
+    status: managedOptions.manageAgentEntry
+      ? (agentEntry && agentWorkspace === resolvedWorkspace ? 'pass' : 'fail')
+      : (agentEntry ? 'pass' : 'warn'),
+    summary: managedOptions.manageAgentEntry
+      ? (
+        agentEntry && agentWorkspace === resolvedWorkspace
+          ? `Managed agent \`${resolvedAgentId}\` points at \`${resolvedWorkspace}\`.`
+          : agentEntry
+            ? `Managed agent \`${resolvedAgentId}\` exists but points at \`${agentWorkspace || 'missing workspace'}\`.`
+            : `Managed agent \`${resolvedAgentId}\` is missing from agents.list.`
+      )
+      : (
+        agentEntry
+          ? `Claworld is bound to existing local agent \`${resolvedAgentId}\` (${agentWorkspace || 'workspace unspecified'}).`
+          : `Claworld is configured to bind to local agent \`${resolvedAgentId}\`; this doctor run could not confirm an agents.list entry and will rely on runtime binding visibility instead.`
+      ),
+    action: managedOptions.manageAgentEntry
+      ? `Rerun \`${CLAWORLD_INSTALLER_COMMAND}\` to reconcile the managed agent entry.`
+      : null,
+    details: {
+      expectedWorkspace: resolvedWorkspace,
+      actualWorkspace: agentWorkspace,
+      manageAgentEntry: managedOptions.manageAgentEntry,
+    },
   }));
 
   checks.push(createCheck({
@@ -689,11 +720,17 @@ export async function runClaworldDoctor({
     id: 'workspace-contract',
     category: 'Workspace',
     label: 'Managed workspace contract',
-    status: workspaceWorstStatus,
-    summary: workspaceInspection.ok
-      ? `Managed workspace is present with ${formatWorkspaceState(workspaceInspection)}.`
-      : `Managed workspace needs repair: ${workspaceInspection.issues.map((issue) => issue.code).join(', ')}.`,
-    action: workspaceInspection.ok ? null : `Rerun \`${CLAWORLD_INSTALLER_COMMAND}\` to repair the managed workspace bootstrap.`,
+    status: managedOptions.manageWorkspace ? workspaceWorstStatus : 'pass',
+    summary: managedOptions.manageWorkspace
+      ? (
+        workspaceInspection.ok
+          ? `Managed workspace is present with ${formatWorkspaceState(workspaceInspection)}.`
+          : `Managed workspace needs repair: ${workspaceInspection.issues.map((issue) => issue.code).join(', ')}.`
+      )
+      : `Claworld is attached to existing local agent \`${resolvedAgentId}\`; no dedicated managed workspace is expected.`,
+    action: managedOptions.manageWorkspace && !workspaceInspection.ok
+      ? `Rerun \`${CLAWORLD_INSTALLER_COMMAND}\` to repair the managed workspace bootstrap.`
+      : null,
     details: {
       workspacePath: workspaceInspection.workspacePath,
       metadataPath: workspaceInspection.metadataPath,
@@ -704,6 +741,7 @@ export async function runClaworldDoctor({
         exists: file.exists,
       })),
       issues: workspaceInspection.issues,
+      manageWorkspace: managedOptions.manageWorkspace,
     },
   }));
 
@@ -735,8 +773,8 @@ export function formatClaworldDoctorReport(result = {}) {
     `Command: ${CLAWORLD_DOCTOR_COMMAND}`,
     `Config: ${result.configPath || '(unknown)'}`,
     `Managed account: ${result.accountId || '(unknown)'}`,
-    `Managed agent: ${result.agentId || '(unknown)'}`,
-    `Managed workspace: ${result.workspacePath || '(unknown)'}`,
+    `Bound local agent: ${result.agentId || '(unknown)'}`,
+    `Managed workspace: ${result.workspacePath || '(not used)'}`,
     '',
   ];
 

package/src/openclaw/installer/workspace-contract.js

@@ -12,6 +12,28 @@ import {
 export const CLAWORLD_MANAGED_WORKSPACE_METADATA_FILE = '.claworld-managed.json';
 export const CLAWORLD_MANAGED_WORKSPACE_CONTRACT_VERSION = 1;
 
+function resolveHomeDir(homeDir = null) {
+  const explicitHomeDir = normalizeText(homeDir, null);
+  if (explicitHomeDir) {
+    return explicitHomeDir;
+  }
+
+  const envHomeDir = normalizeText(
+    process.env.HOME,
+    normalizeText(
+      process.env.USERPROFILE,
+      normalizeText(
+        process.env.HOMEDRIVE && process.env.HOMEPATH
+          ? path.join(process.env.HOMEDRIVE, process.env.HOMEPATH)
+          : null,
+        null,
+      ),
+    ),
+  );
+
+  return envHomeDir || os.homedir();
+}
+
 function createHash(content) {
   return crypto.createHash('sha256').update(String(content || ''), 'utf8').digest('hex');
 }
@@ -51,12 +73,13 @@ function normalizeMetadata(source = {}) {
   };
 }
 
-export function resolveManagedWorkspacePath(workspace, homeDir = os.homedir()) {
-  return path.resolve(expandUserPath(workspace, homeDir));
+export function resolveManagedWorkspacePath(workspace, homeDir = null) {
+  return path.resolve(expandUserPath(workspace, resolveHomeDir(homeDir)));
 }
 
-export function buildManagedWorkspaceContract(options = {}, homeDir = os.homedir()) {
-  const workspacePath = resolveManagedWorkspacePath(options.workspace, homeDir);
+export function buildManagedWorkspaceContract(options = {}, homeDir = null) {
+  const resolvedHomeDir = resolveHomeDir(homeDir);
+  const workspacePath = resolveManagedWorkspacePath(options.workspace, resolvedHomeDir);
   const files = [
     createWorkspaceFileSpec('AGENTS.md', 'refreshable', buildWorkspaceAgentsContent(options)),
     createWorkspaceFileSpec('MEMORY.md', 'durable', buildWorkspaceMemoryContent(options)),
@@ -75,7 +98,7 @@ export function buildManagedWorkspaceContract(options = {}, homeDir = os.homedir
   };
 }
 
-export async function loadManagedWorkspaceMetadata(workspacePath, homeDir = os.homedir()) {
+export async function loadManagedWorkspaceMetadata(workspacePath, homeDir = null) {
   const resolvedWorkspacePath = resolveManagedWorkspacePath(workspacePath, homeDir);
   const metadataPath = path.join(resolvedWorkspacePath, CLAWORLD_MANAGED_WORKSPACE_METADATA_FILE);
   const raw = await readTextIfPresent(metadataPath);
@@ -214,12 +237,13 @@ function evaluateDurableFile({
   };
 }
 
-export async function seedManagedWorkspaceContract(options = {}, dryRun = false, homeDir = os.homedir()) {
-  const contract = buildManagedWorkspaceContract(options, homeDir);
+export async function seedManagedWorkspaceContract(options = {}, dryRun = false, homeDir = null) {
+  const resolvedHomeDir = resolveHomeDir(homeDir);
+  const contract = buildManagedWorkspaceContract(options, resolvedHomeDir);
   const agentDirPath = options.agentDirExplicit && options.agentDir
-    ? path.resolve(expandUserPath(options.agentDir, homeDir))
+    ? path.resolve(expandUserPath(options.agentDir, resolvedHomeDir))
     : null;
-  const metadataState = await loadManagedWorkspaceMetadata(contract.workspacePath, homeDir);
+  const metadataState = await loadManagedWorkspaceMetadata(contract.workspacePath, resolvedHomeDir);
   const previousFiles = metadataState.value?.files || {};
   const actions = [];