@agent-webui/ai-desk-daemon 1.0.30 → 1.0.32

package/README.md

@@ -8,7 +8,7 @@
 
 ## ✨ 特性
 
-- 🎯 **自动启动** - Web 访问时自动检测并启动守护进程
+- 🎯 **智能启动** - Web 访问时自动检测并尝试启动守护进程
 - 🖥️ **图形化管理** - 系统托盘 + 控制面板，便捷管理
 - 🔄 **实时监控** - 查看守护进程状态、日志和统计信息
 - 🚀 **智能启动器** - 多种方式自动唤醒守护进程
@@ -24,11 +24,17 @@
 
 ```bash
 # 全局安装
-npm install -g agent-webui/ai-desk-daemon
+npm install -g @agent-webui/ai-desk
 
-# 启动 daemon
+# 启动 daemon（默认使用已保存模式）
 aidesk start
 
+# 切到 Native mode
+aidesk start --mode native
+
+# 切到 Bundled CLI-Anything runtime mode
+aidesk start --mode cli-anything
+
 # 查看状态
 aidesk status
 ```
@@ -36,6 +42,9 @@ aidesk status
 **包含内容**：
 - ✅ AI Desk Daemon 后台服务
 - ✅ CLI 命令行管理工具
+- ✅ 默认 harness 运行时与安装脚本
+- ✅ bundled CLI-Anything runtime（随包安装到 AI Desk runtime）
+- ✅ 按平台分发的内置 Python runtime
 - ✅ HTTP API (http://localhost:9527)
 
 **不包含**：
@@ -43,14 +52,21 @@ aidesk status
 - ❌ 桌面 GUI 应用
 
 **可用命令**：
-- `aidesk start` - 启动守护进程（后台运行）
+- `aidesk start` - 启动守护进程（后台运行，沿用当前已保存 mode）
+- `aidesk start --mode native` - 切到 Native mode 并启动
+- `aidesk start --mode cli-anything` - 切到 Bundled CLI-Anything runtime mode 并启动
 - `aidesk start --log` - 启动守护进程（前台运行，跟随日志）
 - `aidesk stop` - 停止守护进程
 - `aidesk restart` - 重启守护进程
+- `aidesk restart --mode cli-anything` - 切到 Bundled CLI-Anything runtime mode 并重启
 - `aidesk status` - 查看状态
 - `aidesk logs` - 查看日志
 - `aidesk logs -f` - 实时查看日志（不会停止守护进程）
 
+**Mode 说明**：
+- `Native mode`：检测、模型查询、命令执行走 daemon 原生实现。
+- `Bundled CLI-Anything runtime mode`：使用 npm 安装时随包准备好的 Python runtime 和 `cli_anything` 入口；如果某个功能当前 runtime 不支持，daemon 会按配置回退到 native。
+
 📖 详细使用说明：[NPM_CLI.md](NPM_CLI.md)
 
 ---
@@ -69,6 +85,8 @@ curl -fsSL https://github.com/your-repo/ai-desk-desktop/releases/latest/download
 ./scripts/install-macos.sh
 ```
 
+安装脚本会为当前会话尝试启动 daemon，但不会再通过 LaunchAgent/Plist 保活。
+
 #### Linux
 
 ```bash

package/bin/cli.js

@@ -7,12 +7,67 @@
 const { program } = require('commander');
 const chalk = require('chalk');
 const fs = require('fs');
+const path = require('path');
 const { start, stop, restart, status } = require('../lib/daemon-manager');
 const { getLogPath } = require('../lib/platform');
 const { VERSION } = require('../lib/platform');
 
+function resolveRequestedMode(options) {
+  const hasExplicitMode = typeof options.mode === 'string' && options.mode.trim() !== '';
+
+  if (options.cliAnything && options.native) {
+    throw new Error('Use either --cli-anything or --native, not both');
+  }
+
+  if (hasExplicitMode && (options.cliAnything || options.native)) {
+    throw new Error('Use either --mode or the mode shortcut flags, not both');
+  }
+
+  if (options.cliAnything) {
+    return 'cli-anything';
+  }
+
+  if (options.native) {
+    return 'native';
+  }
+
+  if (!hasExplicitMode) {
+    return '';
+  }
+
+  const normalizedMode = options.mode.trim().toLowerCase();
+  if (normalizedMode !== 'native' && normalizedMode !== 'cli-anything') {
+    throw new Error(`Unsupported mode: ${options.mode}. Use "native" or "cli-anything".`);
+  }
+
+  return normalizedMode;
+}
+
+function configureRequestedMode(mode) {
+  const packageRoot = path.join(__dirname, '..');
+  const { loadConfig } = require('../lib/config');
+  const { syncCLIAnythingConfig } = require('../lib/cli-anything-manager');
+
+  if (!mode) {
+    const config = loadConfig();
+    if (config.cli_anything?.enabled) {
+      return syncCLIAnythingConfig(packageRoot, { enabled: true });
+    }
+    return null;
+  }
+
+  if (mode === 'cli-anything') {
+    return syncCLIAnythingConfig(packageRoot, { enabled: true });
+  }
+
+  return syncCLIAnythingConfig(packageRoot, {
+    enabled: false,
+    ensureInstalled: false,
+  });
+}
+
 program
-  .name('ai-desk-daemon')
+  .name('aidesk')
   .description('AI Desk Daemon - CLI tool for managing the AI Desk daemon service')
   .version(VERSION);
 
@@ -20,11 +75,20 @@ program
 program
   .command('start')
   .description('Start the daemon')
+  .option('-m, --mode <mode>', 'Implementation mode: native or cli-anything')
+  .option('--cli-anything', 'Enable CLI-Anything mode before starting')
+  .option('--native', 'Force native mode before starting')
   .option('--log', 'Follow daemon logs in foreground (Ctrl+C to stop daemon)')
   .action(async (options) => {
     try {
-      const { getPidPath } = require('../lib/platform');
-      const daemonPid = start();
+      const mode = resolveRequestedMode(options) || 'native';
+      const modeResult = configureRequestedMode(mode);
+      start();
+      if (mode === 'cli-anything' && modeResult?.runtimeInfo?.cliAnythingPath) {
+        console.log(chalk.cyan(`CLI-Anything mode configured: ${modeResult.runtimeInfo.cliAnythingPath}`));
+      } else if (mode === 'native') {
+        console.log(chalk.cyan('Native mode configured'));
+      }
       console.log(chalk.green('✓ Daemon started successfully'));
 
       // Only follow logs if --log is specified
@@ -138,9 +202,19 @@ program
 program
   .command('restart')
   .description('Restart the daemon')
-  .action(async () => {
+  .option('-m, --mode <mode>', 'Implementation mode: native or cli-anything')
+  .option('--cli-anything', 'Enable CLI-Anything mode before restarting')
+  .option('--native', 'Force native mode before restarting')
+  .action(async (options) => {
     try {
+      const mode = resolveRequestedMode(options);
+      const modeResult = configureRequestedMode(mode);
       restart();
+      if (mode === 'cli-anything' && modeResult?.runtimeInfo?.cliAnythingPath) {
+        console.log(chalk.cyan(`CLI-Anything mode configured: ${modeResult.runtimeInfo.cliAnythingPath}`));
+      } else if (mode === 'native') {
+        console.log(chalk.cyan('Native mode configured'));
+      }
       console.log(chalk.green('✓ Daemon restarted successfully'));
     } catch (error) {
       console.error(chalk.red('✗ Failed to restart daemon:'), error.message);
@@ -228,4 +302,3 @@ program.parse(process.argv);
 if (!process.argv.slice(2).length) {
   program.outputHelp();
 }
-

package/lib/cli-anything-manager.js

@@ -0,0 +1,218 @@
+const fs = require('fs');
+const path = require('path');
+const { ensureRuntime, readJSON, run, writeJSON } = require('./runtime-manager');
+const { getConfigPath } = require('./platform');
+
+const CLI_ANYTHING_MODULE = 'cli_anything';
+
+function resolveCommandPath(binDir, command) {
+  const candidates = process.platform === 'win32'
+    ? [
+        path.join(binDir, `${command}.exe`),
+        path.join(binDir, `${command}.cmd`),
+        path.join(binDir, `${command}.bat`),
+        path.join(binDir, command),
+      ]
+    : [path.join(binDir, command)];
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  return candidates[0];
+}
+
+function resolveCLIAnythingRuntimeSource(packageRoot = '') {
+  const candidates = [];
+
+  if (process.env.AI_DESK_CLI_ANYTHING_RUNTIME_SOURCE) {
+    candidates.push(process.env.AI_DESK_CLI_ANYTHING_RUNTIME_SOURCE);
+  }
+
+  if (packageRoot) {
+    candidates.push(path.join(packageRoot, 'python-runtime'));
+  }
+
+  candidates.push(path.join(__dirname, '..', 'python-runtime'));
+
+  for (const candidate of candidates) {
+    if (!candidate) {
+      continue;
+    }
+
+    const setupPyPath = path.join(candidate, 'setup.py');
+    if (fs.existsSync(setupPyPath)) {
+      return candidate;
+    }
+  }
+
+  return '';
+}
+
+function cliAnythingRuntimeLooksHealthy(runtimeInfo, pythonModule = CLI_ANYTHING_MODULE) {
+  let importable = false;
+
+  try {
+    const importResult = run(runtimeInfo.pythonPath, ['-c', `import ${pythonModule}`]);
+    importable = importResult.status === 0;
+  } catch (error) {
+    importable = false;
+  }
+
+  const cliAnythingPath = resolveCommandPath(runtimeInfo.binDir, 'cli-anything');
+
+  return {
+    importable,
+    cliAnythingPath,
+    healthy: importable && fs.existsSync(cliAnythingPath),
+  };
+}
+
+function installCLIAnythingRuntime(runtimeInfo, packageRoot = '', options = {}) {
+  const pythonModule = options.pythonModule || CLI_ANYTHING_MODULE;
+  const runtimeSource = resolveCLIAnythingRuntimeSource(packageRoot);
+
+  if (!runtimeSource) {
+    throw new Error('CLI-Anything runtime source not found in the installed AI Desk package');
+  }
+
+  const args = ['-m', 'pip', 'install', '--upgrade'];
+  if (options.forceReinstall) {
+    args.push('--force-reinstall');
+  }
+  args.push(runtimeSource);
+
+  const installResult = run(runtimeInfo.pythonPath, args);
+  if (installResult.status !== 0) {
+    throw new Error(
+      installResult.stderr ||
+        installResult.stdout ||
+        `Failed to install CLI-Anything runtime from ${runtimeSource}`
+    );
+  }
+
+  const health = cliAnythingRuntimeLooksHealthy(runtimeInfo, pythonModule);
+  if (!health.importable) {
+    throw new Error(`CLI-Anything Python module "${pythonModule}" is not importable after installation`);
+  }
+
+  if (!fs.existsSync(health.cliAnythingPath)) {
+    throw new Error(`CLI-Anything executable not found after installation: ${health.cliAnythingPath}`);
+  }
+
+  return {
+    ...runtimeInfo,
+    cliAnythingPath: health.cliAnythingPath,
+    pythonModule,
+    runtimeSource,
+  };
+}
+
+function ensureCLIAnythingRuntime(packageRoot = '', options = {}) {
+  const pythonModule = options.pythonModule || CLI_ANYTHING_MODULE;
+  const runtimeInfo = ensureRuntime();
+  const health = cliAnythingRuntimeLooksHealthy(runtimeInfo, pythonModule);
+
+  if (health.healthy && !options.forceReinstall) {
+    return {
+      ...runtimeInfo,
+      cliAnythingPath: health.cliAnythingPath,
+      pythonModule,
+      runtimeSource: resolveCLIAnythingRuntimeSource(packageRoot),
+    };
+  }
+
+  return installCLIAnythingRuntime(runtimeInfo, packageRoot, options);
+}
+
+function syncCLIAnythingConfig(packageRoot = '', options = {}) {
+  const configPath = options.configPath || getConfigPath();
+  const config = readJSON(configPath);
+  const cliAnything = config.cli_anything || {};
+  const runtime = cliAnything.runtime || {};
+  const features = cliAnything.features || {};
+
+  let runtimeInfo = null;
+  if (options.ensureInstalled !== false) {
+    runtimeInfo = ensureCLIAnythingRuntime(packageRoot, options);
+  }
+
+  if (typeof options.enabled === 'boolean') {
+    cliAnything.enabled = options.enabled;
+  } else if (typeof cliAnything.enabled !== 'boolean') {
+    cliAnything.enabled = false;
+  }
+
+  if (typeof options.fallbackToNative === 'boolean') {
+    cliAnything.fallback_to_native = options.fallbackToNative;
+  } else if (typeof cliAnything.fallback_to_native !== 'boolean') {
+    cliAnything.fallback_to_native = true;
+  }
+
+  if (runtimeInfo) {
+    cliAnything.cli_anything_path = runtimeInfo.cliAnythingPath;
+    runtime.python_path = runtimeInfo.pythonPath;
+    runtime.python_module = runtimeInfo.pythonModule;
+  } else {
+    cliAnything.cli_anything_path = cliAnything.cli_anything_path || '';
+    runtime.python_path = runtime.python_path || '';
+    runtime.python_module = runtime.python_module || CLI_ANYTHING_MODULE;
+  }
+
+  if (typeof options.timeout === 'number') {
+    cliAnything.timeout = options.timeout;
+  } else if (typeof cliAnything.timeout !== 'number') {
+    cliAnything.timeout = 30;
+  }
+
+  if (typeof options.maxRetries === 'number') {
+    cliAnything.max_retries = options.maxRetries;
+  } else if (typeof cliAnything.max_retries !== 'number') {
+    cliAnything.max_retries = 3;
+  }
+
+  if (typeof options.generationTimeout === 'number') {
+    runtime.generation_timeout = options.generationTimeout;
+  } else if (typeof runtime.generation_timeout !== 'number') {
+    runtime.generation_timeout = 300;
+  }
+
+  const booleanFeatureDefaults = {
+    ai_cli_detection: true,
+    model_listing: true,
+    command_execution: true,
+    task_generation: true,
+  };
+
+  for (const [featureKey, defaultValue] of Object.entries(booleanFeatureDefaults)) {
+    if (featureKey === 'task_generation' && typeof options.taskGeneration === 'boolean') {
+      features[featureKey] = options.taskGeneration;
+      continue;
+    }
+
+    if (typeof features[featureKey] !== 'boolean') {
+      features[featureKey] = defaultValue;
+    }
+  }
+
+  cliAnything.runtime = runtime;
+  cliAnything.features = features;
+  config.cli_anything = cliAnything;
+  writeJSON(configPath, config);
+
+  return {
+    configPath,
+    config,
+    runtimeInfo,
+  };
+}
+
+module.exports = {
+  CLI_ANYTHING_MODULE,
+  ensureCLIAnythingRuntime,
+  resolveCLIAnythingRuntimeSource,
+  resolveCommandPath,
+  syncCLIAnythingConfig,
+};

package/lib/config.js

@@ -7,6 +7,65 @@ const path = require('path');
 const { getConfigDir, getConfigPath } = require('./platform');
 
 const DEFAULT_PORT = 9527;
+const DEFAULT_CONFIG = {
+  port: DEFAULT_PORT,
+  logLevel: 'info',
+  autoStart: true,
+  cli_anything: {
+    enabled: false,
+    fallback_to_native: true,
+    cli_anything_path: '',
+    timeout: 30,
+    max_retries: 3,
+    features: {
+      ai_cli_detection: true,
+      model_listing: true,
+      command_execution: true,
+      task_generation: true,
+    },
+    runtime: {
+      python_path: '',
+      python_module: 'cli_anything',
+      generation_timeout: 300,
+    },
+  },
+  harness_runtime: {
+    venv_path: '',
+    python_path: '',
+    registry_path: '',
+    source: '',
+    runtime_home: '',
+    package_name: '',
+    package_version: '',
+    archive_sha256: '',
+  },
+  harnesses: {},
+};
+
+function cloneDefaultConfig() {
+  return JSON.parse(JSON.stringify(DEFAULT_CONFIG));
+}
+
+function mergeConfig(base, override) {
+  if (!override || typeof override !== 'object' || Array.isArray(override)) {
+    return base;
+  }
+
+  const merged = Array.isArray(base) ? [...base] : { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+      const nestedBase = merged[key] && typeof merged[key] === 'object' && !Array.isArray(merged[key])
+        ? merged[key]
+        : {};
+      merged[key] = mergeConfig(nestedBase, value);
+      continue;
+    }
+
+    merged[key] = value;
+  }
+
+  return merged;
+}
 
 /**
  * Ensure config directory exists
@@ -33,22 +92,17 @@ function loadConfig() {
   const configPath = getConfigPath();
   
   if (!fs.existsSync(configPath)) {
-    // Create default config
-    const defaultConfig = {
-      port: DEFAULT_PORT,
-      logLevel: 'info',
-      autoStart: true
-    };
+    const defaultConfig = cloneDefaultConfig();
     saveConfig(defaultConfig);
     return defaultConfig;
   }
   
   try {
     const content = fs.readFileSync(configPath, 'utf8');
-    return JSON.parse(content);
+    return mergeConfig(cloneDefaultConfig(), JSON.parse(content));
   } catch (error) {
     console.error('Failed to load config:', error.message);
-    return { port: DEFAULT_PORT };
+    return cloneDefaultConfig();
   }
 }
 
@@ -59,7 +113,8 @@ function saveConfig(config) {
   ensureConfigDir();
   
   const configPath = getConfigPath();
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+  const mergedConfig = mergeConfig(cloneDefaultConfig(), config);
+  fs.writeFileSync(configPath, JSON.stringify(mergedConfig, null, 2), 'utf8');
 }
 
 /**
@@ -97,7 +152,8 @@ module.exports = {
   saveConfig,
   getPort,
   setPort,
+  cloneDefaultConfig,
+  mergeConfig,
   getConfigPath,  // Re-export from platform.js
   DEFAULT_PORT
 };
-

package/lib/daemon-manager.js

@@ -80,7 +80,7 @@ function start() {
     throw new Error(
       `Daemon binary not found at: ${binaryPath}\n` +
       `This might be a corrupted installation. Try reinstalling:\n` +
-      `  npm install -g @ringcentral/ai-desk-daemon --force`
+      `  npm install -g @agent-webui/ai-desk --force`
     );
   }
 
@@ -186,4 +186,3 @@ module.exports = {
   restart,
   status
 };
-

package/lib/harness-manager.js

@@ -0,0 +1,178 @@
+const fs = require('fs');
+const path = require('path');
+const { ensureRuntime, readJSON, run, syncHarnessConfig, writeJSON } = require('./runtime-manager');
+
+function listDependencyNames(packageRoot) {
+  const packageJsonPath = path.join(packageRoot, 'package.json');
+  const packageJson = readJSON(packageJsonPath);
+
+  const allDeps = {
+    ...(packageJson.dependencies || {}),
+    ...(packageJson.optionalDependencies || {}),
+  };
+
+  return Object.keys(allDeps).filter((name) => name.startsWith('@agent-webui/ai-desk-harness-'));
+}
+
+function findWorkspaceSiblingPackage(packageRoot, packageName) {
+  const packagesRoot = path.resolve(packageRoot, '..');
+  if (!fs.existsSync(packagesRoot)) {
+    return null;
+  }
+
+  const children = fs.readdirSync(packagesRoot, { withFileTypes: true });
+  for (const child of children) {
+    if (!child.isDirectory()) {
+      continue;
+    }
+
+    const packageJsonPath = path.join(packagesRoot, child.name, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+      continue;
+    }
+
+    const pkg = readJSON(packageJsonPath);
+    if (pkg.name === packageName) {
+      return path.dirname(packageJsonPath);
+    }
+  }
+
+  return null;
+}
+
+function resolveHarnessPackageDir(packageRoot, packageName) {
+  try {
+    const packageJsonPath = require.resolve(`${packageName}/package.json`, {
+      paths: [packageRoot],
+    });
+    return path.dirname(packageJsonPath);
+  } catch (error) {
+    const workspaceMatch = findWorkspaceSiblingPackage(packageRoot, packageName);
+    if (workspaceMatch) {
+      return workspaceMatch;
+    }
+    throw new Error(`Failed to resolve harness package ${packageName} from ${packageRoot}: ${error.message}`);
+  }
+}
+
+function resolveHarnesses(packageRoot) {
+  const harnessNames = listDependencyNames(packageRoot);
+
+  return harnessNames.map((packageName) => {
+    const packageDir = resolveHarnessPackageDir(packageRoot, packageName);
+    const packageJson = readJSON(path.join(packageDir, 'package.json'));
+    const manifestPath = path.join(packageDir, 'manifest.json');
+    const manifest = readJSON(manifestPath);
+
+    return {
+      packageDir,
+      packageJson,
+      packageName,
+      manifest,
+      manifestPath,
+      sourcePath: path.resolve(packageDir, manifest.source_path),
+    };
+  });
+}
+
+function resolveCommandPath(binDir, command) {
+  const candidates = process.platform === 'win32'
+    ? [
+        path.join(binDir, `${command}.exe`),
+        path.join(binDir, `${command}.cmd`),
+        path.join(binDir, `${command}.bat`),
+        path.join(binDir, command),
+      ]
+    : [path.join(binDir, command)];
+
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  return candidates[0];
+}
+
+function installHarnessPackage(runtimeInfo, harness) {
+  if (!fs.existsSync(harness.sourcePath)) {
+    throw new Error(`Harness source not found: ${harness.sourcePath}`);
+  }
+
+	const installResult = run(runtimeInfo.pythonPath, ['-m', 'pip', 'install', '--upgrade', harness.sourcePath]);
+	if (installResult.status !== 0) {
+    throw new Error(
+      installResult.stderr ||
+        installResult.stdout ||
+        `Failed to install harness ${harness.packageName} from ${harness.sourcePath}`
+    );
+	}
+
+	for (const requirement of harness.manifest.python_requirements || []) {
+		const requirementResult = run(runtimeInfo.pythonPath, ['-m', 'pip', 'install', '--upgrade', requirement]);
+		if (requirementResult.status !== 0) {
+			throw new Error(
+				requirementResult.stderr ||
+					requirementResult.stdout ||
+					`Failed to install Python requirement ${requirement} for ${harness.packageName}`
+			);
+		}
+	}
+
+	return {
+    name: harness.manifest.name,
+    displayName: harness.manifest.display_name || harness.manifest.name,
+    module: harness.manifest.module,
+    commands: harness.manifest.commands || [],
+    capabilities: harness.manifest.capabilities || [],
+    commandPath: resolveCommandPath(runtimeInfo.binDir, (harness.manifest.commands || [])[0] || ''),
+    commandPaths: Object.fromEntries(
+      (harness.manifest.commands || []).map((command) => [command, resolveCommandPath(runtimeInfo.binDir, command)])
+    ),
+    packageName: harness.packageName,
+    packageVersion: harness.packageJson.version || '',
+    version: harness.manifest.version || harness.packageJson.version || '',
+    sourcePath: harness.sourcePath,
+  };
+}
+
+function writeHarnessRegistry(runtimeInfo, harnesses) {
+  const registry = {
+    version: 1,
+    generated_at: new Date().toISOString(),
+    runtime: {
+      python_path: runtimeInfo.pythonPath,
+      venv_path: runtimeInfo.venvDir,
+      registry_path: runtimeInfo.registryPath,
+      source: runtimeInfo.source || '',
+      runtime_home: runtimeInfo.runtimeHomeDir || '',
+      package_name: runtimeInfo.packageName || '',
+      package_version: runtimeInfo.packageVersion || '',
+      archive_sha256: runtimeInfo.archiveSHA256 || '',
+    },
+    harnesses,
+  };
+
+  writeJSON(runtimeInfo.registryPath, registry);
+  syncHarnessConfig(runtimeInfo, harnesses);
+  return registry;
+}
+
+function installHarnessesForPackageRoot(packageRoot) {
+  const runtimeInfo = ensureRuntime();
+  const harnessPackages = resolveHarnesses(packageRoot);
+  const installedHarnesses = harnessPackages.map((harness) => installHarnessPackage(runtimeInfo, harness));
+  const registry = writeHarnessRegistry(runtimeInfo, installedHarnesses);
+
+  return {
+    harnessCount: installedHarnesses.length,
+    harnesses: installedHarnesses,
+    registry,
+    runtimeInfo,
+  };
+}
+
+module.exports = {
+  installHarnessesForPackageRoot,
+  resolveHarnesses,
+};