@factory/cli 0.1.2-dev.7 → 0.55.2

package/install.js

@@ -0,0 +1,314 @@
+#!/usr/bin/env node
+
+/**
+ * postinstall script for @factory/cli
+ *
+ * This script optimizes the installed package by replacing the JavaScript shim
+ * with a hard link to the actual binary executable. This avoids the overhead
+ * of launching another Node.js process when using the "droid" command.
+ *
+ * Based on esbuild's approach: https://github.com/evanw/esbuild/pull/1621
+ * and Sentry's guide: https://sentry.engineering/blog/publishing-binaries-on-npm
+ *
+ * On Unix: replaces bin/droid with hard link to the platform binary
+ * On Windows: keeps JS shim (Windows requires .exe extension)
+ * With --ignore-scripts: falls back to JS shim (still works, just slower)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const zlib = require('zlib');
+const child_process = require('child_process');
+
+const {
+  PLATFORM_PACKAGES,
+  getPlatformKey,
+  getBinaryName,
+  getBinaryPath,
+  detectAVX2Support,
+} = require('./platform.js');
+
+// Read version - handle case where package.json doesn't exist yet (template dir)
+let PACKAGE_VERSION = '0.0.0';
+try {
+  PACKAGE_VERSION = require('./package.json').version;
+} catch (e) {
+  // Running from template directory before build
+}
+
+function isYarn2OrAbove() {
+  const { npm_config_user_agent } = process.env;
+  if (npm_config_user_agent) {
+    const match = npm_config_user_agent.match(/yarn\/(\d+)/);
+    if (match && match[1]) {
+      return parseInt(match[1], 10) >= 2;
+    }
+  }
+  return false;
+}
+
+function validateBinaryVersion(binaryPath) {
+  try {
+    const result = child_process.execFileSync(binaryPath, ['--version'], {
+      encoding: 'utf8',
+      timeout: 10000,
+    });
+    const version = result.trim().split('\n')[0];
+    // Version format might be "droid 0.50.0" or just "0.50.0"
+    if (PACKAGE_VERSION !== '0.0.0' && !version.includes(PACKAGE_VERSION)) {
+      console.warn(
+        `Warning: Binary version mismatch. Expected ${PACKAGE_VERSION}, got ${version}`
+      );
+    }
+  } catch (e) {
+    // Version check is optional, don't fail install
+  }
+}
+
+/**
+ * Make an HTTPS request with optional npm authentication.
+ * Uses NPM_TOKEN env var if available to bypass rate limits.
+ */
+function makeRequest(url) {
+  return new Promise((resolve, reject) => {
+    const parsedUrl = new URL(url);
+    const options = {
+      hostname: parsedUrl.hostname,
+      path: parsedUrl.pathname + parsedUrl.search,
+      headers: {},
+    };
+
+    // Add auth header if NPM_TOKEN is available (bypasses rate limits in CI)
+    if (process.env.NPM_TOKEN && parsedUrl.hostname.includes('npmjs.org')) {
+      options.headers['Authorization'] = `Bearer ${process.env.NPM_TOKEN}`;
+    }
+
+    https
+      .get(options, (response) => {
+        if (response.statusCode >= 200 && response.statusCode < 300) {
+          const chunks = [];
+          response.on('data', (chunk) => chunks.push(chunk));
+          response.on('end', () => resolve(Buffer.concat(chunks)));
+        } else if (
+          response.statusCode >= 300 &&
+          response.statusCode < 400 &&
+          response.headers.location
+        ) {
+          makeRequest(response.headers.location).then(resolve, reject);
+        } else {
+          reject(
+            new Error(
+              `npm responded with status code ${response.statusCode} when downloading the package`
+            )
+          );
+        }
+      })
+      .on('error', reject);
+  });
+}
+
+/**
+ * Fetch the tarball URL from npm registry packument.
+ * This is more reliable than constructing the URL manually.
+ */
+function fetchTarballUrl(packageName, version) {
+  return new Promise((resolve, reject) => {
+    const encodedName = packageName.replace('/', '%2f');
+    const url = `https://registry.npmjs.org/${encodedName}`;
+
+    makeRequest(url)
+      .then((buffer) => {
+        const packument = JSON.parse(buffer.toString('utf8'));
+        const versionData = packument.versions?.[version];
+        if (!versionData) {
+          throw new Error(
+            `Version ${version} not found for package ${packageName}`
+          );
+        }
+        const tarballUrl = versionData.dist?.tarball;
+        if (!tarballUrl) {
+          throw new Error(`No tarball URL found for ${packageName}@${version}`);
+        }
+        resolve(tarballUrl);
+      })
+      .catch(reject);
+  });
+}
+
+/**
+ * Download the platform-specific package from npm registry as a fallback.
+ * This handles the case where optionalDependencies were disabled.
+ */
+function downloadBinaryFromNpm() {
+  return new Promise((resolve, reject) => {
+    const platformKey = getPlatformKey();
+    const packages = PLATFORM_PACKAGES[platformKey];
+
+    if (!packages) {
+      reject(new Error(`Unsupported platform: ${platformKey}`));
+      return;
+    }
+
+    // Choose package based on AVX2 support
+    const hasBaseline = !!packages.baseline;
+    let useBaseline = false;
+    if (hasBaseline) {
+      const avx2Supported = detectAVX2Support();
+      if (avx2Supported === false) {
+        useBaseline = true;
+      }
+    }
+
+    const packageName = useBaseline ? packages.baseline : packages.regular;
+
+    console.log(`Downloading ${packageName}@${PACKAGE_VERSION} from npm...`);
+
+    // Fetch the tarball URL from packument instead of constructing it manually
+    fetchTarballUrl(packageName, PACKAGE_VERSION)
+      .then((tarballUrl) => makeRequest(tarballUrl))
+      .then((tarballBuffer) => {
+        const unzipped = zlib.gunzipSync(tarballBuffer);
+        const binaryName = getBinaryName();
+        const binaryData = extractFileFromTarball(
+          unzipped,
+          `package/bin/${binaryName}`
+        );
+
+        if (!binaryData) {
+          throw new Error(
+            `Binary not found in tarball: package/bin/${binaryName}`
+          );
+        }
+
+        // Ensure bin directory exists before writing
+        const binDir = path.join(__dirname, 'bin');
+        fs.mkdirSync(binDir, { recursive: true });
+
+        // Write binary to local bin directory
+        const localBinPath = path.join(binDir, binaryName);
+        fs.writeFileSync(localBinPath, binaryData, { mode: 0o755 });
+
+        console.log(`Downloaded and extracted binary to ${localBinPath}`);
+        resolve(localBinPath);
+      })
+      .catch(reject);
+  });
+}
+
+function extractFileFromTarball(tarballBuffer, filepath) {
+  // Tar archives are organized in 512 byte blocks
+  let offset = 0;
+  while (offset < tarballBuffer.length) {
+    const header = tarballBuffer.subarray(offset, offset + 512);
+    offset += 512;
+
+    const fileName = header.toString('utf-8', 0, 100).replace(/\0.*/g, '');
+    const fileSize = parseInt(
+      header.toString('utf-8', 124, 136).replace(/\0.*/g, ''),
+      8
+    );
+
+    if (isNaN(fileSize)) break;
+
+    if (fileName === filepath) {
+      return tarballBuffer.subarray(offset, offset + fileSize);
+    }
+
+    // Clamp offset to the upper multiple of 512
+    offset = (offset + fileSize + 511) & ~511;
+  }
+  return null;
+}
+
+async function main() {
+  const shimPath = path.join(__dirname, 'bin', 'droid');
+  let binaryPath = getBinaryPath();
+
+  // If optionalDependency not found, try downloading from npm
+  if (!binaryPath) {
+    console.log('Platform-specific binary not found in optionalDependencies.');
+    try {
+      binaryPath = await downloadBinaryFromNpm();
+    } catch (e) {
+      console.log(
+        `Failed to download binary: ${e.message}\n` +
+          'The "droid" command will use the JavaScript fallback.\n' +
+          'For better performance, ensure optionalDependencies are installed.'
+      );
+      return;
+    }
+  }
+
+  // On Windows, we can't replace the shim with the binary due to .exe requirement
+  // On Yarn 2+, PnP mode has issues with binary modules
+  if (process.platform === 'win32' || isYarn2OrAbove()) {
+    validateBinaryVersion(binaryPath);
+    console.log('Using JavaScript shim for droid command.');
+    return;
+  }
+
+  // On Unix, replace the JavaScript shim with a hard link to the binary
+  // First, backup the shim in case linking fails
+  const shimBackupPath = shimPath + '.backup';
+  let shimBackedUp = false;
+
+  try {
+    // Backup the existing shim
+    if (fs.existsSync(shimPath)) {
+      fs.copyFileSync(shimPath, shimBackupPath);
+      shimBackedUp = true;
+    }
+
+    // Remove the existing shim
+    fs.unlinkSync(shimPath);
+
+    // Create a hard link to the binary
+    fs.linkSync(binaryPath, shimPath);
+
+    // Clean up backup
+    if (shimBackedUp) {
+      fs.unlinkSync(shimBackupPath);
+    }
+
+    validateBinaryVersion(shimPath);
+    console.log(
+      'Optimized: droid command now runs the native binary directly.'
+    );
+  } catch (e) {
+    // If hard link fails (e.g., cross-device), try symlink
+    try {
+      fs.symlinkSync(binaryPath, shimPath);
+
+      // Clean up backup
+      if (shimBackedUp) {
+        fs.unlinkSync(shimBackupPath);
+      }
+
+      console.log('Optimized: droid command linked to native binary.');
+    } catch (e2) {
+      // Restore the shim from backup
+      if (shimBackedUp) {
+        try {
+          fs.renameSync(shimBackupPath, shimPath);
+          console.log(
+            'Using JavaScript shim for droid command (optimization failed).'
+          );
+        } catch (e3) {
+          console.error(
+            'Failed to restore shim. Please reinstall the package.'
+          );
+        }
+      } else {
+        console.log(
+          'Using JavaScript shim for droid command (optimization failed).'
+        );
+      }
+    }
+  }
+}
+
+main().catch((e) => {
+  console.error('postinstall error:', e.message);
+  // Don't fail the install - the JS shim will still work
+});

package/package.json

@@ -1,104 +1,47 @@
 {
   "name": "@factory/cli",
-  "version": "0.1.2-dev.7",
-  "private": false,
-  "type": "module",
-  "main": "dist/index.js",
+  "version": "0.55.2",
+  "description": "Factory Droid CLI - AI-powered software engineering agent",
   "bin": {
-    "droid": "bundle/droid.js"
-  },
-  "engines": {
-    "bun": ">=1.0.0"
+    "droid": "bin/droid"
   },
+  "main": "platform.js",
   "files": [
-    "bundle/",
-    "README.md",
-    "LICENSE"
+    "bin/",
+    "platform.js",
+    "install.js",
+    "README.md"
   ],
   "scripts": {
-    "start": "bun scripts/start.js",
-    "debug": "DEBUG=1 bun scripts/start.js",
-    "build": "bun run clean && bun scripts/build.js",
-    "build:sea:linux": "bun scripts/build-sea.ts linux x64",
-    "build:sea:mac:x64": "bun scripts/build-sea.ts darwin x64",
-    "build:sea:mac:arm64": "bun scripts/build-sea.ts darwin arm64",
-    "build:sea:windows": "bun scripts/build-sea.ts windows x64",
-    "bundle": "bun bun.build.ts",
-    "bundle:dev": "bun bun.build.ts --dev",
-    "package": "bun run build && bun run bundle",
-    "clean": "rm -rf dist bundle",
-    "prepare": "bun run bundle",
-    "typecheck": "tsc --noEmit",
-    "test": "NODE_OPTIONS='--experimental-vm-modules' bun run jest --coverage",
-    "test:watch": "NODE_OPTIONS='--experimental-vm-modules' bun run jest --watch",
-    "lint": "eslint \"./src/**/*.{ts,tsx}\"",
-    "fix": "bun run lint -- --fix; bun run format",
-    "format": "prettier --list-different --write ./src"
+    "postinstall": "node install.js"
+  },
+  "optionalDependencies": {
+    "@factory/cli-darwin-arm64": "0.55.2",
+    "@factory/cli-darwin-x64": "0.55.2",
+    "@factory/cli-darwin-x64-baseline": "0.55.2",
+    "@factory/cli-linux-arm64": "0.55.2",
+    "@factory/cli-linux-x64": "0.55.2",
+    "@factory/cli-linux-x64-baseline": "0.55.2",
+    "@factory/cli-win32-x64": "0.55.2",
+    "@factory/cli-win32-x64-baseline": "0.55.2"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Factory-AI/factory.git",
+    "directory": "apps/cli"
   },
-  "dependencies": {
-    "@anthropic-ai/sdk": "^0.57.0",
-    "@factory/common": "^0.1.0",
-    "@factory/droid-core": "^0.1.0",
-    "@factory/errors": "^0.1.0",
-    "@factory/logging": "^0.1.0",
-    "@factory/mcp": "^0.1.0",
-    "@factory/models": "^0.1.0",
-    "@factory/services": "^0.1.0",
-    "@factory/utils": "^0.1.0",
-    "@modelcontextprotocol/sdk": "^1.1.0",
-    "@statsig/react-bindings": "^3.8.2",
-    "@statsig/statsig-node-core": "^0.6.1",
-    "@types/express": "^5.0.3",
-    "@types/lodash": "^4.17.20",
-    "@types/marked": "^5.0.2",
-    "@types/react": "19.0.2",
-    "@types/uuid": "^10.0.0",
-    "@vscode/ripgrep": "^1.15.14",
-    "ansi-escapes": "^7.0.0",
-    "chalk": "^5.3.0",
-    "commander": "^11.0.0",
-    "diff": "^8.0.2",
-    "express": "^5.1.0",
-    "glob": "^10.4.5",
-    "highlight.js": "^11.11.1",
-    "ink": "^6.1.0",
-    "inquirer": "^12.8.2",
-    "jose": "^5.9.4",
-    "lodash-es": "^4.17.21",
-    "marked": "^16.1.1",
-    "mime": "^4.0.7",
-    "node-fetch": "^3.3.2",
-    "open": "^10.2.0",
-    "ora": "^8.1.1",
-    "prop-types": "^15.8.1",
-    "shell-quote": "^1.8.3",
-    "semver": "^7.7.2",
-    "table": "^6.8.2",
-    "terminal-link": "^3.0.0",
-    "uuid": "^9.0.0",
-    "zod": "^3.23.8",
-    "zod-to-json-schema": "^3.24.1"
+  "publishConfig": {
+    "access": "public"
   },
-  "devDependencies": {
-    "@factory/eslint-config": "^0.1.0",
-    "@jest/globals": "^29.7.0",
-    "@types/diff": "^7.0.2",
-    "@types/inquirer": "^9.0.8",
-    "@types/jest": "^29.5.14",
-    "@types/jsdom": "^21.1.7",
-    "@types/lodash-es": "^4.17.12",
-    "@types/node": "^20",
-    "@types/node-fetch": "^2.6.11",
-    "@types/prop-types": "^15.7.15",
-    "@types/shell-quote": "^1.7.5",
-    "esbuild": "^0.25.0",
-    "eslint-plugin-no-barrel-files": "^1.2.2",
-    "ink-testing-library": "^4.0.0",
-    "jest": "^29.7.0",
-    "jsdom": "^26.1.0",
-    "ts-jest": "^29.2.6",
-    "ts-node": "^10.9.2",
-    "tsx": "^4.20.3",
-    "typescript": "^5.3.3"
-  }
-}
+  "keywords": [
+    "factory",
+    "droid",
+    "cli",
+    "ai",
+    "agent"
+  ]
+}

package/platform.js

@@ -0,0 +1,166 @@
+/**
+ * Platform detection utilities for @factory/cli
+ *
+ * Exports the platform package mapping and helper functions for
+ * determining the correct binary to use.
+ */
+
+const fs = require('fs');
+const child_process = require('child_process');
+
+// Platform-specific package mapping
+// x64 platforms have both regular (AVX2) and baseline (no AVX2) variants
+const PLATFORM_PACKAGES = {
+  'darwin-arm64': { regular: '@factory/cli-darwin-arm64' },
+  'darwin-x64': {
+    regular: '@factory/cli-darwin-x64',
+    baseline: '@factory/cli-darwin-x64-baseline',
+  },
+  'linux-arm64': { regular: '@factory/cli-linux-arm64' },
+  'linux-x64': {
+    regular: '@factory/cli-linux-x64',
+    baseline: '@factory/cli-linux-x64-baseline',
+  },
+  'win32-x64': {
+    regular: '@factory/cli-win32-x64',
+    baseline: '@factory/cli-win32-x64-baseline',
+  },
+};
+
+// All packages (used for optionalDependencies)
+const ALL_PACKAGES = Object.values(PLATFORM_PACKAGES).flatMap((p) =>
+  [p.regular, p.baseline].filter(Boolean)
+);
+
+function getPlatformKey() {
+  return `${process.platform}-${process.arch}`;
+}
+
+function getBinaryName() {
+  return process.platform === 'win32' ? 'droid.exe' : 'droid';
+}
+
+function getPlatformPackages() {
+  const platformKey = getPlatformKey();
+  return PLATFORM_PACKAGES[platformKey] || null;
+}
+
+/**
+ * Detect if CPU supports AVX2 instructions.
+ * Returns true if AVX2 is supported, false if not, null if detection failed.
+ */
+function detectAVX2Support() {
+  try {
+    if (process.platform === 'linux') {
+      const cpuinfo = fs.readFileSync('/proc/cpuinfo', 'utf8');
+      return cpuinfo.toLowerCase().includes('avx2');
+    } else if (process.platform === 'darwin') {
+      const result = child_process.execSync(
+        'sysctl -n machdep.cpu.leaf7_features',
+        { encoding: 'utf8', timeout: 5000 }
+      );
+      return result.toLowerCase().includes('avx2');
+    } else if (process.platform === 'win32') {
+      // Windows: use kernel32.dll IsProcessorFeaturePresent(40) via PowerShell
+      // Feature ID 40 = PF_AVX2_INSTRUCTIONS_AVAILABLE
+      // This is the same method used by the Factory CLI installer and Bun
+      const script = `
+        try {
+          $hasAvx2 = (Add-Type -MemberDefinition '[DllImport("kernel32.dll")] public static extern bool IsProcessorFeaturePresent(int ProcessorFeature);' -Name 'Kernel32' -Namespace 'Win32' -PassThru -ErrorAction Stop)::IsProcessorFeaturePresent(40)
+          if ($hasAvx2) { Write-Output 'true' } else { Write-Output 'false' }
+        } catch {
+          try {
+            $hasAvx2 = ([Win32.Kernel32]::IsProcessorFeaturePresent(40))
+            if ($hasAvx2) { Write-Output 'true' } else { Write-Output 'false' }
+          } catch {
+            Write-Output 'unknown'
+          }
+        }
+      `;
+      const result = child_process.execSync(
+        `powershell -NoProfile -Command "${script.replace(/\n/g, ' ')}"`,
+        { encoding: 'utf8', timeout: 10000 }
+      );
+      const output = result.trim().toLowerCase();
+      if (output === 'true') return true;
+      if (output === 'false') return false;
+      // 'unknown' or other - detection failed
+      return null;
+    }
+  } catch (e) {
+    // Detection failed
+  }
+  return null;
+}
+
+function resolveBinaryPath(packageName) {
+  if (!packageName) return null;
+  try {
+    return require.resolve(`${packageName}/bin/${getBinaryName()}`);
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Get the binary path with AVX2-aware package selection.
+ * Returns { path, pkg, hasBaseline } or null if not found.
+ */
+function getBinaryPathWithInfo() {
+  const packages = getPlatformPackages();
+  if (!packages) {
+    return null;
+  }
+
+  const hasBaseline = !!packages.baseline;
+  let useBaseline = false;
+
+  if (hasBaseline) {
+    const avx2Supported = detectAVX2Support();
+    if (avx2Supported === false) {
+      useBaseline = true;
+    }
+  }
+
+  const preferredPkg = useBaseline ? packages.baseline : packages.regular;
+  const fallbackPkg = useBaseline ? packages.regular : packages.baseline;
+
+  let binPath = resolveBinaryPath(preferredPkg);
+  let selectedPkg = preferredPkg;
+
+  if (!binPath && fallbackPkg) {
+    binPath = resolveBinaryPath(fallbackPkg);
+    selectedPkg = fallbackPkg;
+  }
+
+  if (!binPath) {
+    return null;
+  }
+
+  return { path: binPath, pkg: selectedPkg, hasBaseline };
+}
+
+/**
+ * Get the binary path (simple version for backward compatibility).
+ */
+function getBinaryPath() {
+  const result = getBinaryPathWithInfo();
+  return result ? result.path : null;
+}
+
+function isSupportedPlatform() {
+  return getPlatformPackages() !== null;
+}
+
+module.exports = {
+  PLATFORM_PACKAGES,
+  ALL_PACKAGES,
+  getPlatformKey,
+  getBinaryName,
+  getPlatformPackages,
+  detectAVX2Support,
+  resolveBinaryPath,
+  getBinaryPathWithInfo,
+  getBinaryPath,
+  isSupportedPlatform,
+};