ideawave 0.0.107 → 0.0.109

package/README.md

@@ -16,4 +16,5 @@ bunx ideawave@latest
 Keep the TUI running, open [ideawave.app](https://ideawave.app), and start
 working with your agent directly on the board.
 
-Requires Node.js 22 or newer. Available for macOS, Linux, and Windows.
+Requires Node.js 22 or newer, or Bun 1.2.16 or newer (no Node needed).
+Available for macOS, Linux, and Windows.

package/bin/ideawave.mjs

@@ -4,7 +4,7 @@ import { accessSync, constants, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { isPathInside, launcherRuntimeError } from "./launcher-core.mjs";
+import { corruptedHostLockEvidence, detectLauncherRuntime, isPathInside } from "./launcher-core.mjs";
 import { detectLinuxLibc, resolveHostTarget } from "./platform.mjs";
 
 const require = createRequire(import.meta.url);
@@ -25,6 +25,40 @@ function readManifest(filename, label) {
   }
 }
 
+function missingHostError(target, version) {
+  const base = `IdeaWave's ${target.key} host package is missing (expected ${target.packageName}@${version}).`;
+  const reinstall =
+    `Reinstall with optional dependencies enabled, for example \`npm install ideawave@${version} --include=optional\`.`;
+  if (path.basename(path.resolve(packageRoot, "..")) !== "node_modules") {
+    return `${base} ${reinstall}`;
+  }
+  const treeRoot = path.resolve(packageRoot, "..", "..");
+  let lockRaw;
+  try {
+    lockRaw = readFileSync(path.join(treeRoot, "package-lock.json"), "utf8");
+  } catch {
+    return `${base} ${reinstall}`;
+  }
+  if (!corruptedHostLockEvidence(lockRaw, target.packageName)) {
+    return `${base} ${reinstall}`;
+  }
+  if (treeRoot.split(path.sep).includes("_npx")) {
+    const removeExample = process.platform === "win32"
+      ? `\`rmdir /s /q "${treeRoot}"\``
+      : `\`rm -rf "${treeRoot}"\``;
+    return (
+      `${base} A known npm bug (https://github.com/npm/cli/issues/4828) corrupted this package-runner cache entry ` +
+      `while updating IdeaWave: its lockfile resolved IdeaWave's host for a different platform. ` +
+      `Delete the cache entry with ${removeExample}, then run \`npx ideawave\` again.`
+    );
+  }
+  return (
+    `${base} A known npm bug (https://github.com/npm/cli/issues/4828) left this installation's package-lock.json ` +
+    `resolved for a different platform. Delete node_modules and package-lock.json in ${treeRoot}, ` +
+    `then reinstall with \`npm install ideawave@${version} --include=optional\`.`
+  );
+}
+
 function resolveDistribution() {
   const manifest = readManifest(path.join(packageRoot, "package.json"), "IdeaWave launcher");
   if (manifest.name !== "ideawave" || typeof manifest.version !== "string" || !manifest.version) {
@@ -51,10 +85,7 @@ function resolveDistribution() {
   try {
     hostManifestPath = require.resolve(`${target.packageName}/package.json`);
   } catch {
-    throw new Error(
-      `IdeaWave's ${target.key} host package is missing (expected ${target.packageName}@${manifest.version}). ` +
-        `Reinstall with optional dependencies enabled, for example \`npm install ideawave@${manifest.version} --include=optional\`.`,
-    );
+    throw new Error(missingHostError(target, manifest.version));
   }
   const hostManifest = readManifest(hostManifestPath, `IdeaWave ${target.key} host`);
   if (hostManifest.name !== target.packageName) {
@@ -103,23 +134,31 @@ function resolveDistribution() {
   };
 }
 
-const runtimeError = launcherRuntimeError();
-if (runtimeError) {
-  fail(runtimeError);
+const runtime = detectLauncherRuntime();
+if (runtime.error) {
+  fail(runtime.error);
 } else {
   try {
     const distribution = resolveDistribution();
+    // Start from a copy so stale launcher-contract values and a leaked
+    // BUN_BE_BUN (which would make the compiled host act as the bun CLI
+    // instead of IdeaWave) never reach the host or its children.
+    const env = { ...process.env };
+    delete env.BUN_BE_BUN;
+    delete env.IDEAWAVE_LAUNCHER_NODE_PATH;
+    delete env.IDEAWAVE_LAUNCHER_NODE_VERSION;
+    env.IDEAWAVE_DISTRIBUTION_MODE = "standalone";
+    env.IDEAWAVE_LAUNCHER_RUNTIME = runtime.kind;
+    if (runtime.kind === "node") {
+      env.IDEAWAVE_LAUNCHER_NODE_PATH = process.execPath;
+      env.IDEAWAVE_LAUNCHER_NODE_VERSION = process.version;
+    }
+    env.IDEAWAVE_PLAYWRIGHT_CORE_PATH = distribution.playwrightRoot;
+    env.IDEAWAVE_PRODUCT_VERSION = distribution.manifest.version;
     const child = spawn(distribution.executable, process.argv.slice(2), {
       cwd: process.cwd(),
       stdio: "inherit",
-      env: {
-        ...process.env,
-        IDEAWAVE_DISTRIBUTION_MODE: "standalone",
-        IDEAWAVE_LAUNCHER_NODE_PATH: process.execPath,
-        IDEAWAVE_LAUNCHER_NODE_VERSION: process.version,
-        IDEAWAVE_PLAYWRIGHT_CORE_PATH: distribution.playwrightRoot,
-        IDEAWAVE_PRODUCT_VERSION: distribution.manifest.version,
-      },
+      env,
     });
 
     const signalHandlers = new Map();

package/bin/launcher-core.mjs

@@ -1,32 +1,99 @@
 import path from "node:path";
 
 export const MINIMUM_NODE_MAJOR = 22;
+// BUN_BE_BUN self-execution of the compiled host exists since Bun 1.2.16;
+// older Bun launchers predate the runtime contract the host relies on.
+export const MINIMUM_BUN_VERSION = "1.2.16";
 
 export function parseNodeMajor(version) {
   const match = /^v?(\d+)(?:\.|$)/.exec(String(version));
   return match ? Number(match[1]) : null;
 }
 
+export function parseBunVersion(version) {
+  const match = /^(\d+)\.(\d+)\.(\d+)/.exec(String(version));
+  return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
+}
+
+function bunVersionAtLeast(version, minimum) {
+  const actual = parseBunVersion(version);
+  const required = parseBunVersion(minimum);
+  if (!actual || !required) return false;
+  for (let index = 0; index < 3; index += 1) {
+    if (actual[index] !== required[index]) return actual[index] > required[index];
+  }
+  return true;
+}
+
 /**
+ * Identify the JavaScript runtime executing the launcher. Supported launch
+ * paths are Node.js 22+ (`npx ideawave`, or `bunx ideawave` with Node
+ * installed) and Bun 1.2.16+ (`bunx ideawave` on a Bun-only machine, or
+ * `bunx --bun ideawave`). Anything else yields a `kind: null` error result.
+ *
  * @param {{ nodeVersion?: string, bunVersion?: string | null, runtimeName?: string } | undefined} options
+ * @returns {{ kind: "node" | "bun" | null, version: string, error: string | null }}
  */
-export function launcherRuntimeError(options = {}) {
+export function detectLauncherRuntime(options = {}) {
   const {
     nodeVersion = process.version,
     bunVersion = process.versions?.bun,
     runtimeName = process.release?.name,
   } = options;
   if (bunVersion) {
-    return "IdeaWave's launcher must run on Node.js, not Bun. Run `bunx ideawave` without `--bun`, or use `npx ideawave`.";
+    if (!bunVersionAtLeast(bunVersion, MINIMUM_BUN_VERSION)) {
+      return {
+        kind: null,
+        version: String(bunVersion),
+        error:
+          `IdeaWave requires Bun ${MINIMUM_BUN_VERSION} or newer when launched with Bun; this launcher is using ${bunVersion}. ` +
+          "Run `bun upgrade`, or use `npx ideawave` with Node.js 22 or newer.",
+      };
+    }
+    return { kind: "bun", version: String(bunVersion), error: null };
   }
   if (runtimeName !== "node") {
-    return `IdeaWave's launcher requires Node.js 22 or newer; detected ${runtimeName || "an unknown runtime"}.`;
+    return {
+      kind: null,
+      version: "",
+      error:
+        `IdeaWave's launcher requires Node.js ${MINIMUM_NODE_MAJOR} or newer or Bun ${MINIMUM_BUN_VERSION} or newer; ` +
+        `detected ${runtimeName || "an unknown runtime"}.`,
+    };
   }
   const major = parseNodeMajor(nodeVersion);
   if (major === null || major < MINIMUM_NODE_MAJOR) {
-    return `IdeaWave requires Node.js 22 or newer; this launcher is using ${nodeVersion || "an unknown version"}.`;
+    return {
+      kind: null,
+      version: String(nodeVersion ?? ""),
+      error:
+        `IdeaWave requires Node.js ${MINIMUM_NODE_MAJOR} or newer; this launcher is using ${nodeVersion || "an unknown version"}. ` +
+        "Upgrade Node.js, or launch with Bun 1.2.16 or newer via `bunx ideawave`.",
+    };
+  }
+  return { kind: "node", version: String(nodeVersion), error: null };
+}
+
+/**
+ * npm's arborist can update an existing install (notably an `_npx` cache
+ * entry) while keeping a package-lock that resolved IdeaWave's platform host
+ * for a different machine, so the matching host is silently never installed
+ * (https://github.com/npm/cli/issues/4828). A lockfile that lists host
+ * packages but not the required one is direct evidence of that corruption.
+ *
+ * @param {string} lockRaw
+ * @param {string} packageName
+ */
+export function corruptedHostLockEvidence(lockRaw, packageName) {
+  try {
+    const lock = JSON.parse(lockRaw);
+    const packages = lock && typeof lock === "object" ? lock.packages : null;
+    if (!packages || typeof packages !== "object") return false;
+    const hosts = Object.keys(packages).filter((key) => key.startsWith("node_modules/ideawave-host-"));
+    return hosts.length > 0 && !hosts.includes(`node_modules/${packageName}`);
+  } catch {
+    return false;
   }
-  return null;
 }
 
 export function isPathInside(root, candidate) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ideawave",
-  "version": "0.0.107",
+  "version": "0.0.109",
   "description": "IdeaWave local agent host and terminal UI",
   "type": "module",
   "license": "UNLICENSED",
@@ -38,12 +38,12 @@
     "playwright-core": "1.62.1"
   },
   "optionalDependencies": {
-    "ideawave-host-darwin-arm64": "0.0.107",
-    "ideawave-host-darwin-x64": "0.0.107",
-    "ideawave-host-linux-arm64": "0.0.107",
-    "ideawave-host-linux-arm64-musl": "0.0.107",
-    "ideawave-host-linux-x64": "0.0.107",
-    "ideawave-host-linux-x64-musl": "0.0.107",
-    "ideawave-host-windows": "0.0.107"
+    "ideawave-host-darwin-arm64": "0.0.109",
+    "ideawave-host-darwin-x64": "0.0.109",
+    "ideawave-host-linux-arm64": "0.0.109",
+    "ideawave-host-linux-arm64-musl": "0.0.109",
+    "ideawave-host-linux-x64": "0.0.109",
+    "ideawave-host-linux-x64-musl": "0.0.109",
+    "ideawave-host-windows": "0.0.109"
   }
 }