deepharness 0.0.1 → 0.0.3

package/README.md

@@ -4,14 +4,53 @@
 
 ## 安装
 
+`deepharness` npm 包会在安装时自动下载对应平台的原生 `dh` 二进制文件。
+
+```bash
+npm install -g deepharness
+```
+
+安装完成后验证：
+
+```bash
+dh --version
+```
+
+### 权限问题
+
+如果 `npm install -g` 出现 `EACCES` 权限错误，推荐将 npm 全局目录改到用户主目录：
+
 ```bash
+mkdir -p ~/.npm-global
+npm config set prefix '~/.npm-global'
+export PATH="$HOME/.npm-global/bin:$PATH"
+# 将上面 export 加入 ~/.bashrc 或 ~/.zshrc
+
 npm install -g deepharness
 ```
 
-**依赖要求：**
+或者使用 `npx`（无需全局安装）：
+
+```bash
+npx deepharness --version
+```
+
+### 手动指定二进制路径
+
+如果自动下载失败，或你想使用自己编译的 `dh`，可通过环境变量指定：
+
+```bash
+export DH_BINARY_PATH=/path/to/dh
+dh --version
+```
+
+## 支持的平台
+
+安装脚本会根据当前系统自动下载对应二进制：
 
-- 已安装 DeepHarness Desktop 应用 或 `dh` 二进制在 PATH 中
-- 若从源码编译：需要 Rust 工具链 (`cargo install --path apps/cli`)
+- Linux x64 / arm64
+- macOS x64 / arm64
+- Windows x64
 
 ## 使用
 

package/bin/dh.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { spawn, execSync } from 'child_process';
-import { existsSync } from 'fs';
+import { existsSync, realpathSync, readFileSync } from 'fs';
 import { dirname, join, resolve } from 'path';
 import { fileURLToPath } from 'url';
 import { homedir } from 'os';
@@ -8,8 +8,44 @@ import { homedir } from 'os';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
+const SYSTEM_INSTALL_URL = 'https://github.com/WraithN/deepharness-ent-desktop';
+
+/**
+ * Resolve the real path of the wrapper script, following symlinks created by
+ * `npm link` or package managers.
+ */
+function resolveWrapperPath() {
+  try {
+    return realpathSync(__filename);
+  } catch {
+    return __filename;
+  }
+}
+
+const WRAPPER_PATH = resolveWrapperPath();
+
+/**
+ * Check whether a candidate path resolves to this wrapper script itself.
+ * This prevents `which dh` from returning the npm-installed JS wrapper and
+ * causing an infinite subprocess loop.
+ */
+function isWrapperItself(candidate) {
+  try {
+    return realpathSync(candidate) === WRAPPER_PATH;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Find the project root when the npm package is installed directly inside the
+ * source repository (development / `npm link`). Returns `null` when installed
+ * from the registry.
+ */
 function findProjectRoot() {
-  let current = __dirname;
+  const wrapperPath = resolveWrapperPath();
+  let current = dirname(wrapperPath);
+
   while (true) {
     if (existsSync(join(current, 'Cargo.toml')) && existsSync(join(current, 'package.json'))) {
       return current;
@@ -22,55 +58,127 @@ function findProjectRoot() {
   }
 }
 
-function findDhBinary() {
-  const searchPaths = [];
+/**
+ * Build a list of candidate paths where the `dh` binary may live.
+ */
+function buildSearchPaths() {
+  const paths = [];
 
+  // 1. Explicit override from environment.
+  if (process.env.DH_BINARY_PATH) {
+    paths.push(resolve(process.env.DH_BINARY_PATH));
+  }
+
+  // 2. Project-local builds when developing from source.
   try {
     const projectRoot = findProjectRoot();
     if (projectRoot) {
-      searchPaths.push(join(projectRoot, 'target', 'release', 'dh'));
-      searchPaths.push(join(projectRoot, 'target', 'debug', 'dh'));
+      paths.push(join(projectRoot, 'target', 'release', 'dh'));
+      paths.push(join(projectRoot, 'target', 'debug', 'dh'));
     }
   } catch {}
 
-  searchPaths.push(
-    '/usr/local/bin/dh',
-    '/usr/bin/dh',
+  // 3. Common user-level install locations.
+  paths.push(
     join(homedir(), '.local', 'bin', 'dh'),
     join(homedir(), '.cargo', 'bin', 'dh'),
   );
 
-  for (const p of searchPaths) {
-    if (existsSync(p)) return p;
+  // 4. System-wide install locations.
+  paths.push('/usr/local/bin/dh', '/usr/bin/dh');
+
+  return paths;
+}
+
+/**
+ * Locate the `dh` binary, or return `null` if it cannot be found.
+ */
+function findDhBinary() {
+  for (const p of buildSearchPaths()) {
+    if (existsSync(p) && !isWrapperItself(p)) return p;
+  }
+
+  // Fallback: rely on the user's PATH. Skip the fallback when we are already
+  // inside a wrapper-spawned process to avoid infinite recursion if `which dh`
+  // points back at this wrapper.
+  if (process.env.DH_NPM_WRAPPER === '1') {
+    return null;
   }
 
   try {
     const which = execSync('which dh', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
-    if (which && existsSync(which)) return which;
+    if (which && existsSync(which) && !isWrapperItself(which)) return which;
   } catch {}
 
   return null;
 }
 
-let dhBin = findDhBinary();
+function readPackageVersion() {
+  try {
+    const pkgPath = join(__dirname, '..', 'package.json');
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    return pkg.version;
+  } catch {
+    return null;
+  }
+}
 
-if (!dhBin) {
+function printInstallInstructions() {
   console.error('Error: `dh` binary not found.');
   console.error('');
-  console.error('Please install DeepHarness Desktop from: https://github.com/deepharness/deepharness-ent-desktop');
-  console.error('Or build from source: cargo install --path apps/cli');
-  process.exit(1);
+  console.error('The `deepharness` npm package is a thin wrapper around the native `dh` binary.');
+  console.error('Please install the binary using one of the following methods:');
+  console.error('');
+  console.error('  1. Install DeepHarness Desktop:');
+  console.error(`     ${SYSTEM_INSTALL_URL}`);
+  console.error('');
+  console.error('  2. Build and install from source (requires Rust):');
+  console.error('     cargo build --release -p deepharness-cli');
+  console.error('     mkdir -p ~/.local/bin');
+  console.error('     cp target/release/dh ~/.local/bin/dh');
+  console.error('');
+  console.error('  3. If the binary is already installed in a non-standard location:');
+  console.error('     export DH_BINARY_PATH=/path/to/dh');
+}
+
+async function ensureDhBinary() {
+  const existing = findDhBinary();
+  if (existing) return existing;
+
+  // Try to download the binary from GitHub release on first use.
+  try {
+    const { downloadDhBinary } = await import('../scripts/download-binary.js');
+    const version = readPackageVersion();
+    if (!version) {
+      throw new Error('Cannot determine package version');
+    }
+    return await downloadDhBinary(version);
+  } catch (err) {
+    console.error(`[deepharness] Failed to download dh binary: ${err.message}`);
+    return null;
+  }
+}
+
+async function main() {
+  const dhBin = await ensureDhBinary();
+
+  if (!dhBin) {
+    printInstallInstructions();
+    process.exit(1);
+  }
+
+  const args = process.argv.slice(2);
+  const proc = spawn(dhBin, args, {
+    stdio: 'inherit',
+    cwd: process.cwd(),
+    env: { ...process.env, DH_NPM_WRAPPER: '1' },
+  });
+
+  proc.on('exit', (code) => process.exit(code ?? 1));
+  proc.on('error', (err) => {
+    console.error(`Failed to start dh from ${dhBin}:`, err.message);
+    process.exit(1);
+  });
 }
 
-const args = process.argv.slice(2);
-const proc = spawn(dhBin, args, {
-  stdio: 'inherit',
-  cwd: process.cwd(),
-  env: { ...process.env, DH_NPM_WRAPPER: '1' },
-});
-
-proc.on('exit', (code) => process.exit(code));
-proc.on('error', (err) => {
-  console.error('Failed to start dh:', err.message);
-  process.exit(1);
-});
+main();

package/package.json

@@ -1,12 +1,19 @@
 {
   "name": "deepharness",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "type": "module",
   "description": "DeepHarness CLI - Connect to AI coding agents with Claude Code, OpenCode, and more",
   "bin": {
     "dh": "bin/dh.js"
   },
-  "scripts": {},
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js"
+  },
+  "files": [
+    "bin/",
+    "scripts/",
+    "README.md"
+  ],
   "keywords": [
     "ai",
     "coding",
@@ -20,17 +27,20 @@
   ],
   "author": "DeepHarness Team",
   "license": "MIT",
+  "dependencies": {
+    "undici": "^6.0.0"
+  },
   "engines": {
     "node": ">= 18"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/deepharness/deepharness-ent-desktop.git"
+    "url": "git+https://github.com/WraithN/deepharness-ent-desktop.git"
   },
   "bugs": {
-    "url": "https://github.com/deepharness/deepharness-ent-desktop/issues"
+    "url": "https://github.com/WraithN/deepharness-ent-desktop/issues"
   },
-  "homepage": "https://github.com/deepharness/deepharness-ent-desktop",
+  "homepage": "https://github.com/WraithN/deepharness-ent-desktop",
   "publishConfig": {
     "access": "public"
   }

package/scripts/download-binary.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+/**
+ * Download the native `dh` binary from the GitHub release that matches the
+ * current platform and architecture.
+ */
+import { existsSync, mkdirSync, writeFileSync, chmodSync, readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+
+const GITHUB_OWNER = 'WraithN';
+const GITHUB_REPO = 'deepharness-ent-desktop';
+const DOWNLOAD_TIMEOUT_MS = 60_000;
+
+const PLATFORM_ASSET_NAMES = {
+  'linux:x64': 'dh-linux-x64',
+  'linux:arm64': 'dh-linux-arm64',
+  'darwin:x64': 'dh-darwin-x64',
+  'darwin:arm64': 'dh-darwin-arm64',
+  'win32:x64': 'dh-windows-x64.exe',
+};
+
+function getProxyUrl() {
+  return process.env.HTTPS_PROXY || process.env.https_proxy || process.env.HTTP_PROXY || process.env.http_proxy || null;
+}
+
+async function fetchWithProxy(url) {
+  const proxyUrl = getProxyUrl();
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), DOWNLOAD_TIMEOUT_MS);
+
+  try {
+    if (proxyUrl) {
+      try {
+        const { ProxyAgent } = await import('undici');
+        return await fetch(url, {
+          signal: controller.signal,
+          dispatcher: new ProxyAgent(proxyUrl),
+        });
+      } catch (err) {
+        // If undici/ProxyAgent fails, fall back to default fetch so users
+        // without a problematic proxy still work.
+        console.warn(`[deepharness] Proxy download failed (${err.message}), retrying without proxy.`);
+      }
+    }
+
+    return await fetch(url, { signal: controller.signal });
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+function getPackageVersion() {
+  const __filename = fileURLToPath(import.meta.url);
+  const packageJsonPath = join(dirname(__filename), '..', 'package.json');
+  try {
+    const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+    return pkg.version;
+  } catch {
+    return null;
+  }
+}
+
+function getAssetName() {
+  const key = `${process.platform}:${process.arch}`;
+  const assetName = PLATFORM_ASSET_NAMES[key];
+  if (!assetName) {
+    throw new Error(`Unsupported platform/architecture: ${key}. Supported platforms: ${Object.keys(PLATFORM_ASSET_NAMES).join(', ')}`);
+  }
+  return assetName;
+}
+
+function getBinaryName() {
+  return process.platform === 'win32' ? 'dh.exe' : 'dh';
+}
+
+function getInstallDir() {
+  return join(homedir(), '.local', 'bin');
+}
+
+function getBinaryPath() {
+  return join(getInstallDir(), getBinaryName());
+}
+
+function getDownloadUrl(version, assetName) {
+  return `https://github.com/${GITHUB_OWNER}/${GITHUB_REPO}/releases/download/dh-v${version}/${assetName}`;
+}
+
+/**
+ * Download the binary for the current platform and install it to ~/.local/bin.
+ * Returns the path to the installed binary.
+ */
+export async function downloadDhBinary(version) {
+  const assetName = getAssetName();
+  const binaryPath = getBinaryPath();
+  const downloadUrl = getDownloadUrl(version, assetName);
+
+  console.log(`[deepharness] Downloading dh ${version} for ${process.platform}-${process.arch}...`);
+  console.log(`[deepharness] URL: ${downloadUrl}`);
+
+  const response = await fetchWithProxy(downloadUrl);
+  if (!response.ok) {
+    throw new Error(`Download failed: ${response.status} ${response.statusText} (${downloadUrl})`);
+  }
+
+  const buffer = Buffer.from(await response.arrayBuffer());
+
+  mkdirSync(getInstallDir(), { recursive: true });
+  writeFileSync(binaryPath, buffer);
+
+  if (process.platform !== 'win32') {
+    chmodSync(binaryPath, 0o755);
+  }
+
+  console.log(`[deepharness] Installed dh to ${binaryPath}`);
+  return binaryPath;
+}
+
+/**
+ * Check whether the installed binary is present.
+ */
+export function isBinaryInstalled() {
+  return existsSync(getBinaryPath());
+}
+
+export { getBinaryPath, getPackageVersion };
+
+// CLI entry point for testing or manual download.
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const version = process.argv[2] || getPackageVersion();
+  if (!version) {
+    console.error('Usage: node download-binary.js <version>');
+    process.exit(1);
+  }
+  downloadDhBinary(version).catch((err) => {
+    console.error(err.message);
+    process.exit(1);
+  });
+}

package/scripts/postinstall.js

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+/**
+ * Post-install hook for the `deepharness` npm package.
+ *
+ * The npm package is only a wrapper; it needs the native `dh` binary to be
+ * present on the system. This script verifies that the binary exists and,
+ * when possible, installs it automatically by downloading from the matching
+ * GitHub release or by building from source.
+ */
+import { existsSync, realpathSync, readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { homedir } from 'os';
+import { execSync } from 'child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const SYSTEM_INSTALL_URL = 'https://github.com/WraithN/deepharness-ent-desktop';
+
+function resolveWrapperPath() {
+  try {
+    return realpathSync(__filename);
+  } catch {
+    return __filename;
+  }
+}
+
+const WRAPPER_PATH = resolveWrapperPath();
+
+function isWrapperItself(candidate) {
+  try {
+    return realpathSync(candidate) === WRAPPER_PATH;
+  } catch {
+    return false;
+  }
+}
+
+function findProjectRoot() {
+  const wrapperPath = resolveWrapperPath();
+  let current = dirname(wrapperPath);
+
+  while (true) {
+    if (existsSync(join(current, 'Cargo.toml')) && existsSync(join(current, 'package.json'))) {
+      return current;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
+function findExistingDhBinary() {
+  const candidates = [
+    join(homedir(), '.local', 'bin', 'dh'),
+    join(homedir(), '.cargo', 'bin', 'dh'),
+    '/usr/local/bin/dh',
+    '/usr/bin/dh',
+  ];
+
+  for (const p of candidates) {
+    if (existsSync(p) && !isWrapperItself(p)) return p;
+  }
+
+  try {
+    const which = execSync('which dh', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    if (which && existsSync(which) && !isWrapperItself(which)) return which;
+  } catch {}
+
+  return null;
+}
+
+function readPackageVersion() {
+  try {
+    const pkgPath = join(__dirname, '..', 'package.json');
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    return pkg.version;
+  } catch {
+    return null;
+  }
+}
+
+function buildFromSource(projectRoot) {
+  console.log(`[deepharness] Building native dh binary from ${projectRoot}...`);
+  try {
+    execSync('cargo build --release -p deepharness-cli', {
+      cwd: projectRoot,
+      stdio: 'inherit',
+    });
+    return true;
+  } catch {
+    console.error('[deepharness] Failed to build dh from source.');
+    return false;
+  }
+}
+
+async function downloadBinary() {
+  const { downloadDhBinary } = await import('./download-binary.js');
+  const version = readPackageVersion();
+  if (!version) {
+    throw new Error('Cannot determine package version');
+  }
+  return downloadDhBinary(version);
+}
+
+async function main() {
+  // If a usable binary already exists, nothing more to do.
+  const existing = findExistingDhBinary();
+  if (existing) {
+    console.log(`[deepharness] Found dh binary at ${existing}`);
+    return;
+  }
+
+  const projectRoot = findProjectRoot();
+
+  // Prefer building from source when installed inside the repository.
+  if (projectRoot) {
+    console.log('[deepharness] dh binary not found; attempting to build from source...');
+    const built = buildFromSource(projectRoot);
+    if (built) {
+      const releaseBinary = join(projectRoot, 'target', 'release', 'dh');
+      if (existsSync(releaseBinary)) {
+        console.log(`[deepharness] Built dh binary at ${releaseBinary}`);
+        console.log('[deepharness] Add it to your PATH to use the `dh` command globally:');
+        console.log(`  export PATH="${join(projectRoot, 'target', 'release')}:$PATH"`);
+      }
+      return;
+    }
+  }
+
+  // Otherwise try to download the matching release binary.
+  try {
+    await downloadBinary();
+    return;
+  } catch (err) {
+    console.warn(`[deepharness] Could not download binary: ${err.message}`);
+  }
+
+  console.warn('[deepharness] The native `dh` binary is not installed.');
+  console.warn('[deepharness] The `dh` command will not work until it is available.');
+  console.warn(`[deepharness] Install DeepHarness Desktop from: ${SYSTEM_INSTALL_URL}`);
+  console.warn('[deepharness] Or build from source: cargo build --release -p deepharness-cli');
+}
+
+main().catch((err) => {
+  console.warn(`[deepharness] Post-install hook failed: ${err.message}`);
+});