trymeanwhile 1.1.0 → 1.2.1

package/bin/meanwhile.js

@@ -1,10 +1,9 @@
 #!/usr/bin/env node
-// Node reimplementation of install.sh/install.ps1/install_copilot.sh -- one
-// script instead of three, since Node itself is already cross-platform and
-// can detect which tool(s) are actually installed. Behavior is kept in
-// lockstep with those scripts (same install dir, same settings.json shape,
-// same non-fatal certifi step) so every installer produces an identical
-// result regardless of which one someone happens to run.
+// The `npx trymeanwhile` entry point -- one cross-platform script that
+// detects which tool(s) are actually installed and wires them up. The
+// status line it wires in (statusline.js) runs on Node too, not Python:
+// Node is already guaranteed present since npx can't invoke this script
+// without it, so there's no second runtime to find, verify, or fail on.
 
 const fs = require("fs");
 const os = require("os");
@@ -24,13 +23,6 @@ function commandExists(cmd) {
   return spawnSync(cmd, ["--version"], { stdio: "ignore" }).status === 0;
 }
 
-function findPython() {
-  for (const candidate of ["python3", "python", "py"]) {
-    if (commandExists(candidate)) return candidate;
-  }
-  return null;
-}
-
 function openUrl(url) {
   const cmd =
     process.platform === "darwin" ? `open "${url}"`
@@ -39,37 +31,71 @@ function openUrl(url) {
   exec(cmd, () => {});
 }
 
-async function ensureCertifi(python) {
-  const hasCertifi = spawnSync(python, ["-c", "import certifi"], { stdio: "ignore" }).status === 0;
-  if (hasCertifi) return;
-  // certifi is a nice-to-have, not a hard requirement -- both status line
-  // scripts fall back to the system's own certificate store if it's
-  // missing. Never let a failed pip install here take down the install.
-  log("installing certifi (helps with HTTPS, not required)...");
-  const pipAttempts = [
-    ["-m", "pip", "install", "--quiet", "certifi"],
-    ["-m", "pip", "install", "--quiet", "--user", "certifi"],
-    ["-m", "pip", "install", "--quiet", "--break-system-packages", "certifi"],
-  ];
-  const installed = pipAttempts.some((args) => spawnSync(python, args, { stdio: "ignore" }).status === 0);
-  if (!installed) log("couldn't install certifi, continuing without it (falls back automatically)");
-}
-
 async function downloadTo(remoteName, localPath) {
   const res = await fetch(`${SERVER}/${remoteName}`);
   if (!res.ok) throw new Error(`couldn't download ${remoteName} (${res.status})`);
   fs.writeFileSync(localPath, await res.text());
 }
 
-function wireSettings(settingsPath, python, scriptPath) {
+function wireSettings(settingsPath, runtime, scriptPath) {
   fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
   const settings = fs.existsSync(settingsPath) ? JSON.parse(fs.readFileSync(settingsPath, "utf8") || "{}") : {};
-  settings.statusLine = { type: "command", command: `${python} "${scriptPath}"` };
+  settings.statusLine = { type: "command", command: `"${runtime}" "${scriptPath}"` };
   fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
   log(`wired into ${settingsPath}`);
 }
 
+// Wraps any long-running shell command (npm install, docker build, terraform
+// apply, ...) and shows the same disclosed line the Claude Code/Copilot
+// status lines show -- reusing the exact same /line endpoint and billing
+// mechanism, just from a different trigger than an editor hook. The server
+// only bills a line if it stayed on screen >= BILLABLE_THRESHOLD (10s), so
+// this polls every 15s -- fast enough to feel alive, slow enough that real
+// polls actually bill instead of always resetting the timer on each other.
+async function wrapCommand(args) {
+  const cmdArgs = args[0] === "--" ? args.slice(1) : args;
+  if (cmdArgs.length === 0) {
+    log("usage: npx trymeanwhile wrap -- <command> [args...]");
+    log("example: npx trymeanwhile wrap -- npm install");
+    process.exit(1);
+  }
+
+  fs.mkdirSync(STATE_DIR, { recursive: true });
+  const idPath = path.join(STATE_DIR, "install_id");
+  if (!fs.existsSync(idPath)) {
+    fs.writeFileSync(idPath, crypto.randomUUID(), { mode: 0o600 });
+  }
+  const installId = fs.readFileSync(idPath, "utf8").trim();
+
+  const { spawn } = require("child_process");
+  const child = spawn(cmdArgs[0], cmdArgs.slice(1), { stdio: "inherit", shell: process.platform === "win32" });
+
+  let stopped = false;
+  (async function pollLoop() {
+    while (!stopped) {
+      try {
+        const res = await fetch(`${SERVER}/line?id=${installId}&event=cli_wrap`);
+        if (res.ok) {
+          const data = await res.json();
+          process.stderr.write(`\nmeanwhile: ${data.line}\n`);
+        }
+      } catch (e) {}
+      await new Promise((r) => setTimeout(r, 15000));
+    }
+  })();
+
+  child.on("exit", (code) => {
+    stopped = true;
+    process.exit(code === null ? 1 : code);
+  });
+}
+
 async function main() {
+  if (process.argv[2] === "wrap") {
+    await wrapCommand(process.argv.slice(3));
+    return;
+  }
+
   log(`installing to ${INSTALL_DIR}`);
   fs.mkdirSync(INSTALL_DIR, { recursive: true });
   fs.mkdirSync(STATE_DIR, { recursive: true });
@@ -85,13 +111,14 @@ async function main() {
   }
   const installId = fs.readFileSync(idPath, "utf8").trim();
 
-  const python = findPython();
-  if (!python) {
-    log("couldn't find Python on your PATH.");
-    log("install it from https://python.org, then run `npx trymeanwhile` again.");
-    process.exit(1);
-  }
-  await ensureCertifi(python);
+  // Node, not Python: this script is already running under Node (it can't
+  // not be -- npx just invoked it), so there is no second runtime to find
+  // or verify. process.execPath is the absolute path to the exact node
+  // binary running right now, more robust than trusting a bare `node` on
+  // PATH (some distros only ship `nodejs`). This used to hard-require
+  // python3/python/py on top of Node and fail the whole install for
+  // anyone without it -- a real dead stop, not a cosmetic gap.
+  const node = process.execPath;
 
   // Wire whichever tool(s) are actually on this machine, so the same
   // command works everywhere instead of a different one per tool. Claude
@@ -99,20 +126,20 @@ async function main() {
   // built for -- and Copilot CLI is wired too if it's detected on PATH.
   const wireCopilot = commandExists("copilot");
 
-  const claudeScript = path.join(INSTALL_DIR, "statusline.py");
-  await downloadTo("statusline.py", claudeScript);
-  wireSettings(path.join(os.homedir(), ".claude", "settings.json"), python, claudeScript);
+  const claudeScript = path.join(INSTALL_DIR, "statusline.js");
+  await downloadTo("statusline.js", claudeScript);
+  wireSettings(path.join(os.homedir(), ".claude", "settings.json"), node, claudeScript);
 
   if (wireCopilot) {
-    const copilotScript = path.join(INSTALL_DIR, "copilot_statusline.py");
-    await downloadTo("copilot_statusline.py", copilotScript);
-    wireSettings(path.join(os.homedir(), ".copilot", "settings.json"), python, copilotScript);
+    const copilotScript = path.join(INSTALL_DIR, "copilot_statusline.js");
+    await downloadTo("copilot_statusline.js", copilotScript);
+    wireSettings(path.join(os.homedir(), ".copilot", "settings.json"), node, copilotScript);
     log("Copilot CLI detected -- wired that too, same install ID, earnings share one balance.");
   }
 
   log("installed. Restart Claude Code (and Copilot CLI, if wired) to see it live.");
   log("to check earnings or register a payout email later, run:");
-  log(`  ${python} "${claudeScript}" --claim`);
+  log(`  "${node}" "${claudeScript}" --claim`);
 
   // Open the browser straight to the claim page -- same pattern as
   // `gh auth login` / `vercel login` / `wrangler login`. This is the only

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trymeanwhile",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "Get paid while your AI coding agent thinks. Wires a disclosed status line into Claude Code / Copilot CLI.",
   "bin": {
     "meanwhile": "bin/meanwhile.js"