@agent-webui/ai-desk-daemon 1.0.24 → 1.0.29-beta1

package/README.md

@@ -24,7 +24,7 @@
 
 ```bash
 # 全局安装
-npm install -g agent-webui/ai-desk-daemon
+npm install -g @agent-webui/ai-desk
 
 # 启动 daemon
 aidesk start
@@ -36,6 +36,8 @@ aidesk status
 **包含内容**：
 - ✅ AI Desk Daemon 后台服务
 - ✅ CLI 命令行管理工具
+- ✅ 默认 harness 运行时与安装脚本
+- ✅ 按平台分发的内置 Python runtime
 - ✅ HTTP API (http://localhost:9527)
 
 **不包含**：

package/bin/cli.js

@@ -12,7 +12,7 @@ const { getLogPath } = require('../lib/platform');
 const { VERSION } = require('../lib/platform');
 
 program
-  .name('ai-desk-daemon')
+  .name('aidesk')
   .description('AI Desk Daemon - CLI tool for managing the AI Desk daemon service')
   .version(VERSION);
 
@@ -228,4 +228,3 @@ program.parse(process.argv);
 if (!process.argv.slice(2).length) {
   program.outputHelp();
 }
-

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,
+};

package/lib/platform.js

@@ -4,8 +4,10 @@
 
 const os = require('os');
 const path = require('path');
+const fs = require('fs');
+const { getBinaryPackageByPlatformKey, resolveInstalledPackageDir } = require('./workspace-packages');
 
-const VERSION = '1.0.24';
+const VERSION = require('../package.json').version;
 
 /**
  * Detect current platform and architecture
@@ -39,9 +41,19 @@ function detectPlatform() {
  */
 function getDaemonBinaryPath() {
   const { platform, platformKey } = detectPlatform();
+  const binaryPackage = getBinaryPackageByPlatformKey(platformKey);
 
-  // Binary is in the npm package under dist/<platform>/
   const binaryName = platform === 'win32' ? 'ai-desk-daemon.exe' : 'ai-desk-daemon';
+  if (binaryPackage) {
+    const packageDir = resolveInstalledPackageDir(binaryPackage.packageName);
+    if (packageDir) {
+      const packageBinaryPath = path.join(packageDir, 'bin', binaryName);
+      if (fs.existsSync(packageBinaryPath)) {
+        return packageBinaryPath;
+      }
+    }
+  }
+
   const binaryPath = path.join(__dirname, '..', 'dist', platformKey, binaryName);
 
   return binaryPath;
@@ -54,6 +66,54 @@ function getConfigDir() {
   return path.join(os.homedir(), '.aidesktop');
 }
 
+function getRuntimeDir() {
+  return path.join(getConfigDir(), 'runtime');
+}
+
+function getManagedPythonDir() {
+  return path.join(getRuntimeDir(), 'python');
+}
+
+function getManagedPythonBinDir() {
+  if (process.platform === 'win32') {
+    return getManagedPythonDir();
+  }
+  return path.join(getManagedPythonDir(), 'bin');
+}
+
+function getManagedPythonPath() {
+  if (process.platform === 'win32') {
+    return path.join(getManagedPythonDir(), 'python.exe');
+  }
+  return path.join(getManagedPythonBinDir(), 'python3');
+}
+
+function getManagedPythonMetadataPath() {
+  return path.join(getManagedPythonDir(), '.ai-desk-runtime.json');
+}
+
+function getRuntimeVenvDir() {
+  return path.join(getRuntimeDir(), 'venv');
+}
+
+function getRuntimeBinDir() {
+  if (process.platform === 'win32') {
+    return path.join(getRuntimeVenvDir(), 'Scripts');
+  }
+  return path.join(getRuntimeVenvDir(), 'bin');
+}
+
+function getRuntimePythonPath() {
+  if (process.platform === 'win32') {
+    return path.join(getRuntimeBinDir(), 'python.exe');
+  }
+  return path.join(getRuntimeBinDir(), 'python3');
+}
+
+function getHarnessRegistryPath() {
+  return path.join(getRuntimeDir(), 'installed-harnesses.json');
+}
+
 /**
  * Get config file path
  */
@@ -79,9 +139,17 @@ module.exports = {
   detectPlatform,
   getDaemonBinaryPath,
   getConfigDir,
+  getRuntimeDir,
+  getManagedPythonDir,
+  getManagedPythonBinDir,
+  getManagedPythonPath,
+  getManagedPythonMetadataPath,
+  getRuntimeVenvDir,
+  getRuntimeBinDir,
+  getRuntimePythonPath,
+  getHarnessRegistryPath,
   getConfigPath,
   getLogPath,
   getPidPath,
   VERSION
 };
-

package/lib/runtime-manager.js

@@ -0,0 +1,320 @@
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const {
+  getConfigDir,
+  getConfigPath,
+  getHarnessRegistryPath,
+  getManagedPythonBinDir,
+  getManagedPythonDir,
+  getManagedPythonMetadataPath,
+  getManagedPythonPath,
+  getRuntimeBinDir,
+  getRuntimeDir,
+  getRuntimePythonPath,
+  getRuntimeVenvDir,
+  detectPlatform,
+} = require('./platform');
+const {
+  getPythonRuntimePackageByPlatformKey,
+  resolveInstalledPackageDir,
+} = require('./workspace-packages');
+
+function readJSON(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return {};
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch (error) {
+    throw new Error(`Failed to parse JSON at ${filePath}: ${error.message}`);
+  }
+}
+
+function writeJSON(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(value, null, 2) + '\n', 'utf8');
+}
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    encoding: 'utf8',
+    stdio: 'pipe',
+    ...options,
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  return result;
+}
+
+function findSystemPython() {
+  const candidates = [];
+
+  if (process.env.AI_DESK_PYTHON) {
+    candidates.push({ command: process.env.AI_DESK_PYTHON, args: [] });
+  }
+
+  candidates.push({ command: 'python3', args: [] });
+  candidates.push({ command: 'python', args: [] });
+
+  if (process.platform === 'win32') {
+    candidates.push({ command: 'py', args: ['-3'] });
+  }
+
+  for (const candidate of candidates) {
+    try {
+      const result = run(candidate.command, [...candidate.args, '--version']);
+      if (result.status === 0) {
+        return candidate;
+      }
+    } catch (error) {
+      // Try next candidate.
+    }
+  }
+
+  throw new Error('No usable Python interpreter found. Set AI_DESK_PYTHON to override.');
+}
+
+function ensureRuntimeDirectories() {
+  fs.mkdirSync(getConfigDir(), { recursive: true });
+  fs.mkdirSync(path.join(getConfigDir(), 'logs'), { recursive: true });
+  fs.mkdirSync(getRuntimeDir(), { recursive: true });
+}
+
+function getBundledPythonRuntime() {
+  const { platformKey } = detectPlatform();
+  const runtimePackage = getPythonRuntimePackageByPlatformKey(platformKey);
+  if (!runtimePackage) {
+    return null;
+  }
+
+  const packageDir = resolveInstalledPackageDir(runtimePackage.packageName, [path.join(__dirname, '..')]);
+  if (!packageDir) {
+    return null;
+  }
+
+  const packageJson = readJSON(path.join(packageDir, 'package.json'));
+  const sourceRuntimeDir = path.join(packageDir, 'python');
+  const sourcePythonPath = path.join(packageDir, runtimePackage.pythonRelativePath);
+  const sourceBinDir = path.join(packageDir, runtimePackage.binDirRelativePath);
+
+  if (!fs.existsSync(sourceRuntimeDir) || !fs.existsSync(sourcePythonPath)) {
+    return null;
+  }
+
+  return {
+    packageDir,
+    packageName: runtimePackage.packageName,
+    packageVersion: packageJson.version || '',
+    archiveName: runtimePackage.archiveName,
+    archiveSHA256: runtimePackage.sha256 || '',
+    sourceRuntimeDir,
+    sourcePythonPath,
+    sourceBinDir,
+  };
+}
+
+function copyDirectoryRecursive(sourceDir, targetDir) {
+  fs.mkdirSync(targetDir, { recursive: true });
+
+  for (const entry of fs.readdirSync(sourceDir, { withFileTypes: true })) {
+    const sourcePath = path.join(sourceDir, entry.name);
+    const targetPath = path.join(targetDir, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDirectoryRecursive(sourcePath, targetPath);
+      continue;
+    }
+
+    if (entry.isSymbolicLink()) {
+      const linkTarget = fs.readlinkSync(sourcePath);
+      try {
+        fs.unlinkSync(targetPath);
+      } catch (error) {
+        if (error.code !== 'ENOENT') {
+          throw error;
+        }
+      }
+      fs.symlinkSync(linkTarget, targetPath);
+      continue;
+    }
+
+    fs.copyFileSync(sourcePath, targetPath);
+    try {
+      fs.chmodSync(targetPath, fs.statSync(sourcePath).mode);
+    } catch (error) {
+      // Ignore chmod failures on platforms that do not preserve permissions.
+    }
+  }
+}
+
+function packagedRuntimeLooksHealthy(pythonPath) {
+  if (!fs.existsSync(pythonPath)) {
+    return false;
+  }
+
+  try {
+    const result = run(pythonPath, ['-c', 'import sys; print(sys.executable)']);
+    return result.status === 0;
+  } catch (error) {
+    return false;
+  }
+}
+
+function ensurePackagedRuntime(bundledRuntime) {
+  const targetRuntimeDir = getManagedPythonDir();
+  const metadataPath = getManagedPythonMetadataPath();
+  const expectedMetadata = {
+    package_name: bundledRuntime.packageName,
+    package_version: bundledRuntime.packageVersion,
+  };
+
+  const existingMetadata = readJSON(metadataPath);
+  const targetPythonPath = getManagedPythonPath();
+  const targetBinDir = getManagedPythonBinDir();
+
+  const metadataMatches =
+    existingMetadata.package_name === expectedMetadata.package_name &&
+    existingMetadata.package_version === expectedMetadata.package_version;
+
+  if (!metadataMatches || !packagedRuntimeLooksHealthy(targetPythonPath)) {
+    fs.rmSync(targetRuntimeDir, { recursive: true, force: true });
+    copyDirectoryRecursive(bundledRuntime.sourceRuntimeDir, targetRuntimeDir);
+    writeJSON(metadataPath, expectedMetadata);
+  }
+
+  return {
+    pythonPath: targetPythonPath,
+    binDir: targetBinDir,
+    runtimeHomeDir: targetRuntimeDir,
+    packageName: bundledRuntime.packageName,
+    packageVersion: bundledRuntime.packageVersion,
+    archiveSHA256: bundledRuntime.archiveSHA256,
+    source: 'packaged',
+  };
+}
+
+function resolveRuntimePythonPath() {
+  const pythonPath = getRuntimePythonPath();
+  if (fs.existsSync(pythonPath)) {
+    return pythonPath;
+  }
+
+  const fallback = process.platform === 'win32'
+    ? path.join(getRuntimeBinDir(), 'python.exe')
+    : path.join(getRuntimeBinDir(), 'python');
+
+  return fallback;
+}
+
+function venvLooksHealthy(pythonPath) {
+  if (!fs.existsSync(pythonPath)) {
+    return false;
+  }
+
+  try {
+    const result = run(pythonPath, ['-c', 'import sys; print(sys.executable)']);
+    return result.status === 0;
+  } catch (error) {
+    return false;
+  }
+}
+
+function ensureRuntime() {
+  ensureRuntimeDirectories();
+
+  const bundledRuntime = getBundledPythonRuntime();
+  if (bundledRuntime) {
+    const packagedRuntime = ensurePackagedRuntime(bundledRuntime);
+    const pipBootstrap = run(packagedRuntime.pythonPath, ['-m', 'pip', 'install', '--upgrade', 'pip', 'setuptools', 'wheel']);
+    if (pipBootstrap.status !== 0) {
+      throw new Error(pipBootstrap.stderr || pipBootstrap.stdout || 'Failed to bootstrap packaged Python runtime');
+    }
+
+    return {
+      configPath: getConfigPath(),
+      pythonPath: packagedRuntime.pythonPath,
+      registryPath: getHarnessRegistryPath(),
+      runtimeDir: getRuntimeDir(),
+      runtimeHomeDir: packagedRuntime.runtimeHomeDir,
+      venvDir: '',
+      binDir: packagedRuntime.binDir,
+      packageName: packagedRuntime.packageName,
+      packageVersion: packagedRuntime.packageVersion,
+      archiveSHA256: packagedRuntime.archiveSHA256,
+      source: packagedRuntime.source,
+    };
+  }
+
+  const venvDir = getRuntimeVenvDir();
+  let pythonPath = resolveRuntimePythonPath();
+
+  if (!venvLooksHealthy(pythonPath)) {
+    const basePython = findSystemPython();
+    const createResult = run(basePython.command, [...basePython.args, '-m', 'venv', venvDir]);
+    if (createResult.status !== 0) {
+      throw new Error(createResult.stderr || createResult.stdout || 'Failed to create Python virtual environment');
+    }
+    pythonPath = resolveRuntimePythonPath();
+  }
+
+  const pipBootstrap = run(pythonPath, ['-m', 'pip', 'install', '--upgrade', 'pip', 'setuptools', 'wheel']);
+  if (pipBootstrap.status !== 0) {
+    throw new Error(pipBootstrap.stderr || pipBootstrap.stdout || 'Failed to bootstrap pip tooling');
+  }
+
+  return {
+    configPath: getConfigPath(),
+    pythonPath,
+    registryPath: getHarnessRegistryPath(),
+    runtimeDir: getRuntimeDir(),
+    runtimeHomeDir: venvDir,
+    venvDir,
+    binDir: getRuntimeBinDir(),
+    packageName: '',
+    packageVersion: '',
+    archiveSHA256: '',
+    source: 'system-venv',
+  };
+}
+
+function syncHarnessConfig(runtimeInfo, harnesses = []) {
+  const configPath = runtimeInfo.configPath || getConfigPath();
+  const config = readJSON(configPath);
+
+  config.harness_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 || '',
+  };
+
+  config.harnesses = {};
+  for (const harness of harnesses) {
+    config.harnesses[harness.name] = {
+      command: harness.commandPath || '',
+      module: harness.module,
+      package: harness.packageName,
+      version: harness.version,
+    };
+  }
+
+  writeJSON(configPath, config);
+}
+
+module.exports = {
+  ensureRuntime,
+  getBundledPythonRuntime,
+  readJSON,
+  run,
+  syncHarnessConfig,
+  writeJSON,
+};

package/lib/workspace-packages.js

@@ -0,0 +1,172 @@
+const DAEMON_BINARY_PACKAGES = [
+  {
+    dirName: 'ai-desk-daemon-darwin-arm64',
+    packageName: '@agent-webui/ai-desk-daemon-darwin-arm64',
+    platformKey: 'darwin-arm64',
+    os: ['darwin'],
+    cpu: ['arm64'],
+    binaryName: 'ai-desk-daemon',
+  },
+  {
+    dirName: 'ai-desk-daemon-darwin-x64',
+    packageName: '@agent-webui/ai-desk-daemon-darwin-x64',
+    platformKey: 'darwin-x64',
+    os: ['darwin'],
+    cpu: ['x64'],
+    binaryName: 'ai-desk-daemon',
+  },
+  {
+    dirName: 'ai-desk-daemon-linux-arm64',
+    packageName: '@agent-webui/ai-desk-daemon-linux-arm64',
+    platformKey: 'linux-arm64',
+    os: ['linux'],
+    cpu: ['arm64'],
+    binaryName: 'ai-desk-daemon',
+  },
+  {
+    dirName: 'ai-desk-daemon-linux-x64',
+    packageName: '@agent-webui/ai-desk-daemon-linux-x64',
+    platformKey: 'linux-x64',
+    os: ['linux'],
+    cpu: ['x64'],
+    binaryName: 'ai-desk-daemon',
+  },
+  {
+    dirName: 'ai-desk-daemon-win32-x64',
+    packageName: '@agent-webui/ai-desk-daemon-win32-x64',
+    platformKey: 'win32-x64',
+    os: ['win32'],
+    cpu: ['x64'],
+    binaryName: 'ai-desk-daemon.exe',
+  },
+];
+
+const PYTHON_RUNTIME_RELEASE = '20260310';
+const PYTHON_RUNTIME_VERSION = '3.13.12';
+
+const PYTHON_RUNTIME_PACKAGES = [
+  {
+    dirName: 'ai-desk-python-darwin-arm64',
+    packageName: '@agent-webui/ai-desk-python-darwin-arm64',
+    platformKey: 'darwin-arm64',
+    os: ['darwin'],
+    cpu: ['arm64'],
+    archiveName: `cpython-${PYTHON_RUNTIME_VERSION}+${PYTHON_RUNTIME_RELEASE}-aarch64-apple-darwin-install_only.tar.gz`,
+    sha256: '8b49181b776a9ebc8323a645dc55126b389d62c50a0b9f072e37811a9391244d',
+    pythonRelativePath: 'python/bin/python3',
+    binDirRelativePath: 'python/bin',
+  },
+  {
+    dirName: 'ai-desk-python-darwin-x64',
+    packageName: '@agent-webui/ai-desk-python-darwin-x64',
+    platformKey: 'darwin-x64',
+    os: ['darwin'],
+    cpu: ['x64'],
+    archiveName: `cpython-${PYTHON_RUNTIME_VERSION}+${PYTHON_RUNTIME_RELEASE}-x86_64-apple-darwin-install_only.tar.gz`,
+    sha256: 'd778d46b49c640a54a13dc2bd356561b4d4f85466a2d21bc0ab1483a209bb05c',
+    pythonRelativePath: 'python/bin/python3',
+    binDirRelativePath: 'python/bin',
+  },
+  {
+    dirName: 'ai-desk-python-linux-arm64',
+    packageName: '@agent-webui/ai-desk-python-linux-arm64',
+    platformKey: 'linux-arm64',
+    os: ['linux'],
+    cpu: ['arm64'],
+    archiveName: `cpython-${PYTHON_RUNTIME_VERSION}+${PYTHON_RUNTIME_RELEASE}-aarch64-unknown-linux-gnu-install_only.tar.gz`,
+    sha256: '563bf262875fc0c6a22dbbb35ab7df3082184f5a587c16c534b8712e4e05c7c2',
+    pythonRelativePath: 'python/bin/python3',
+    binDirRelativePath: 'python/bin',
+  },
+  {
+    dirName: 'ai-desk-python-linux-x64',
+    packageName: '@agent-webui/ai-desk-python-linux-x64',
+    platformKey: 'linux-x64',
+    os: ['linux'],
+    cpu: ['x64'],
+    archiveName: `cpython-${PYTHON_RUNTIME_VERSION}+${PYTHON_RUNTIME_RELEASE}-x86_64-unknown-linux-gnu-install_only.tar.gz`,
+    sha256: 'a1d58266fede23e795b1b7d1dee3cc77470538fd14292a46cc96e735af030fec',
+    pythonRelativePath: 'python/bin/python3',
+    binDirRelativePath: 'python/bin',
+  },
+  {
+    dirName: 'ai-desk-python-win32-x64',
+    packageName: '@agent-webui/ai-desk-python-win32-x64',
+    platformKey: 'win32-x64',
+    os: ['win32'],
+    cpu: ['x64'],
+    archiveName: `cpython-${PYTHON_RUNTIME_VERSION}+${PYTHON_RUNTIME_RELEASE}-x86_64-pc-windows-msvc-install_only.tar.gz`,
+    sha256: '6204052c096536f9fa926f8312a1dcd5ac0846dc182a0c05ee0011d580546af0',
+    pythonRelativePath: 'python/python.exe',
+    binDirRelativePath: 'python',
+  },
+];
+
+const DEFAULT_HARNESS_PACKAGES = ['@agent-webui/ai-desk-harness-gimp'];
+
+function getBinaryPackageByPlatformKey(platformKey) {
+  return DAEMON_BINARY_PACKAGES.find((pkg) => pkg.platformKey === platformKey) || null;
+}
+
+function getPythonRuntimePackageByPlatformKey(platformKey) {
+  return PYTHON_RUNTIME_PACKAGES.find((pkg) => pkg.platformKey === platformKey) || null;
+}
+
+function getWorkspacePackagesRoot() {
+  return require('path').join(__dirname, '..', 'packages');
+}
+
+function findWorkspaceSiblingPackageDir(packageName) {
+  const fs = require('fs');
+  const path = require('path');
+  const packagesRoot = getWorkspacePackagesRoot();
+  if (!fs.existsSync(packagesRoot)) {
+    return null;
+  }
+
+  for (const child of fs.readdirSync(packagesRoot, { withFileTypes: true })) {
+    if (!child.isDirectory()) {
+      continue;
+    }
+
+    const packageJsonPath = path.join(packagesRoot, child.name, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+      continue;
+    }
+
+    try {
+      const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      if (pkg.name === packageName) {
+        return path.dirname(packageJsonPath);
+      }
+    } catch (error) {
+      // Ignore malformed workspace packages and keep searching.
+    }
+  }
+
+  return null;
+}
+
+function resolveInstalledPackageDir(packageName, searchPaths = []) {
+  const path = require('path');
+  const defaultPaths = [path.join(__dirname, '..'), process.cwd(), ...searchPaths];
+  try {
+    const packageJsonPath = require.resolve(`${packageName}/package.json`, {
+      paths: defaultPaths,
+    });
+    return path.dirname(packageJsonPath);
+  } catch (error) {
+    return findWorkspaceSiblingPackageDir(packageName);
+  }
+}
+
+module.exports = {
+  DAEMON_BINARY_PACKAGES,
+  PYTHON_RUNTIME_RELEASE,
+  PYTHON_RUNTIME_VERSION,
+  PYTHON_RUNTIME_PACKAGES,
+  DEFAULT_HARNESS_PACKAGES,
+  getBinaryPackageByPlatformKey,
+  getPythonRuntimePackageByPlatformKey,
+  resolveInstalledPackageDir,
+};

package/package.json

@@ -1,13 +1,18 @@
 {
   "name": "@agent-webui/ai-desk-daemon",
-  "version": "1.0.24",
+  "version": "1.0.29-beta1",
   "description": "AI Desk Daemon - CLI tool for managing the AI Desk daemon service",
+  "workspaces": [
+    "packages/*"
+  ],
   "main": "lib/daemon-manager.js",
   "bin": {
     "aidesk": "bin/cli.js"
   },
   "scripts": {
     "postinstall": "node scripts/postinstall.js",
+    "prepare:packages": "node scripts/prepare-npm-packages.js",
+    "publish:npm:workspaces": "node scripts/publish-npm-packages.js",
     "test": "node bin/cli.js --help"
   },
   "keywords": [
@@ -24,11 +29,6 @@
   "files": [
     "bin/",
     "lib/",
-    "dist/darwin-arm64/",
-    "dist/darwin-x64/",
-    "dist/linux-arm64/",
-    "dist/linux-x64/",
-    "dist/win32-x64/",
     "scripts/postinstall.js",
     "README.md"
   ],
@@ -36,6 +36,18 @@
     "commander": "^11.0.0",
     "chalk": "^4.1.2"
   },
+  "optionalDependencies": {
+    "@agent-webui/ai-desk-daemon-darwin-arm64": "1.0.29-beta1",
+    "@agent-webui/ai-desk-daemon-darwin-x64": "1.0.29-beta1",
+    "@agent-webui/ai-desk-daemon-linux-arm64": "1.0.29-beta1",
+    "@agent-webui/ai-desk-daemon-linux-x64": "1.0.29-beta1",
+    "@agent-webui/ai-desk-daemon-win32-x64": "1.0.29-beta1",
+    "@agent-webui/ai-desk-python-darwin-arm64": "1.0.29-beta1",
+    "@agent-webui/ai-desk-python-darwin-x64": "1.0.29-beta1",
+    "@agent-webui/ai-desk-python-linux-arm64": "1.0.29-beta1",
+    "@agent-webui/ai-desk-python-linux-x64": "1.0.29-beta1",
+    "@agent-webui/ai-desk-python-win32-x64": "1.0.29-beta1"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/agent-webui/ai-desk-daemon.git"

package/scripts/postinstall.js

@@ -7,10 +7,24 @@
  */
 
 const chalk = require('chalk');
+const path = require('path');
+const { ensureRuntime } = require('../lib/runtime-manager');
+const { installHarnessesForPackageRoot } = require('../lib/harness-manager');
 
 console.log('');
-console.log(chalk.green('✓ @agent-webui/ai-desk-daemon installed successfully'));
-console.log('');
-console.log('Run ' + chalk.cyan('aidesk --help') + ' to get started');
-console.log('');
 
+try {
+  const runtime = ensureRuntime();
+  const installResult = installHarnessesForPackageRoot(path.join(__dirname, '..'));
+
+  console.log(chalk.green('✓ @agent-webui/ai-desk-daemon installed successfully'));
+  console.log(chalk.cyan(`Runtime: ${runtime.pythonPath}`));
+  console.log(chalk.cyan(`Harnesses installed: ${installResult.harnessCount}`));
+  console.log('');
+  console.log('Run ' + chalk.cyan('aidesk --help') + ' to get started');
+  console.log('');
+} catch (error) {
+  console.log(chalk.yellow('! AI Desk daemon installed with runtime warnings'));
+  console.log(chalk.yellow(error.message));
+  console.log('');
+}