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

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.30';
+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.30",
+  "version": "1.0.32",
   "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,8 @@
   "files": [
     "bin/",
     "lib/",
-    "dist/darwin-arm64/",
-    "dist/darwin-x64/",
-    "dist/linux-arm64/",
-    "dist/linux-x64/",
-    "dist/win32-x64/",
+    "python-runtime/setup.py",
+    "python-runtime/cli_anything/",
     "scripts/postinstall.js",
     "README.md"
   ],
@@ -36,6 +38,18 @@
     "commander": "^11.0.0",
     "chalk": "^4.1.2"
   },
+  "optionalDependencies": {
+    "@agent-webui/ai-desk-daemon-darwin-arm64": "1.0.32",
+    "@agent-webui/ai-desk-daemon-darwin-x64": "1.0.32",
+    "@agent-webui/ai-desk-daemon-linux-arm64": "1.0.32",
+    "@agent-webui/ai-desk-daemon-linux-x64": "1.0.32",
+    "@agent-webui/ai-desk-daemon-win32-x64": "1.0.32",
+    "@agent-webui/ai-desk-python-darwin-arm64": "1.0.32",
+    "@agent-webui/ai-desk-python-darwin-x64": "1.0.32",
+    "@agent-webui/ai-desk-python-linux-arm64": "1.0.32",
+    "@agent-webui/ai-desk-python-linux-x64": "1.0.32",
+    "@agent-webui/ai-desk-python-win32-x64": "1.0.32"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/agent-webui/ai-desk-daemon.git"

package/python-runtime/cli_anything/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

package/python-runtime/cli_anything/__main__.py

@@ -0,0 +1,5 @@
+from cli_anything._compat import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())