@xfxstudio/claworld 0.1.0

package/src/openclaw/installer/core.js

@@ -0,0 +1,1548 @@
+import fs from 'fs/promises';
+import os from 'os';
+import path from 'path';
+import { spawnSync } from 'child_process';
+import vm from 'vm';
+import {
+  DEFAULT_CLAWORLD_ACCOUNT_ID,
+  DEFAULT_CLAWORLD_SERVER_URL,
+  applyClaworldManagedRuntimeConfig,
+  ensureObject,
+  expandUserPath,
+  normalizeText,
+  resolveClaworldManagedRuntimeOptions,
+  resolveToolNames,
+} from '../plugin/managed-config.js';
+import {
+  defaultClaworldAccountId,
+  inspectClaworldChannelAccount,
+  listClaworldAccountIds,
+} from '../plugin/config-schema.js';
+import {
+  CLAWORLD_INSTALLER_COMMAND,
+  CLAWORLD_INSTALLER_PACKAGE_NAME,
+  CLAWORLD_OPENCLAW_MIN_HOST_VERSION,
+  CLAWORLD_UPDATE_COMMAND,
+} from './constants.js';
+import { seedManagedWorkspaceContract } from './workspace-contract.js';
+
+export const DEFAULT_OPENCLAW_BIN = 'openclaw';
+export const DEFAULT_OPENCLAW_CONFIG_PATH = '~/.openclaw/openclaw.json';
+export const DEFAULT_OPENCLAW_STATE_DIR = null;
+export const DEFAULT_INSTALL_TIMEOUT_MS = 15_000;
+export const DEFAULT_VERIFICATION_ATTEMPTS = 6;
+export const DEFAULT_VERIFICATION_DELAY_MS = 1_000;
+export const seedManagedWorkspace = seedManagedWorkspaceContract;
+const TRACKED_PLUGIN_UPDATEABLE_SOURCES = new Set(['npm', 'marketplace']);
+
+function listBindings(config = {}) {
+  return Array.isArray(config.bindings) ? config.bindings : [];
+}
+
+function findAgentEntry(config = {}, agentId) {
+  const list = Array.isArray(config?.agents?.list) ? config.agents.list : [];
+  return list
+    .map((item) => ensureObject(item))
+    .find((item) => item.id === agentId) || null;
+}
+
+export function hasManagedBinding(config = {}, { agentId, accountId } = {}) {
+  return listBindings(config).some((binding) => {
+    const candidate = ensureObject(binding);
+    const match = ensureObject(candidate.match);
+    return candidate.agentId === agentId
+      && match.channel === 'claworld'
+      && match.accountId === accountId;
+  });
+}
+
+export function isManagedToolAllowlistReady(config = {}, options = {}) {
+  const allow = new Set(
+    (Array.isArray(config?.tools?.allow) ? config.tools.allow : [])
+      .map((item) => normalizeText(item, null))
+      .filter(Boolean),
+  );
+  if (allow.has('*')) return true;
+  return resolveToolNames(options).every((toolName) => allow.has(toolName));
+}
+
+export function isRelayBootstrapReady(account = {}) {
+  return Boolean(
+    account?.configured
+    && (
+      normalizeText(account?.appToken, null)
+      || (
+        account?.registration?.enabled === true
+        && normalizeText(account?.registration?.agentCode, null)
+      )
+    ),
+  );
+}
+
+function parseCommandVersion(text) {
+  const match = String(text || '').match(/OpenClaw\s+([0-9]+(?:\.[0-9]+)+)/i)
+    || String(text || '').match(/([0-9]+(?:\.[0-9]+)+)/);
+  return match ? match[1] : null;
+}
+
+function parseVersionParts(version) {
+  const normalized = String(version || '')
+    .trim()
+    .replace(/^[^\d]+/, '');
+  return normalized
+    .split('.')
+    .map((value) => Number.parseInt(value, 10))
+    .filter((value) => Number.isFinite(value));
+}
+
+function compareVersionParts(leftVersion, rightVersion) {
+  const leftParts = parseVersionParts(leftVersion);
+  const rightParts = parseVersionParts(rightVersion);
+  const length = Math.max(leftParts.length, rightParts.length);
+  for (let index = 0; index < length; index += 1) {
+    const left = leftParts[index] ?? 0;
+    const right = rightParts[index] ?? 0;
+    if (left > right) return 1;
+    if (left < right) return -1;
+  }
+  return 0;
+}
+
+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 buildFetchHeaders({ apiKey = null, appToken = null, body = false } = {}) {
+  return {
+    accept: 'application/json',
+    ...(body ? { 'content-type': 'application/json' } : {}),
+    ...(apiKey ? { 'x-api-key': apiKey } : {}),
+    ...(appToken ? { authorization: `Bearer ${appToken}` } : {}),
+  };
+}
+
+function createInstallerError(code, message, context = {}) {
+  const error = new Error(message);
+  error.code = code;
+  error.context = context;
+  return error;
+}
+
+function cloneObject(value = {}) {
+  return JSON.parse(JSON.stringify(ensureObject(value)));
+}
+
+function parseJson(text, fallback = null) {
+  try {
+    return JSON.parse(String(text || '').trim());
+  } catch {
+    return fallback;
+  }
+}
+
+export function parseJsonDocument(text, fallback = null) {
+  const source = String(text || '').trim();
+  const direct = parseJson(source, null);
+  if (direct) return direct;
+
+  const lines = source.split('\n');
+  for (let index = 0; index < lines.length; index += 1) {
+    const candidate = lines.slice(index).join('\n').trim();
+    if (!candidate.startsWith('{') && !candidate.startsWith('[')) continue;
+    const parsed = parseJson(candidate, null);
+    if (parsed) return parsed;
+  }
+
+  return fallback;
+}
+
+function parseLegacyChannelTokenStatus(tokenValue = '') {
+  const normalized = normalizeText(tokenValue, '').toLowerCase();
+  if (!normalized || normalized === 'missing' || normalized === 'none' || normalized === 'unset') {
+    return {
+      tokenStatus: 'missing',
+      tokenSource: 'none',
+    };
+  }
+  if (
+    normalized === 'registration'
+    || normalized === 'registration-required'
+    || normalized === 'registration_required'
+    || normalized === 'agentcode'
+    || normalized === 'agent-code'
+  ) {
+    return {
+      tokenStatus: 'registration_required',
+      tokenSource: 'registration',
+    };
+  }
+  return {
+    tokenStatus: 'available',
+    tokenSource: normalized,
+  };
+}
+
+function parseLegacyChannelStatus(text = '') {
+  const entries = String(text || '')
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => line.match(/^-+\s*Claworld\s+(.+?):\s*(.+)$/i))
+    .filter(Boolean)
+    .map((match) => {
+      const accountId = normalizeText(match[1], null);
+      const flags = String(match[2] || '')
+        .split(',')
+        .map((flag) => flag.trim().toLowerCase())
+        .filter(Boolean);
+      const tokenFlag = flags.find((flag) => flag.startsWith('token:')) || '';
+      const tokenValue = tokenFlag.includes(':') ? tokenFlag.split(':').slice(1).join(':').trim() : '';
+      const tokenState = parseLegacyChannelTokenStatus(tokenValue);
+      const notConfigured = flags.includes('not configured') || flags.includes('unconfigured');
+
+      return {
+        accountId,
+        enabled: flags.includes('disabled') ? false : true,
+        configured: notConfigured ? false : flags.includes('configured'),
+        ...tokenState,
+        rawStatus: flags,
+      };
+    })
+    .filter((entry) => entry.accountId);
+
+  if (entries.length === 0) {
+    return null;
+  }
+
+  return {
+    channels: {
+      claworld: {
+        configured: entries.some((entry) => entry.configured === true),
+      },
+    },
+    channelAccounts: {
+      claworld: entries,
+    },
+    sourceFormat: 'legacy_text',
+  };
+}
+
+function readClaworldAccountStatus(channelsStatus, accountId) {
+  const items = Array.isArray(channelsStatus?.channelAccounts?.claworld)
+    ? channelsStatus.channelAccounts.claworld
+    : [];
+  return items.find((item) => item?.accountId === accountId) || null;
+}
+
+function parsePluginInfo(text = '') {
+  const source = String(text || '');
+  const status = source.match(/^\s*Status:\s+(.+)$/m)?.[1]?.trim() || null;
+  const install = source.match(/^\s*Install:\s+(.+)$/m)?.[1]?.trim() || null;
+  const sourcePath = source.match(/^\s*Source path:\s+(.+)$/m)?.[1]?.trim() || null;
+  const version = source.match(/^\s*Version:\s+(.+)$/m)?.[1]?.trim()
+    || source.match(/^\s*Recorded version:\s+(.+)$/m)?.[1]?.trim()
+    || null;
+  return {
+    installed: Boolean(source.trim()),
+    loaded: status === 'loaded',
+    status,
+    install,
+    sourcePath,
+    version,
+    raw: source,
+  };
+}
+
+function parseBindingLine(text = '', { agentId, accountId } = {}) {
+  return String(text || '')
+    .split('\n')
+    .map((line) => line.trim())
+    .find((line) => line === `- ${agentId} <- claworld accountId=${accountId}`) || null;
+}
+
+function inspectTrackedClaworldPluginInstall(config = {}) {
+  const installRecord = ensureObject(config?.plugins?.installs?.claworld);
+  const tracked = Object.keys(installRecord).length > 0;
+  const source = normalizeText(installRecord.source, null);
+  return {
+    tracked,
+    updateable: tracked && TRACKED_PLUGIN_UPDATEABLE_SOURCES.has(source),
+    source,
+    spec: normalizeText(installRecord.spec, null),
+    resolvedSpec: normalizeText(installRecord.resolvedSpec, null),
+    resolvedVersion: normalizeText(installRecord.resolvedVersion, null),
+    installPath: normalizeText(installRecord.installPath, null),
+    record: tracked ? installRecord : null,
+  };
+}
+
+function needsPluginBootstrapConfig(config = {}) {
+  if (config?.channels?.claworld) {
+    return true;
+  }
+  return listBindings(config).some((binding) => ensureObject(binding).match?.channel === 'claworld');
+}
+
+function buildPluginBootstrapConfig(config = {}) {
+  const next = cloneObject(config);
+
+  const channels = ensureObject(next.channels);
+  if (Object.prototype.hasOwnProperty.call(channels, 'claworld')) {
+    delete channels.claworld;
+  }
+  if (Object.keys(channels).length > 0) {
+    next.channels = channels;
+  } else {
+    delete next.channels;
+  }
+
+  if (Array.isArray(next.bindings)) {
+    next.bindings = next.bindings.filter((binding) => ensureObject(binding).match?.channel !== 'claworld');
+  }
+
+  return next;
+}
+
+async function preparePluginBootstrapConfig({
+  configPath = null,
+  config = {},
+  dryRun = false,
+} = {}) {
+  if (!configPath || !needsPluginBootstrapConfig(config)) {
+    return null;
+  }
+
+  if (dryRun) {
+    return {
+      configPath,
+      pluginConfig: ensureObject(config.plugins),
+      cleanup: async () => {},
+    };
+  }
+
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'claworld-plugin-bootstrap-'));
+  const tempConfigPath = path.join(tempRoot, path.basename(configPath || 'openclaw.json'));
+  await writeConfig(tempConfigPath, buildPluginBootstrapConfig(config));
+  return {
+    configPath: tempConfigPath,
+    pluginConfig: null,
+    cleanup: async () => {
+      await fs.rm(tempRoot, { recursive: true, force: true });
+    },
+  };
+}
+
+function mergePluginMetadata(config = {}, pluginConfig = {}) {
+  const extraPlugins = ensureObject(pluginConfig);
+  if (Object.keys(extraPlugins).length === 0) {
+    return cloneObject(config);
+  }
+
+  const next = cloneObject(config);
+  const existingPlugins = ensureObject(next.plugins);
+  next.plugins = {
+    ...existingPlugins,
+    ...extraPlugins,
+    entries: {
+      ...ensureObject(existingPlugins.entries),
+      ...ensureObject(extraPlugins.entries),
+    },
+    installs: {
+      ...ensureObject(existingPlugins.installs),
+      ...ensureObject(extraPlugins.installs),
+    },
+  };
+  return next;
+}
+
+function defaultCommandRunner({
+  bin,
+  args,
+  cwd = process.cwd(),
+  env = process.env,
+  dryRun = false,
+  capture = true,
+} = {}) {
+  const rendered = [bin, ...args].join(' ');
+  if (dryRun) {
+    return {
+      status: 0,
+      stdout: '',
+      stderr: '',
+      rendered,
+      dryRun: true,
+    };
+  }
+
+  const result = spawnSync(bin, args, {
+    cwd,
+    env,
+    stdio: capture ? 'pipe' : 'inherit',
+    encoding: 'utf8',
+  });
+
+  if (result.error) {
+    const error = createInstallerError(
+      'openclaw_command_failed',
+      `Failed to run "${rendered}": ${result.error.message}`,
+      { rendered },
+    );
+    error.cause = result.error;
+    throw error;
+  }
+
+  return {
+    status: result.status ?? 0,
+    stdout: result.stdout || '',
+    stderr: result.stderr || '',
+    rendered,
+  };
+}
+
+async function executeCommand({
+  commandRunner = defaultCommandRunner,
+  bin,
+  args,
+  cwd = process.cwd(),
+  env = process.env,
+  dryRun = false,
+  capture = true,
+  allowFailure = false,
+} = {}) {
+  const result = await Promise.resolve(commandRunner({
+    bin,
+    args,
+    cwd,
+    env,
+    dryRun,
+    capture,
+  }));
+  if (!allowFailure && result.status !== 0) {
+    throw createInstallerError(
+      'openclaw_command_failed',
+      `Command failed (${result.status}): ${result.rendered || [bin, ...args].join(' ')}`,
+      { result },
+    );
+  }
+  return result;
+}
+
+export function parseConfigObject(sourceText, sourceLabel = 'openclaw config') {
+  const text = String(sourceText || '').replace(/^\uFEFF/, '').trim();
+  if (!text) return {};
+
+  try {
+    const parsed = JSON.parse(text);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      throw new Error('config root must be an object');
+    }
+    return parsed;
+  } catch {}
+
+  try {
+    const expression = text.replace(/;\s*$/, '');
+    const script = new vm.Script(`(${expression}\n)`, { filename: sourceLabel });
+    const result = script.runInNewContext(Object.create(null), { timeout: 1000 });
+    if (!result || typeof result !== 'object' || Array.isArray(result)) {
+      throw new Error('config root must evaluate to an object');
+    }
+    return JSON.parse(JSON.stringify(result));
+  } catch (error) {
+    throw createInstallerError(
+      'invalid_openclaw_config',
+      `Failed to parse ${sourceLabel}: ${error.message}`,
+      { sourceLabel },
+    );
+  }
+}
+
+export async function loadConfigFromDisk(configPath) {
+  try {
+    const raw = await fs.readFile(configPath, 'utf8');
+    return { existed: true, config: parseConfigObject(raw, configPath) };
+  } catch (error) {
+    if (error && error.code === 'ENOENT') {
+      return { existed: false, config: {} };
+    }
+    throw error;
+  }
+}
+
+export async function backupConfigIfPresent(configPath, existed, dryRun = false) {
+  if (!existed) return null;
+  const stamp = new Date().toISOString().replace(/[-:]/g, '').replace(/\..+$/, '').replace('T', '-');
+  const backupPath = `${configPath}.bak.${stamp}`;
+  if (dryRun) return backupPath;
+  await fs.copyFile(configPath, backupPath);
+  return backupPath;
+}
+
+export async function writeConfig(configPath, config, dryRun = false) {
+  const rendered = `${JSON.stringify(config, null, 2)}\n`;
+  if (dryRun) return rendered;
+  await fs.mkdir(path.dirname(configPath), { recursive: true });
+  await fs.writeFile(configPath, rendered, 'utf8');
+  return rendered;
+}
+
+export function buildOpenclawCommandEnv({ configPath, stateDir = null, env = process.env } = {}) {
+  return {
+    ...env,
+    ...(configPath ? { OPENCLAW_CONFIG_PATH: configPath } : {}),
+    ...(stateDir ? { OPENCLAW_STATE_DIR: stateDir } : {}),
+  };
+}
+
+export function inspectManagedClaworldInstall({
+  cfg = {},
+  accountId = DEFAULT_CLAWORLD_ACCOUNT_ID,
+  input = {},
+  overrides = {},
+} = {}) {
+  const configuredAccountIds = listClaworldAccountIds(cfg);
+  const hasAnyConfig = configuredAccountIds.length > 0 || cfg?.channels?.claworld != null;
+  const managedOptions = resolveClaworldManagedRuntimeOptions({
+    cfg,
+    accountId,
+    input,
+    overrides,
+  });
+  const managedAgentPresent = Boolean(findAgentEntry(cfg, managedOptions.agentId));
+  const managedBindingPresent = hasManagedBinding(cfg, managedOptions);
+  const toolsReady = isManagedToolAllowlistReady(cfg, managedOptions);
+  const managedAccountPresent = configuredAccountIds.includes(managedOptions.accountId);
+  const accountStatus = managedAccountPresent
+    ? inspectClaworldChannelAccount(cfg, managedOptions.accountId)
+    : inspectClaworldChannelAccount({}, managedOptions.accountId);
+  const managedRuntimeReady = isRelayBootstrapReady(accountStatus);
+  const managedReady = Boolean(
+    managedAccountPresent
+    && managedRuntimeReady
+    && managedAgentPresent
+    && managedBindingPresent
+    && toolsReady
+  );
+
+  let statusLabel = 'needs setup';
+  let selectionHint = 'remote relay world channel';
+  if (managedRuntimeReady) {
+    statusLabel = managedReady ? 'configured' : 'configured (managed refresh recommended)';
+    selectionHint = managedReady ? 'configured · managed runtime' : 'configured · managed refresh';
+  } else if (hasAnyConfig) {
+    statusLabel = 'needs refresh';
+    selectionHint = 'needs refresh · remote relay';
+  }
+
+  return {
+    hasAnyConfig,
+    configuredAccountIds,
+    defaultAccountId: defaultClaworldAccountId(cfg) || null,
+    managedOptions,
+    managedAccountPresent,
+    managedAgentPresent,
+    managedBindingPresent,
+    toolsReady,
+    accountStatus,
+    managedRuntimeReady,
+    managedReady,
+    reusableAppToken: normalizeText(accountStatus?.appToken, null),
+    statusLabel,
+    selectionHint,
+    quickstartScore: managedRuntimeReady ? 2 : 5,
+  };
+}
+
+export function buildManagedOnboardingStatus({ cfg = {}, accountId = DEFAULT_CLAWORLD_ACCOUNT_ID } = {}) {
+  const inspection = inspectManagedClaworldInstall({ cfg, accountId });
+  const configured = inspection.configuredAccountIds.some((configuredAccountId) =>
+    isRelayBootstrapReady(inspectClaworldChannelAccount(cfg, configuredAccountId)),
+  );
+  return {
+    configured,
+    statusLines: [`Claworld: ${inspection.statusLabel}`],
+    selectionHint: inspection.selectionHint,
+    quickstartScore: configured ? 2 : inspection.quickstartScore,
+  };
+}
+
+export async function detectOpenclawHost({
+  openclawBin = DEFAULT_OPENCLAW_BIN,
+  commandRunner = defaultCommandRunner,
+  cwd = process.cwd(),
+  env = process.env,
+  dryRun = false,
+} = {}) {
+  const result = await executeCommand({
+    commandRunner,
+    bin: openclawBin,
+    args: ['--version'],
+    cwd,
+    env,
+    dryRun,
+  });
+  const version = parseCommandVersion(result.stdout || result.stderr);
+  if (!version) {
+    throw createInstallerError(
+      'openclaw_version_unreadable',
+      'Unable to determine the installed OpenClaw version.',
+      { result },
+    );
+  }
+  return {
+    version,
+    raw: (result.stdout || result.stderr || '').trim(),
+  };
+}
+
+export async function inspectClaworldPluginInstall({
+  openclawBin = DEFAULT_OPENCLAW_BIN,
+  configPath = null,
+  stateDir = DEFAULT_OPENCLAW_STATE_DIR,
+  commandRunner = defaultCommandRunner,
+  cwd = process.cwd(),
+  env = process.env,
+  dryRun = false,
+} = {}) {
+  const result = await executeCommand({
+    commandRunner,
+    bin: openclawBin,
+    args: ['plugins', 'info', 'claworld'],
+    cwd,
+    env: buildOpenclawCommandEnv({ configPath, stateDir, env }),
+    dryRun,
+    allowFailure: true,
+  });
+  if (result.status !== 0) {
+    return {
+      installed: false,
+      loaded: false,
+      status: null,
+      raw: `${result.stdout || ''}${result.stderr || ''}`.trim(),
+    };
+  }
+  return parsePluginInfo(`${result.stdout || ''}${result.stderr || ''}`);
+}
+
+export async function ensureClaworldPluginInstalled({
+  openclawBin = DEFAULT_OPENCLAW_BIN,
+  configPath = null,
+  stateDir = DEFAULT_OPENCLAW_STATE_DIR,
+  config = {},
+  commandRunner = defaultCommandRunner,
+  cwd = process.cwd(),
+  env = process.env,
+  dryRun = false,
+  installMode = 'npm',
+  installSource = CLAWORLD_INSTALLER_PACKAGE_NAME,
+  refresh = false,
+} = {}) {
+  const bootstrap = await preparePluginBootstrapConfig({
+    configPath,
+    config,
+    dryRun,
+  });
+  const pluginConfigPath = bootstrap?.configPath || configPath;
+
+  try {
+    const before = await inspectClaworldPluginInstall({
+      openclawBin,
+      configPath: pluginConfigPath,
+      stateDir,
+      commandRunner,
+      cwd,
+      env,
+      dryRun,
+    });
+    if (before.installed && !refresh) {
+      return {
+        changed: false,
+        action: 'reused_existing_plugin_install',
+        plugin: before,
+        pluginConfig: bootstrap?.pluginConfig || null,
+      };
+    }
+
+    if (installMode === 'skip') {
+      return {
+        changed: false,
+        action: 'skipped_plugin_install',
+        plugin: before,
+        pluginConfig: bootstrap?.pluginConfig || null,
+      };
+    }
+
+    if (before.installed && refresh && installMode === 'copy') {
+      await executeCommand({
+        commandRunner,
+        bin: openclawBin,
+        args: ['plugins', 'uninstall', 'claworld', '--force'],
+        cwd,
+        env: buildOpenclawCommandEnv({ configPath: pluginConfigPath, stateDir, env }),
+        dryRun,
+        capture: false,
+      });
+    }
+
+    const args = ['plugins', 'install'];
+    if (installMode === 'link') args.push('--link');
+    args.push(installSource);
+    await executeCommand({
+      commandRunner,
+      bin: openclawBin,
+      args,
+      cwd,
+      env: buildOpenclawCommandEnv({ configPath: pluginConfigPath, stateDir, env }),
+      dryRun,
+      capture: false,
+    });
+
+    const after = await inspectClaworldPluginInstall({
+      openclawBin,
+      configPath: pluginConfigPath,
+      stateDir,
+      commandRunner,
+      cwd,
+      env,
+      dryRun,
+    });
+    if (!after.installed) {
+      throw createInstallerError(
+        'claworld_plugin_install_failed',
+        'OpenClaw did not report the claworld plugin as installed after plugin install.',
+        { installMode, installSource, before, after },
+      );
+    }
+
+    const pluginConfig = pluginConfigPath
+      ? (await loadConfigFromDisk(pluginConfigPath)).config?.plugins || null
+      : null;
+
+    return {
+      changed: true,
+      action: before.installed ? 'refreshed_plugin_install' : 'installed_plugin',
+      plugin: after,
+      pluginConfig,
+    };
+  } finally {
+    if (bootstrap) {
+      await bootstrap.cleanup();
+    }
+  }
+}
+
+export async function updateTrackedClaworldPluginInstall({
+  openclawBin = DEFAULT_OPENCLAW_BIN,
+  configPath = null,
+  stateDir = DEFAULT_OPENCLAW_STATE_DIR,
+  config = {},
+  commandRunner = defaultCommandRunner,
+  cwd = process.cwd(),
+  env = process.env,
+  dryRun = false,
+} = {}) {
+  const trackedInstall = inspectTrackedClaworldPluginInstall(config);
+  const before = await inspectClaworldPluginInstall({
+    openclawBin,
+    configPath,
+    stateDir,
+    commandRunner,
+    cwd,
+    env,
+    dryRun,
+  });
+
+  if (!before.installed) {
+    throw createInstallerError(
+      'claworld_plugin_not_installed',
+      'The Claworld plugin is not installed or not discoverable. Run the install command before update.',
+      { plugin: before, trackedInstall },
+    );
+  }
+
+  if (!trackedInstall.tracked) {
+    return {
+      changed: false,
+      action: 'skipped_untracked_plugin_update',
+      reason: 'plugins.installs.claworld_missing',
+      trackedInstall,
+      plugin: before,
+    };
+  }
+
+  if (!trackedInstall.updateable) {
+    return {
+      changed: false,
+      action: 'skipped_untracked_plugin_update',
+      reason: `plugins.installs.claworld_source_${trackedInstall.source || 'unknown'}_is_not_host_updateable`,
+      trackedInstall,
+      plugin: before,
+    };
+  }
+
+  await executeCommand({
+    commandRunner,
+    bin: openclawBin,
+    args: ['plugins', 'update', 'claworld'],
+    cwd,
+    env: buildOpenclawCommandEnv({ configPath, stateDir, env }),
+    dryRun,
+    capture: false,
+  });
+
+  const after = await inspectClaworldPluginInstall({
+    openclawBin,
+    configPath,
+    stateDir,
+    commandRunner,
+    cwd,
+    env,
+    dryRun,
+  });
+
+  if (!after.installed) {
+    throw createInstallerError(
+      'claworld_plugin_update_failed',
+      'OpenClaw no longer reported the claworld plugin as installed after plugin update.',
+      { before, after, trackedInstall },
+    );
+  }
+
+  return {
+    changed: true,
+    action: dryRun ? 'dry_run_tracked_plugin_update' : 'updated_tracked_plugin',
+    trackedInstall,
+    plugin: after,
+  };
+}
+
+async function fetchJson(fetchImpl, url, init = {}) {
+  let response;
+  try {
+    response = await fetchImpl(url, init);
+  } catch (error) {
+    throw createInstallerError(
+      'installer_fetch_failed',
+      `Failed to reach ${url}: ${error?.message || String(error)}`,
+      { url, method: init?.method || 'GET' },
+    );
+  }
+
+  const text = await response.text();
+  return {
+    ok: response.ok,
+    status: response.status,
+    body: parseJsonDocument(text, null),
+    text,
+  };
+}
+
+export async function fetchInstallManifest({
+  serverUrl = DEFAULT_CLAWORLD_SERVER_URL,
+  apiKey = null,
+  fetchImpl = globalThis.fetch?.bind(globalThis),
+} = {}) {
+  if (typeof fetchImpl !== 'function') {
+    throw createInstallerError('missing_fetch', 'Install manifest fetch requires a fetch implementation.');
+  }
+  const url = `${normalizeRelayHttpBaseUrl(serverUrl)}/v1/meta/install`;
+  const response = await fetchJson(fetchImpl, url, {
+    method: 'GET',
+    headers: buildFetchHeaders({ apiKey }),
+  });
+  if (!response.ok || !response.body) {
+    throw createInstallerError(
+      'install_manifest_unavailable',
+      `Failed to read Claworld install contract from ${url}.`,
+      { url, response },
+    );
+  }
+  return response.body;
+}
+
+export async function activateInstall({
+  serverUrl = DEFAULT_CLAWORLD_SERVER_URL,
+  apiKey = null,
+  appToken = null,
+  displayName = null,
+  fetchImpl = globalThis.fetch?.bind(globalThis),
+} = {}) {
+  if (typeof fetchImpl !== 'function') {
+    throw createInstallerError('missing_fetch', 'Install activation requires a fetch implementation.');
+  }
+  const url = `${normalizeRelayHttpBaseUrl(serverUrl)}/v1/onboarding/activate`;
+  const body = {};
+  if (displayName) {
+    body.displayName = displayName;
+  }
+  const response = await fetchJson(fetchImpl, url, {
+    method: 'POST',
+    headers: buildFetchHeaders({ apiKey, appToken, body: true }),
+    body: JSON.stringify(body),
+  });
+  if (!response.ok || !response.body) {
+    throw createInstallerError(
+      'install_activation_failed',
+      `Failed to activate Claworld install via ${url}.`,
+      { url, response },
+    );
+  }
+  return response.body;
+}
+
+export async function readGatewayStatus({
+  openclawBin = DEFAULT_OPENCLAW_BIN,
+  configPath = null,
+  stateDir = DEFAULT_OPENCLAW_STATE_DIR,
+  commandRunner = defaultCommandRunner,
+  cwd = process.cwd(),
+  env = process.env,
+  dryRun = false,
+} = {}) {
+  const result = await executeCommand({
+    commandRunner,
+    bin: openclawBin,
+    args: ['gateway', 'status', '--json', '--no-probe'],
+    cwd,
+    env: buildOpenclawCommandEnv({ configPath, stateDir, env }),
+    dryRun,
+  });
+  const payload = parseJsonDocument(`${result.stdout || ''}\n${result.stderr || ''}`, null);
+  if (!payload) {
+    throw createInstallerError(
+      'invalid_gateway_status',
+      'OpenClaw gateway status did not produce JSON output.',
+      { result },
+    );
+  }
+  return payload;
+}
+
+export async function readChannelStatus({
+  openclawBin = DEFAULT_OPENCLAW_BIN,
+  configPath = null,
+  stateDir = DEFAULT_OPENCLAW_STATE_DIR,
+  commandRunner = defaultCommandRunner,
+  cwd = process.cwd(),
+  env = process.env,
+  dryRun = false,
+} = {}) {
+  const result = await executeCommand({
+    commandRunner,
+    bin: openclawBin,
+    args: ['channels', 'status', '--json'],
+    cwd,
+    env: buildOpenclawCommandEnv({ configPath, stateDir, env }),
+    dryRun,
+  });
+  const output = `${result.stdout || ''}\n${result.stderr || ''}`;
+  const payload = parseJsonDocument(output, null) || parseLegacyChannelStatus(output);
+  if (!payload) {
+    throw createInstallerError(
+      'invalid_channel_status',
+      'OpenClaw channel status did not produce JSON output.',
+      { result },
+    );
+  }
+  return payload;
+}
+
+export async function readAgentBindings({
+  openclawBin = DEFAULT_OPENCLAW_BIN,
+  configPath = null,
+  stateDir = DEFAULT_OPENCLAW_STATE_DIR,
+  commandRunner = defaultCommandRunner,
+  cwd = process.cwd(),
+  env = process.env,
+  dryRun = false,
+} = {}) {
+  return await executeCommand({
+    commandRunner,
+    bin: openclawBin,
+    args: ['agents', 'bindings'],
+    cwd,
+    env: buildOpenclawCommandEnv({ configPath, stateDir, env }),
+    dryRun,
+    allowFailure: true,
+  });
+}
+
+export async function validateOpenclawConfig({
+  openclawBin = DEFAULT_OPENCLAW_BIN,
+  configPath = null,
+  stateDir = DEFAULT_OPENCLAW_STATE_DIR,
+  commandRunner = defaultCommandRunner,
+  cwd = process.cwd(),
+  env = process.env,
+  dryRun = false,
+} = {}) {
+  await executeCommand({
+    commandRunner,
+    bin: openclawBin,
+    args: ['config', 'validate'],
+    cwd,
+    env: buildOpenclawCommandEnv({ configPath, stateDir, env }),
+    dryRun,
+    capture: false,
+  });
+  return { ok: true };
+}
+
+export async function refreshOpenclawRuntime({
+  openclawBin = DEFAULT_OPENCLAW_BIN,
+  configPath = null,
+  stateDir = DEFAULT_OPENCLAW_STATE_DIR,
+  commandRunner = defaultCommandRunner,
+  cwd = process.cwd(),
+  env = process.env,
+  dryRun = false,
+} = {}) {
+  const commandEnv = buildOpenclawCommandEnv({ configPath, stateDir, env });
+  const restart = await executeCommand({
+    commandRunner,
+    bin: openclawBin,
+    args: ['gateway', 'restart'],
+    cwd,
+    env: commandEnv,
+    dryRun,
+    capture: false,
+    allowFailure: true,
+  });
+  if (restart.status === 0) {
+    return { ok: true, action: 'restart', result: restart };
+  }
+
+  const start = await executeCommand({
+    commandRunner,
+    bin: openclawBin,
+    args: ['gateway', 'start'],
+    cwd,
+    env: commandEnv,
+    dryRun,
+    capture: false,
+    allowFailure: true,
+  });
+  if (start.status === 0) {
+    return { ok: true, action: 'start', result: start };
+  }
+
+  throw createInstallerError(
+    'openclaw_gateway_refresh_failed',
+    'Failed to restart or start the OpenClaw gateway service.',
+    { restart, start },
+  );
+}
+
+function wait(delayMs) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, delayMs);
+  });
+}
+
+export async function verifyClaworldInstall({
+  openclawBin = DEFAULT_OPENCLAW_BIN,
+  configPath = null,
+  stateDir = DEFAULT_OPENCLAW_STATE_DIR,
+  accountId = DEFAULT_CLAWORLD_ACCOUNT_ID,
+  agentId = DEFAULT_CLAWORLD_ACCOUNT_ID,
+  commandRunner = defaultCommandRunner,
+  cwd = process.cwd(),
+  env = process.env,
+  dryRun = false,
+  attempts = DEFAULT_VERIFICATION_ATTEMPTS,
+  delayMs = DEFAULT_VERIFICATION_DELAY_MS,
+} = {}) {
+  let lastResult = null;
+
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    const [plugin, gatewayStatus, channelStatus, bindings] = await Promise.all([
+      inspectClaworldPluginInstall({
+        openclawBin,
+        configPath,
+        stateDir,
+        commandRunner,
+        cwd,
+        env,
+        dryRun,
+      }),
+      readGatewayStatus({
+        openclawBin,
+        configPath,
+        stateDir,
+        commandRunner,
+        cwd,
+        env,
+        dryRun,
+      }),
+      readChannelStatus({
+        openclawBin,
+        configPath,
+        stateDir,
+        commandRunner,
+        cwd,
+        env,
+        dryRun,
+      }),
+      readAgentBindings({
+        openclawBin,
+        configPath,
+        stateDir,
+        commandRunner,
+        cwd,
+        env,
+        dryRun,
+      }),
+    ]);
+
+    const channelAccount = readClaworldAccountStatus(channelStatus, accountId);
+    const gatewayRunning = gatewayStatus?.service?.runtime?.status === 'running';
+    const bindingLine = parseBindingLine(`${bindings.stdout || ''}${bindings.stderr || ''}`, {
+      agentId,
+      accountId,
+    });
+    const channelReady = Boolean(
+      channelAccount
+      && channelAccount.configured === true
+      && channelAccount.enabled !== false
+      && channelAccount.tokenStatus === 'available'
+    );
+    const pluginReady = Boolean(plugin.installed);
+    const bindingReady = Boolean(bindingLine);
+
+    lastResult = {
+      ok: pluginReady && gatewayRunning && channelReady && bindingReady,
+      attempt,
+      plugin,
+      gatewayStatus,
+      channelStatus,
+      channelAccount,
+      bindingLine,
+      gatewayRunning,
+      channelReady,
+      bindingReady,
+    };
+
+    if (lastResult.ok) {
+      return lastResult;
+    }
+    if (attempt < attempts) {
+      await wait(delayMs);
+    }
+  }
+
+  return lastResult || {
+    ok: false,
+    attempt: 0,
+  };
+}
+
+async function reconcileManagedClaworldRuntime({
+  openclawBin = DEFAULT_OPENCLAW_BIN,
+  configPath = DEFAULT_OPENCLAW_CONFIG_PATH,
+  stateDir = DEFAULT_OPENCLAW_STATE_DIR,
+  currentConfigState = { existed: false, config: {} },
+  currentConfig = {},
+  host = null,
+  serverUrl = null,
+  apiKey = null,
+  accountId = DEFAULT_CLAWORLD_ACCOUNT_ID,
+  agentId = DEFAULT_CLAWORLD_ACCOUNT_ID,
+  workspace = null,
+  displayName = null,
+  toolProfile = null,
+  approvalMode = null,
+  sessionDmScope = null,
+  repoRoot = null,
+  fetchImpl = globalThis.fetch?.bind(globalThis),
+  commandRunner = defaultCommandRunner,
+  cwd = process.cwd(),
+  env = process.env,
+  dryRun = false,
+  timeoutMs = DEFAULT_INSTALL_TIMEOUT_MS,
+} = {}) {
+  const existingInstall = inspectManagedClaworldInstall({
+    cfg: currentConfig,
+    accountId,
+    overrides: {
+      agentId,
+      workspace,
+      displayName,
+      toolProfile,
+      approvalMode,
+      sessionDmScope,
+      ...(repoRoot ? { repoRoot } : {}),
+    },
+  });
+  const effectiveServerUrl = normalizeText(
+    serverUrl,
+    normalizeText(existingInstall.accountStatus?.serverUrl, DEFAULT_CLAWORLD_SERVER_URL),
+  );
+
+  const manifest = await fetchInstallManifest({
+    serverUrl: effectiveServerUrl,
+    apiKey,
+    fetchImpl,
+  });
+  const manifestMinHostVersion = normalizeText(
+    manifest?.installer?.minHostVersion,
+    normalizeText(manifest?.plugin?.minHostVersion, CLAWORLD_OPENCLAW_MIN_HOST_VERSION),
+  );
+  if (host && compareVersionParts(host.version, manifestMinHostVersion) < 0) {
+    throw createInstallerError(
+      'openclaw_version_too_old',
+      `OpenClaw ${host.version} is below the required minimum ${manifestMinHostVersion}.`,
+      { hostVersion: host.version, minHostVersion: manifestMinHostVersion },
+    );
+  }
+
+  const installAccountId = normalizeText(
+    accountId,
+    normalizeText(manifest?.setup?.defaultAccountId, DEFAULT_CLAWORLD_ACCOUNT_ID),
+  );
+  const installAgentId = normalizeText(
+    agentId,
+    normalizeText(manifest?.setup?.defaultLocalAgentId, installAccountId),
+  );
+
+  const preflight = inspectManagedClaworldInstall({
+    cfg: currentConfig,
+    accountId: installAccountId,
+    overrides: {
+      agentId: installAgentId,
+      workspace,
+      serverUrl: effectiveServerUrl,
+      displayName,
+      toolProfile,
+      approvalMode,
+      sessionDmScope,
+      ...(repoRoot ? { repoRoot } : {}),
+    },
+  });
+  const desiredDisplayName = normalizeText(
+    displayName,
+    normalizeText(preflight.managedOptions.displayName, null),
+  );
+
+  let activation = null;
+  let activationMode = 'new_activation';
+  const existingAppToken = normalizeText(preflight.reusableAppToken, null);
+  if (existingAppToken) {
+    try {
+      activation = await activateInstall({
+        serverUrl: effectiveServerUrl,
+        apiKey,
+        appToken: existingAppToken,
+        displayName: desiredDisplayName,
+        fetchImpl,
+      });
+      activationMode = 'reused_existing_token';
+    } catch (error) {
+      const status = error?.context?.response?.status;
+      if (status !== 401 && status !== 403) {
+        throw error;
+      }
+    }
+  }
+  if (!activation) {
+    activation = await activateInstall({
+      serverUrl: effectiveServerUrl,
+      apiKey,
+      displayName: desiredDisplayName,
+      fetchImpl,
+    });
+    activationMode = 'created_new_activation';
+  }
+
+  const managedOptions = resolveClaworldManagedRuntimeOptions({
+    cfg: currentConfig,
+    accountId: installAccountId,
+    input: {
+      name: desiredDisplayName,
+      appToken: activation.appToken,
+      toolProfile,
+    },
+    overrides: {
+      agentId: installAgentId,
+      workspace,
+      serverUrl: effectiveServerUrl,
+      apiKey,
+      appToken: activation.appToken,
+      displayName: desiredDisplayName,
+      toolProfile,
+      approvalMode,
+      sessionDmScope,
+      replaceManagedRuntime: true,
+      installPlugin: false,
+      pluginInstallMode: 'skip',
+      ...(repoRoot ? { repoRoot } : {}),
+    },
+  });
+
+  const transformed = applyClaworldManagedRuntimeConfig(currentConfig, managedOptions);
+  const configChanged = JSON.stringify(currentConfig) !== JSON.stringify(transformed.config);
+  const backupPath = configChanged
+    ? await backupConfigIfPresent(configPath, currentConfigState.existed, dryRun)
+    : null;
+  if (configChanged) {
+    await writeConfig(configPath, transformed.config, dryRun);
+  }
+
+  const workspaceActions = await seedManagedWorkspace(managedOptions, dryRun);
+  await validateOpenclawConfig({
+    openclawBin,
+    configPath,
+    stateDir,
+    commandRunner,
+    cwd,
+    env,
+    dryRun,
+  });
+  const runtimeRefresh = await refreshOpenclawRuntime({
+    openclawBin,
+    configPath,
+    stateDir,
+    commandRunner,
+    cwd,
+    env,
+    dryRun,
+  });
+  const verification = await verifyClaworldInstall({
+    openclawBin,
+    configPath,
+    stateDir,
+    accountId: installAccountId,
+    agentId: installAgentId,
+    commandRunner,
+    cwd,
+    env,
+    dryRun,
+    delayMs: Math.min(timeoutMs, DEFAULT_VERIFICATION_DELAY_MS),
+  });
+  if (!verification.ok) {
+    throw createInstallerError(
+      'claworld_install_verification_failed',
+      'Claworld install verification did not confirm the managed account binding.',
+      { verification },
+    );
+  }
+
+  return {
+    backupPath,
+    existingInstall,
+    effectiveServerUrl,
+    manifest,
+    preflight,
+    activationMode,
+    activation,
+    managedOptions,
+    transformed,
+    configChanged,
+    workspaceActions,
+    runtimeRefresh,
+    verification,
+  };
+}
+
+export async function runClaworldInstallerInstall({
+  openclawBin = DEFAULT_OPENCLAW_BIN,
+  configPath = DEFAULT_OPENCLAW_CONFIG_PATH,
+  stateDir = DEFAULT_OPENCLAW_STATE_DIR,
+  serverUrl = null,
+  apiKey = null,
+  accountId = DEFAULT_CLAWORLD_ACCOUNT_ID,
+  agentId = DEFAULT_CLAWORLD_ACCOUNT_ID,
+  workspace = null,
+  displayName = null,
+  toolProfile = null,
+  approvalMode = null,
+  sessionDmScope = null,
+  repoRoot = null,
+  pluginInstallMode = 'npm',
+  pluginInstallSource = CLAWORLD_INSTALLER_PACKAGE_NAME,
+  fetchImpl = globalThis.fetch?.bind(globalThis),
+  commandRunner = defaultCommandRunner,
+  cwd = process.cwd(),
+  env = process.env,
+  dryRun = false,
+  timeoutMs = DEFAULT_INSTALL_TIMEOUT_MS,
+} = {}) {
+  const resolvedConfigPath = path.resolve(expandUserPath(configPath, os.homedir()));
+  const resolvedStateDir = stateDir ? path.resolve(expandUserPath(stateDir, os.homedir())) : null;
+  const commandEnv = buildOpenclawCommandEnv({
+    configPath: resolvedConfigPath,
+    stateDir: resolvedStateDir,
+    env,
+  });
+  const currentConfigState = await loadConfigFromDisk(resolvedConfigPath);
+  const currentConfigBeforePluginInstall = currentConfigState.config;
+  const host = await detectOpenclawHost({
+    openclawBin,
+    commandRunner,
+    cwd,
+    env: commandEnv,
+    dryRun,
+  });
+  if (compareVersionParts(host.version, CLAWORLD_OPENCLAW_MIN_HOST_VERSION) < 0) {
+    throw createInstallerError(
+      'openclaw_version_too_old',
+      `OpenClaw ${host.version} is below the required minimum ${CLAWORLD_OPENCLAW_MIN_HOST_VERSION}.`,
+      { hostVersion: host.version, minHostVersion: CLAWORLD_OPENCLAW_MIN_HOST_VERSION },
+    );
+  }
+
+  const plugin = await ensureClaworldPluginInstalled({
+    openclawBin,
+    configPath: resolvedConfigPath,
+    stateDir: resolvedStateDir,
+    config: currentConfigBeforePluginInstall,
+    commandRunner,
+    cwd,
+    env,
+    dryRun,
+    installMode: pluginInstallMode,
+    installSource: pluginInstallSource,
+    refresh: false,
+  });
+  const currentConfig = mergePluginMetadata(
+    currentConfigBeforePluginInstall,
+    plugin.pluginConfig,
+  );
+  const lifecycle = await reconcileManagedClaworldRuntime({
+    openclawBin,
+    configPath: resolvedConfigPath,
+    stateDir: resolvedStateDir,
+    currentConfigState,
+    currentConfig,
+    host,
+    serverUrl,
+    apiKey,
+    accountId,
+    agentId,
+    workspace,
+    displayName,
+    toolProfile,
+    approvalMode,
+    sessionDmScope,
+    repoRoot,
+    fetchImpl,
+    commandRunner,
+    cwd,
+    env,
+    dryRun,
+    timeoutMs,
+  });
+
+  return {
+    ok: true,
+    command: CLAWORLD_INSTALLER_COMMAND,
+    configPath: resolvedConfigPath,
+    stateDir: resolvedStateDir,
+    host,
+    plugin,
+    ...lifecycle,
+  };
+}
+
+export async function runClaworldInstallerUpdate({
+  openclawBin = DEFAULT_OPENCLAW_BIN,
+  configPath = DEFAULT_OPENCLAW_CONFIG_PATH,
+  stateDir = DEFAULT_OPENCLAW_STATE_DIR,
+  serverUrl = null,
+  apiKey = null,
+  accountId = DEFAULT_CLAWORLD_ACCOUNT_ID,
+  agentId = DEFAULT_CLAWORLD_ACCOUNT_ID,
+  workspace = null,
+  displayName = null,
+  toolProfile = null,
+  approvalMode = null,
+  sessionDmScope = null,
+  fetchImpl = globalThis.fetch?.bind(globalThis),
+  commandRunner = defaultCommandRunner,
+  cwd = process.cwd(),
+  env = process.env,
+  dryRun = false,
+  timeoutMs = DEFAULT_INSTALL_TIMEOUT_MS,
+} = {}) {
+  const resolvedConfigPath = path.resolve(expandUserPath(configPath, os.homedir()));
+  const resolvedStateDir = stateDir ? path.resolve(expandUserPath(stateDir, os.homedir())) : null;
+  const commandEnv = buildOpenclawCommandEnv({
+    configPath: resolvedConfigPath,
+    stateDir: resolvedStateDir,
+    env,
+  });
+  const currentConfigState = await loadConfigFromDisk(resolvedConfigPath);
+  const host = await detectOpenclawHost({
+    openclawBin,
+    commandRunner,
+    cwd,
+    env: commandEnv,
+    dryRun,
+  });
+  if (compareVersionParts(host.version, CLAWORLD_OPENCLAW_MIN_HOST_VERSION) < 0) {
+    throw createInstallerError(
+      'openclaw_version_too_old',
+      `OpenClaw ${host.version} is below the required minimum ${CLAWORLD_OPENCLAW_MIN_HOST_VERSION}.`,
+      { hostVersion: host.version, minHostVersion: CLAWORLD_OPENCLAW_MIN_HOST_VERSION },
+    );
+  }
+
+  const plugin = await updateTrackedClaworldPluginInstall({
+    openclawBin,
+    configPath: resolvedConfigPath,
+    stateDir: resolvedStateDir,
+    config: currentConfigState.config,
+    commandRunner,
+    cwd,
+    env,
+    dryRun,
+  });
+
+  const refreshedConfigState = await loadConfigFromDisk(resolvedConfigPath);
+  const currentConfig = mergePluginMetadata(refreshedConfigState.config, null);
+  const lifecycle = await reconcileManagedClaworldRuntime({
+    openclawBin,
+    configPath: resolvedConfigPath,
+    stateDir: resolvedStateDir,
+    currentConfigState: refreshedConfigState,
+    currentConfig,
+    host,
+    serverUrl,
+    apiKey,
+    accountId,
+    agentId,
+    workspace,
+    displayName,
+    toolProfile,
+    approvalMode,
+    sessionDmScope,
+    fetchImpl,
+    commandRunner,
+    cwd,
+    env,
+    dryRun,
+    timeoutMs,
+  });
+
+  return {
+    ok: true,
+    command: CLAWORLD_UPDATE_COMMAND,
+    configPath: resolvedConfigPath,
+    stateDir: resolvedStateDir,
+    host,
+    plugin,
+    ...lifecycle,
+  };
+}
+
+export {
+  compareVersionParts,
+  defaultCommandRunner,
+  findAgentEntry,
+  parseCommandVersion,
+  readClaworldAccountStatus,
+};