ideawave 0.0.103 → 0.0.106

package/README.md

@@ -1,41 +1,19 @@
-# IdeaWave CLI
+# IdeaWave TUI
 
-Run local coding agents from an IdeaWave board.
+Connect your local AI coding agents to a collaborative [IdeaWave](https://ideawave.app) board.
 
-```bash
-npx --yes ideawave@latest
-```
-
-Then open [ideawave.app](https://ideawave.app), choose a board, and start an agent run.
-
-## Requirements
+## Get started
 
-- Node.js 18 or newer
-- Google Chrome for screenshot capture. Browser cards stay inside the app
-  iframe and use the CLI's local browser-kit proxy.
-- At least one supported agent runtime installed and signed in:
-  - Claude Code
-  - Codex CLI
-  - GitHub Copilot CLI
-  - OpenCode
-
-## Commands
+Install and sign in to a supported agent such as Claude Code, Codex, GitHub
+Copilot, or OpenCode. Then launch IdeaWave:
 
 ```bash
-npx --yes ideawave@latest --dev
-npx ideawave --help
-npx ideawave --version
+npx --yes ideawave@latest
+# or
+bunx ideawave@latest
 ```
 
-## Troubleshooting
-
-If a runtime appears unavailable, confirm its command is on your `PATH` and that you are signed in to that tool.
-
-For supported runtimes, the CLI fetches small ACP bridge packages on first use. npm caches them, so later runs are fast. If npm's cache was cleared, keep the CLI running and retry after the bridge downloads again.
+Keep the TUI running, open [ideawave.app](https://ideawave.app), and start
+working with your agent directly on the board.
 
-The CLI advertises `browser-proxy-v6` and `browser-dom-snapshot-v1` so browser
-cards can share one local browser profile, route pages and subresources through
-the local browser-kit proxy, and publish a sanitized read-only fallback for
-collaborators. The normal command
-keeps screenshot capture available. `--dev` skips screenshot-engine setup and
-allows Railway PR previews for browser-card development.
+Requires Node.js 22 or newer. Available for macOS, Linux, and Windows.

package/bin/ideawave.mjs

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+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 { detectLinuxLibc, resolveHostTarget } from "./platform.mjs";
+
+const require = createRequire(import.meta.url);
+const packageRoot = fileURLToPath(new URL("..", import.meta.url));
+
+function fail(message) {
+  process.stderr.write(`${message}\n`);
+  process.exitCode = 1;
+}
+
+function readManifest(filename, label) {
+  try {
+    const value = JSON.parse(readFileSync(filename, "utf8"));
+    if (!value || typeof value !== "object") throw new Error("not an object");
+    return value;
+  } catch (error) {
+    throw new Error(`${label} manifest is unreadable at ${filename}: ${String(error)}`);
+  }
+}
+
+function resolveDistribution() {
+  const manifest = readManifest(path.join(packageRoot, "package.json"), "IdeaWave launcher");
+  if (manifest.name !== "ideawave" || typeof manifest.version !== "string" || !manifest.version) {
+    throw new Error("IdeaWave launcher manifest has an invalid package name or version. Reinstall IdeaWave.");
+  }
+
+  const libc = process.platform === "linux" ? detectLinuxLibc() : null;
+  const target = resolveHostTarget({
+    platform: process.platform,
+    architecture: process.arch,
+    libc,
+  });
+  if (!target) {
+    const tuple =
+      process.platform === "linux"
+        ? `${process.platform}/${process.arch}/${libc ?? "unknown-libc"}`
+        : `${process.platform}/${process.arch}`;
+    throw new Error(
+      `IdeaWave does not have a native host for ${tuple}. Supported targets are macOS and Linux glibc/musl on x64 or arm64, and Windows on x64.`,
+    );
+  }
+
+  let hostManifestPath;
+  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\`.`,
+    );
+  }
+  const hostManifest = readManifest(hostManifestPath, `IdeaWave ${target.key} host`);
+  if (hostManifest.name !== target.packageName) {
+    throw new Error(
+      `IdeaWave host package mismatch: expected ${target.packageName}, found ${hostManifest.name ?? "an unnamed package"}. Reinstall IdeaWave.`,
+    );
+  }
+  if (hostManifest.version !== manifest.version) {
+    throw new Error(
+      `IdeaWave host version mismatch: launcher ${manifest.version}, host ${hostManifest.version ?? "unknown"}. ` +
+        "Clear the package-runner cache and reinstall IdeaWave.",
+    );
+  }
+
+  const hostRoot = path.dirname(hostManifestPath);
+  const executable = path.resolve(hostRoot, ...target.executable.split("/"));
+  if (!isPathInside(hostRoot, executable)) {
+    throw new Error(`IdeaWave host package ${target.packageName} declared an unsafe executable path.`);
+  }
+  try {
+    accessSync(executable, process.platform === "win32" ? constants.F_OK : constants.X_OK);
+  } catch {
+    throw new Error(`IdeaWave's native host is missing or not executable at ${executable}. Reinstall IdeaWave.`);
+  }
+
+  let playwrightManifestPath;
+  try {
+    playwrightManifestPath = require.resolve("playwright-core/package.json");
+  } catch {
+    throw new Error("IdeaWave's Playwright runtime sidecar is missing. Reinstall IdeaWave.");
+  }
+  const playwrightManifest = readManifest(playwrightManifestPath, "IdeaWave Playwright sidecar");
+  const expectedPlaywright = manifest.dependencies?.["playwright-core"];
+  if (typeof expectedPlaywright !== "string" || playwrightManifest.version !== expectedPlaywright) {
+    throw new Error(
+      `IdeaWave Playwright sidecar mismatch: expected ${expectedPlaywright ?? "an exact pinned version"}, ` +
+        `found ${playwrightManifest.version ?? "unknown"}. Reinstall IdeaWave.`,
+    );
+  }
+
+  return {
+    executable,
+    manifest,
+    playwrightRoot: path.dirname(playwrightManifestPath),
+    target,
+  };
+}
+
+const runtimeError = launcherRuntimeError();
+if (runtimeError) {
+  fail(runtimeError);
+} else {
+  try {
+    const distribution = resolveDistribution();
+    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,
+      },
+    });
+
+    const signalHandlers = new Map();
+    for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
+      if (process.platform === "win32" && signal === "SIGHUP") continue;
+      const handler = () => {
+        if (child.exitCode === null && child.signalCode === null) child.kill(signal);
+      };
+      signalHandlers.set(signal, handler);
+      process.on(signal, handler);
+    }
+    const removeSignalHandlers = () => {
+      for (const [signal, handler] of signalHandlers) process.removeListener(signal, handler);
+      signalHandlers.clear();
+    };
+
+    child.once("error", (error) => {
+      removeSignalHandlers();
+      fail(`IdeaWave failed to start its ${distribution.target.key} host: ${String(error)}`);
+    });
+    child.once("exit", (code, signal) => {
+      removeSignalHandlers();
+      if (signal && process.platform !== "win32") {
+        process.kill(process.pid, signal);
+        return;
+      }
+      process.exitCode = code ?? (signal ? 1 : 0);
+    });
+  } catch (error) {
+    fail(error instanceof Error ? error.message : String(error));
+  }
+}

package/bin/launcher-core.mjs

@@ -0,0 +1,35 @@
+import path from "node:path";
+
+export const MINIMUM_NODE_MAJOR = 22;
+
+export function parseNodeMajor(version) {
+  const match = /^v?(\d+)(?:\.|$)/.exec(String(version));
+  return match ? Number(match[1]) : null;
+}
+
+/**
+ * @param {{ nodeVersion?: string, bunVersion?: string | null, runtimeName?: string } | undefined} options
+ */
+export function launcherRuntimeError(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 (runtimeName !== "node") {
+    return `IdeaWave's launcher requires Node.js 22 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 null;
+}
+
+export function isPathInside(root, candidate) {
+  const relative = path.relative(path.resolve(root), path.resolve(candidate));
+  return relative !== "" && relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}

package/bin/platform.mjs

@@ -0,0 +1,100 @@
+const host = (key, options) => Object.freeze({ key, ...options });
+
+const HOSTS = Object.freeze({
+  "darwin-arm64": host("darwin-arm64", {
+    packageName: "ideawave-host-darwin-arm64",
+    bunTarget: "bun-darwin-arm64",
+    os: "darwin",
+    cpu: "arm64",
+    executable: "bin/ideawave-host",
+  }),
+  "darwin-x64": host("darwin-x64", {
+    packageName: "ideawave-host-darwin-x64",
+    bunTarget: "bun-darwin-x64-baseline",
+    os: "darwin",
+    cpu: "x64",
+    executable: "bin/ideawave-host",
+  }),
+  "linux-arm64-glibc": host("linux-arm64-glibc", {
+    packageName: "ideawave-host-linux-arm64",
+    bunTarget: "bun-linux-arm64",
+    os: "linux",
+    cpu: "arm64",
+    libc: "glibc",
+    executable: "bin/ideawave-host",
+  }),
+  "linux-arm64-musl": host("linux-arm64-musl", {
+    packageName: "ideawave-host-linux-arm64-musl",
+    bunTarget: "bun-linux-arm64-musl",
+    os: "linux",
+    cpu: "arm64",
+    libc: "musl",
+    executable: "bin/ideawave-host",
+  }),
+  "linux-x64-glibc": host("linux-x64-glibc", {
+    packageName: "ideawave-host-linux-x64",
+    bunTarget: "bun-linux-x64-baseline",
+    os: "linux",
+    cpu: "x64",
+    libc: "glibc",
+    executable: "bin/ideawave-host",
+  }),
+  "linux-x64-musl": host("linux-x64-musl", {
+    packageName: "ideawave-host-linux-x64-musl",
+    bunTarget: "bun-linux-x64-baseline-musl",
+    os: "linux",
+    cpu: "x64",
+    libc: "musl",
+    executable: "bin/ideawave-host",
+  }),
+  "win32-x64": host("win32-x64", {
+    packageName: "ideawave-host-windows",
+    bunTarget: "bun-windows-x64-baseline",
+    os: "win32",
+    cpu: "x64",
+    executable: "bin/ideawave-host.exe",
+  }),
+});
+
+export const SUPPORTED_HOSTS = HOSTS;
+
+/**
+ * @param {{
+ *   platform?: string,
+ *   report?: { header?: Record<string, unknown> } | null,
+ * } | undefined} options
+ */
+export function detectLinuxLibc(options = {}) {
+  const { platform = process.platform, report = undefined } = options;
+  if (platform !== "linux") return null;
+
+  let runtimeReport = report;
+  if (runtimeReport === undefined) {
+    try {
+      runtimeReport = process.report?.getReport();
+    } catch {
+      return null;
+    }
+  }
+  if (!runtimeReport || typeof runtimeReport !== "object") return null;
+
+  const header = runtimeReport.header;
+  if (!header || typeof header !== "object") return null;
+  if (typeof header.glibcVersionRuntime === "string" && header.glibcVersionRuntime) {
+    return "glibc";
+  }
+
+  // Node's Linux diagnostic report exposes glibcVersionRuntime only on glibc.
+  // A real Linux report with no such field is therefore a musl runtime. An
+  // absent/malformed report remains unknown instead of silently choosing musl.
+  return typeof header.nodejsVersion === "string" || typeof header.nodeVersion === "string" ? "musl" : null;
+}
+
+export function resolveHostTarget({
+  platform = process.platform,
+  architecture = process.arch,
+  libc = platform === "linux" ? detectLinuxLibc({ platform }) : null,
+} = {}) {
+  const key = platform === "linux" ? `${platform}-${architecture}-${libc ?? "unknown"}` : `${platform}-${architecture}`;
+  return HOSTS[key] ?? null;
+}

package/package.json

@@ -1,44 +1,49 @@
 {
   "name": "ideawave",
-  "version": "0.0.103",
-  "description": "IdeaWave CLI",
+  "version": "0.0.106",
+  "description": "IdeaWave local agent host and terminal UI",
   "type": "module",
+  "license": "UNLICENSED",
   "bin": {
-    "ideawave": "dist/index.mjs"
+    "ideawave": "bin/ideawave.mjs"
   },
   "files": [
-    "dist/index.mjs",
+    "bin",
     "README.md"
   ],
+  "publishConfig": {
+    "access": "public"
+  },
   "engines": {
-    "node": ">=18"
+    "node": ">=22"
   },
   "homepage": "https://ideawave.app",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/LoopedIn-ai/ideawave-app.git",
-    "directory": "apps/web/npm/ideawave"
+    "directory": "apps/tui"
   },
   "bugs": {
     "url": "https://github.com/LoopedIn-ai/ideawave-app/issues"
   },
   "keywords": [
     "ideawave",
-    "cli",
+    "tui",
     "agent",
     "whiteboard",
-    "mcp"
+    "mcp",
+    "acp"
   ],
-  "license": "UNLICENSED",
   "dependencies": {
-    "@agentclientprotocol/sdk": "^1.3.0",
-    "@modelcontextprotocol/sdk": "^1.29.0",
-    "css-tree": "^3.2.1",
-    "playwright-core": "1.60.0",
-    "ws": "^8.21.0",
-    "zod": "^4.3.6"
+    "playwright-core": "1.62.1"
   },
-  "publishConfig": {
-    "access": "public"
+  "optionalDependencies": {
+    "ideawave-host-darwin-arm64": "0.0.106",
+    "ideawave-host-darwin-x64": "0.0.106",
+    "ideawave-host-linux-arm64": "0.0.106",
+    "ideawave-host-linux-arm64-musl": "0.0.106",
+    "ideawave-host-linux-x64": "0.0.106",
+    "ideawave-host-linux-x64-musl": "0.0.106",
+    "ideawave-host-windows": "0.0.106"
   }
 }