drift-ml 0.1.6 → 0.1.10

package/README.md

@@ -52,13 +52,19 @@ drift
 
 The `drift` command installs or upgrades the chat CLI (Python) and runs it. You get the welcome and instructions every time.
 
-### Alternative: pipx (Python only)
+### Alternative: pipx (Python only — macOS, Linux, Windows)
 
 ```bash
-pipx install drift
+pipx install drift-ml
 drift
 ```
 
+**Update (pipx):**
+```bash
+pipx upgrade drift-ml
+```
+(PowerShell on Windows: same command.)
+
 ---
 
 ## Example usage

package/bin/drift.js

@@ -1,101 +1,213 @@
 #!/usr/bin/env node
-
-const { spawnSync } = require("child_process");
+//
+// REMOVED: Any pip/pipx/python -m pip install or upgrade logic.
+// WHY: PEP 668 and user envs; we must not modify Python. User installs CLI via pipx once.
+//
+// FINAL FLOW: (1) If no DRIFT_BACKEND_URL, ensure engine at 127.0.0.1:8000 (download + start if needed).
+//             (2) Locate Python drift ONLY in ~/.local/bin (macOS/Linux) or %USERPROFILE%\.local\bin (Windows).
+//             (3) Spawn that binary with DRIFT_BACKEND_URL set; never run drift.cmd/drift.ps1/drift.js (self).
+//
+
+const { spawnSync, spawn } = require("child_process");
 const path = require("path");
 const fs = require("fs");
+const https = require("https");
+const http = require("http");
 
 const isWindows = process.platform === "win32";
+const ENGINE_PORT = process.env.DRIFT_ENGINE_PORT || "8000";
+// Pinned tag: draft releases are invisible to /releases/latest.
+const ENGINE_BASE_URL = process.env.DRIFT_ENGINE_BASE_URL || "https://github.com/lakshitsachdeva/intent2model/releases/download/v0.1.0";
+const HEALTH_URL = `http://127.0.0.1:${ENGINE_PORT}/health`;
+const HEALTH_TIMEOUT_MS = 2000;
+const HEALTH_POLL_MS = 500;
+const HEALTH_POLL_MAX = 60; // 30 seconds total
+const isMac = process.platform === "darwin";
+
+function getPlatformKey() {
+  const p = process.platform;
+  const a = process.arch;
+  const plat = p === "darwin" ? "macos" : p === "win32" ? "windows" : "linux";
+  const arch = a === "arm64" || a === "aarch64" ? "arm64" : "x64";
+  return { plat, arch };
+}
 
-// Known pipx install locations (Unix and Windows)
-function getPipxBinPaths() {
+function getEngineDir() {
   const home = process.env.HOME || process.env.USERPROFILE || "";
-  if (!home) return [];
-  const localBin = path.join(home, ".local", "bin");
-  if (isWindows) {
-    return [
-      path.join(localBin, "drift.exe"),
-      path.join(localBin, "drift"),
-    ];
-  }
-  return [
-    path.join(localBin, "drift"),
-    "/usr/local/bin/drift",
-  ];
+  if (!home) return null;
+  return path.join(home, ".drift", "bin");
 }
 
-function isLikelyUsOrNpmWrapper(filePath, content) {
-  if (!content || typeof content !== "string") return false;
-  const s = content.slice(0, 200);
-  // Node launcher
-  if (s.includes("#!/usr/bin/env node")) return true;
-  // Windows npm .cmd wrapper (invokes node)
-  if (s.includes("node") && (s.startsWith("@") || s.includes("cmd.exe"))) return true;
-  return false;
+function getEnginePath() {
+  const dir = getEngineDir();
+  if (!dir) return null;
+  const { plat, arch } = getPlatformKey();
+  const ext = isWindows ? ".exe" : "";
+  return path.join(dir, `drift-engine-${plat}-${arch}${ext}`);
 }
 
-// Find Python-based drift (not this Node script or npm's drift.cmd)
-function findPythonDrift() {
-  for (const p of getPipxBinPaths()) {
-    if (fs.existsSync(p)) {
-      try {
-        const content = fs.readFileSync(p, "utf8").slice(0, 200);
-        if (!isLikelyUsOrNpmWrapper(p, content)) return p;
-      } catch (_) {
-        return p;
+function fetchOk(url) {
+  return new Promise((resolve) => {
+    const client = url.startsWith("https") ? https : http;
+    const req = client.get(url, { timeout: HEALTH_TIMEOUT_MS }, (res) => {
+      const redirect = res.statusCode >= 301 && res.statusCode <= 302 && res.headers.location;
+      if (redirect) {
+        fetchOk(redirect).then(resolve).catch(() => resolve(false));
+        return;
       }
-    }
-  }
+      resolve(res.statusCode === 200);
+    });
+    req.on("error", () => resolve(false));
+    req.on("timeout", () => { req.destroy(); resolve(false); });
+  });
+}
+
+function downloadFile(url, destPath) {
+  return new Promise((resolve, reject) => {
+    const client = url.startsWith("https") ? https : http;
+    const req = client.get(url, (res) => {
+      const redirect = res.statusCode >= 301 && res.statusCode <= 302 && res.headers.location;
+      if (redirect) {
+        downloadFile(redirect, destPath).then(resolve).catch(reject);
+        return;
+      }
+      if (res.statusCode !== 200) {
+        reject(new Error(`Download failed: ${res.statusCode}`));
+        return;
+      }
+      const dir = path.dirname(destPath);
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      const file = fs.createWriteStream(destPath);
+      res.pipe(file);
+      file.on("finish", () => { file.close(); resolve(); });
+      file.on("error", reject);
+    });
+    req.on("error", reject);
+  });
+}
+
+function engineRunning() {
+  return fetchOk(HEALTH_URL);
+}
 
-  const pathEnv = process.env.PATH || "";
-  const dirs = pathEnv.split(path.delimiter);
+function waitForEngine() {
+  return new Promise((resolve) => {
+    let n = 0;
+    const t = setInterval(() => {
+      n++;
+      fetchOk(HEALTH_URL).then((ok) => {
+        if (ok) { clearInterval(t); resolve(true); }
+        else if (n >= HEALTH_POLL_MAX) { clearInterval(t); resolve(false); }
+      });
+    }, HEALTH_POLL_MS);
+  });
+}
 
-  for (const dir of dirs) {
-    const base = path.join(dir, "drift");
-    const candidates = isWindows ? [base + ".exe", base + ".cmd", base] : [base];
-    for (const candidate of candidates) {
-      if (!fs.existsSync(candidate)) continue;
-      const ext = path.extname(candidate).toLowerCase();
-      if (isWindows && (ext === ".cmd" || ext === ".bat" || ext === ".ps1")) continue;
+async function ensureEngine() {
+  const binPath = getEnginePath();
+  const binDir = getEngineDir();
+  if (!binPath || !binDir) {
+    console.error("drift: Could not resolve engine directory (~/.drift/bin). Set HOME or USERPROFILE.");
+    return false;
+  }
+  if (!fs.existsSync(binDir)) {
+    fs.mkdirSync(binDir, { recursive: true });
+  }
+  if (!fs.existsSync(binPath)) {
+    const { plat, arch } = getPlatformKey();
+    const ext = isWindows ? ".exe" : "";
+    const asset = `drift-engine-${plat}-${arch}${ext}`;
+    const url = `${ENGINE_BASE_URL.replace(/\/$/, "")}/${asset}`;
+    process.stderr.write(`drift: Downloading engine (${asset})...\n`);
+    try {
+      await downloadFile(url, binPath);
+    } catch (e) {
+      console.error("drift: Download failed.", e.message);
+      console.error("drift: Set DRIFT_ENGINE_BASE_URL or run the engine manually.");
+      return false;
+    }
+    if (!isWindows) {
+      try { fs.chmodSync(binPath, 0o755); } catch (_) {}
+    }
+    if (isMac) {
       try {
-        const content = fs.readFileSync(candidate, "utf8").slice(0, 200);
-        if (isLikelyUsOrNpmWrapper(candidate, content)) continue;
-        return candidate;
-      } catch (_) {
-        return candidate;
-      }
+        spawnSync("xattr", ["-dr", "com.apple.quarantine", binPath], { stdio: "pipe" });
+      } catch (_) {}
     }
   }
+  // On macOS, always ensure binary is executable and not quarantined before spawn (covers existing binaries).
+  if (isMac && binPath) {
+    try {
+      fs.chmodSync(binPath, 0o755);
+      spawnSync("xattr", ["-dr", "com.apple.quarantine", binPath], { stdio: "pipe" });
+    } catch (_) {}
+  }
+  const child = spawn(binPath, [], {
+    detached: true,
+    stdio: "ignore",
+    cwd: binDir,
+    env: { ...process.env, DRIFT_ENGINE_PORT: ENGINE_PORT },
+  });
+  child.unref();
+  return waitForEngine();
+}
 
+// Locate Python drift ONLY in pipx bin dir. Never search PATH (avoids running drift.cmd/drift.ps1/drift.js).
+function findPythonDrift() {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  if (!home) return null;
+  const localBin = path.join(home, ".local", "bin");
+  if (isWindows) {
+    const exe = path.join(localBin, "drift.exe");
+    if (fs.existsSync(exe)) return exe;
+    return null;
+  }
+  const unix = path.join(localBin, "drift");
+  if (fs.existsSync(unix)) return unix;
   return null;
 }
 
-function main() {
+async function main() {
+  const userBackend = process.env.DRIFT_BACKEND_URL;
+  if (!userBackend) {
+    const already = await engineRunning();
+    if (!already) {
+      const started = await ensureEngine().catch((e) => {
+        console.error("drift:", e.message);
+        return false;
+      });
+      if (!started) {
+        console.error("Failed to start drift engine.");
+        console.error("Please check permissions or download the engine manually.");
+        process.exit(1);
+      }
+    }
+  }
+
   const driftPath = findPythonDrift();
-  
   if (!driftPath) {
     console.error(`
 drift is not installed.
 
-Install the Python CLI first:
+Install it with:
 
-  pip install --user pipx
-  pipx ensurepath
   pipx install drift-ml
-
-Then run:
-
-  drift
 `);
     process.exit(1);
   }
 
+  const backendUrl = userBackend || `http://127.0.0.1:${ENGINE_PORT}`;
+  const env = { ...process.env, DRIFT_BACKEND_URL: backendUrl };
+
   const result = spawnSync(driftPath, process.argv.slice(2), {
     stdio: "inherit",
-    env: process.env,
-    shell: isWindows,
+    env,
   });
 
   process.exit(result.status === null ? (result.signal ? 128 + 9 : 1) : result.status);
 }
 
-main();
+main().catch((e) => {
+  console.error("drift:", e.message);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "drift-ml",
-  "version": "0.1.6",
+  "version": "0.1.10",
   "description": "Drift — terminal-first, chat-based AutoML. Same engine as the web app. On first run: downloads and starts the engine locally (never exposes engine source).",
   "bin": {
     "drift": "./bin/drift.js"