@olhapi/maestro 0.1.5-rc.14 → 0.1.5-rc.15

package/README.md

@@ -29,7 +29,7 @@ The docs site is organized around the same operator flow the product uses:
 
 ### npm
 
-Install the launcher package:
+Current public npm install on supported platforms:
 
 ```bash
 npm install -g @olhapi/maestro
@@ -43,47 +43,19 @@ npm install -g @olhapi/maestro@next
 
 The installed command name is still `maestro`.
 
-This package no longer ships native platform binaries. It installs a thin host
-launcher that runs Maestro from the published Docker image, so Docker is now a
-first-party runtime requirement for normal CLI use.
+Official npm builds currently cover:
 
-The npm launcher requires Node 24 or newer because it uses the built-in
-`node:sqlite` module to inspect the Maestro database before Docker starts.
+| Platform | Arch | Notes |
+| --- | --- | --- |
+| macOS | arm64 | native package |
+| macOS | x64 | native package |
+| Linux | x64 | glibc only |
+| Linux | arm64 | glibc only |
+| Windows | x64 | native package |
 
-The launcher resolves its runtime image in this order:
+Linux npm packages currently target glibc only. Alpine and other musl-based distros should build from source or use Docker.
 
-- `MAESTRO_IMAGE`
-- the locally pinned image from `~/.maestro/launcher/runtime.json`
-- the npm package version you installed
-
-Pull and pin the latest runtime image explicitly:
-
-```bash
-maestro self-update
-```
-
-Pin a specific image version:
-
-```bash
-maestro self-update --version 0.117.0
-```
-
-Validate the local launcher install, Docker access, and runtime pin:
-
-```bash
-maestro doctor install
-```
-
-### Curl Installer
-
-If you want the same launcher without npm, install it with the repository
-script:
-
-```bash
-curl -fsSL https://raw.githubusercontent.com/olhapi/maestro/main/scripts/install_maestro.sh | sh
-```
-
-### Docker Runtime
+### Docker
 
 Published image:
 
@@ -105,8 +77,7 @@ docker run --rm -v ./repo:/repo -v ./data:/data ghcr.io/olhapi/maestro:latest ru
 
 ### Build From Source
 
-For local development, contributor workflows, or environments where Docker is
-not the right runtime:
+For local development or unsupported platforms:
 
 ```bash
 go build -o maestro ./cmd/maestro
@@ -118,7 +89,7 @@ development package for the standard `make build` / `make test` flow.
 Local contributor Docker build:
 
 ```bash
-docker build -t maestro-local --build-arg CODEX_VERSION="$(./scripts/codex_supported_version.sh)" .
+docker build -t maestro-local .
 ```
 
 ## Quick Start
@@ -161,12 +132,6 @@ When `--db` is omitted, Maestro uses `~/.maestro/maestro.db` by default. When `-
 
 Running `maestro run` without `repo_path` starts the shared daemon for the current database. It does not infer the repo from your shell working directory.
 
-Before Docker starts, `maestro run` performs a one-time preflight pass. When a
-database file exists, the launcher reads the discovered workflow files, resolves
-their `workspace.root` values, and mounts the repo and workspace directories up
-front. If the database file does not exist yet, it skips discovery so fresh
-bootstrap flows still work.
-
 Issue images are stored next to the active database under `assets/images`. With the default database path, that means `~/.maestro/assets/images`. If you run with `--db /custom/path/maestro.db`, image assets move to `/custom/path/assets/images`.
 
 The preview warning on `run` is intentional. Pass `--i-understand-that-this-will-be-running-without-the-usual-guardrails` only when unattended Codex execution is actually what you want.
@@ -417,10 +382,9 @@ Repo-managed Git hooks stay targeted:
 - staged website changes run Astro checks and website tests
 - staged workspace and hook changes run the full `pnpm verify` suite
 - `pnpm verify` runs the JS lint/test/check/smoke flow, npm packaging unit test, and Go build/test/coverage/race gates
-- `pnpm run verify:pre-push` adds real Docker image build smoke, tarball install smoke, local-registry install smoke, curl-installer smoke, the shared retry stress test, and the full retry-safety harness on top of `pnpm verify`
-- `pnpm run verify:ci` is the lean GitHub Actions gate: web verification, launcher packaging tests, and `go test ./...`
+- `pnpm run verify:pre-push` adds current-host npm packaging smoke, the shared retry stress test, and the full retry-safety harness on top of `pnpm verify`
 - package-scoped root commands such as `pnpm run frontend:test` and `pnpm run website:build` now go through `turbo --filter=...` so they benefit from task caching too
-- `pre-push` now runs `pnpm run verify:pre-push`, while GitHub Actions stays on the smaller `pnpm run verify:ci` gate
+- `pre-push` now runs `pnpm run verify:pre-push`, leaving GitHub Actions with the cross-platform packaging matrix and registry smoke coverage
 
 ## License
 

package/bin/maestro.js

@@ -1,15 +1,26 @@
 #!/usr/bin/env node
 
-const nodeMajor = Number.parseInt(process.versions.node.split(".")[0], 10);
-if (!Number.isInteger(nodeMajor) || nodeMajor < 24) {
-  process.stderr.write(`Maestro's npm launcher requires Node 24 or newer; found ${process.versions.node}\n`);
-  process.exit(1);
-}
-
-const { main } = require("../lib/cli");
+const { spawnSync } = require("node:child_process");
+const { getExePath } = require("../lib/get-exe-path");
 
-main(process.argv.slice(2)).catch((error) => {
+let exePath;
+try {
+  exePath = getExePath();
+} catch (error) {
   const message = error instanceof Error ? error.message : String(error);
   process.stderr.write(`${message}\n`);
   process.exit(1);
-});
+}
+
+const result = spawnSync(exePath, process.argv.slice(2), { stdio: "inherit" });
+if (result.error) {
+  process.stderr.write(`${result.error.message}\n`);
+  process.exit(1);
+}
+if (typeof result.status === "number") {
+  process.exit(result.status);
+}
+if (result.signal) {
+  process.stderr.write(`maestro terminated with signal ${result.signal}\n`);
+}
+process.exit(1);

package/lib/get-exe-path.js

@@ -0,0 +1,118 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+const supportedTargets = Object.freeze({
+  "darwin:arm64": {
+    packageName: "@olhapi/maestro-darwin-arm64",
+    label: "darwin/arm64",
+  },
+  "darwin:x64": {
+    packageName: "@olhapi/maestro-darwin-x64",
+    label: "darwin/x64",
+  },
+  "linux:x64": {
+    packageName: "@olhapi/maestro-linux-x64-gnu",
+    label: "linux/x64 (glibc)",
+  },
+  "linux:arm64": {
+    packageName: "@olhapi/maestro-linux-arm64-gnu",
+    label: "linux/arm64 (glibc)",
+  },
+  "win32:x64": {
+    packageName: "@olhapi/maestro-win32-x64",
+    label: "win32/x64",
+  },
+});
+
+function resolveTarget(platform, arch) {
+  return supportedTargets[`${platform}:${arch}`] ?? null;
+}
+
+function supportedTargetSummary() {
+  return Object.values(supportedTargets)
+    .map((target) => target.label)
+    .join(", ");
+}
+
+function readProcessReport() {
+  if (!process.report || typeof process.report.getReport !== "function") {
+    return null;
+  }
+  try {
+    return process.report.getReport();
+  } catch {
+    return null;
+  }
+}
+
+function hasGlibcRuntime(report) {
+  const version = report && report.header && report.header.glibcVersionRuntime;
+  return typeof version === "string" && version.trim() !== "";
+}
+
+function buildInstallError(platform, arch, expectedPackageName, report) {
+  const parts = [
+    `Maestro npm install supports ${supportedTargetSummary()}.`,
+    `Could not resolve a packaged binary for ${platform}/${arch}.`,
+  ];
+  if (expectedPackageName) {
+    parts.push(`Expected package: ${expectedPackageName}.`);
+  }
+  if (platform === "linux") {
+    if (!hasGlibcRuntime(report)) {
+      parts.push("Linux npm packages currently target glibc only. Alpine and other musl-based distros should build from source or use Docker.");
+    } else {
+      parts.push("If your install is on glibc Linux, reinstalling can restore a missing optional dependency. Alpine and other musl-based distros should build from source or use Docker.");
+    }
+  } else {
+    parts.push("If your platform is unsupported, build from source or use Docker.");
+  }
+  return parts.join(" ");
+}
+
+function resolveExePath(options = {}) {
+  const platform = options.platform ?? process.platform;
+  const arch = options.arch ?? process.arch;
+  const pathModule = options.pathModule ?? path;
+  const resolvePackageJson =
+    options.resolvePackageJson ??
+    ((packageName) => require.resolve(`${packageName}/package.json`));
+  const existsSync = options.existsSync ?? fs.existsSync;
+  const report = options.report ?? readProcessReport();
+
+  const target = resolveTarget(platform, arch);
+  if (!target) {
+    throw new Error(buildInstallError(platform, arch, null, report));
+  }
+
+  let packageJsonPath;
+  try {
+    packageJsonPath = resolvePackageJson(target.packageName);
+  } catch {
+    throw new Error(buildInstallError(platform, arch, target.packageName, report));
+  }
+
+  let exePath = pathModule.join(
+    pathModule.dirname(packageJsonPath),
+    "lib",
+    platform === "win32" ? "maestro.exe" : "maestro",
+  );
+  if (platform === "win32" && exePath.length >= 248 && !exePath.startsWith("\\\\?\\")) {
+    exePath = `\\\\?\\${exePath}`;
+  }
+  if (!existsSync(exePath)) {
+    throw new Error(`Executable not found in ${target.packageName}: ${exePath}`);
+  }
+  return exePath;
+}
+
+function getExePath() {
+  return resolveExePath();
+}
+
+module.exports = {
+  buildInstallError,
+  getExePath,
+  resolveExePath,
+  resolveTarget,
+};

package/package.json

@@ -1,28 +1,24 @@
 {
   "name": "@olhapi/maestro",
-  "version": "0.1.5-rc.14",
-  "description": "Maestro Docker-backed launcher for global npm installation",
+  "version": "0.1.5-rc.15",
+  "description": "Maestro CLI packaged for global npm installation",
   "license": "MIT",
-  "engines": {
-    "node": ">=24"
-  },
   "bin": {
-    "maestro": "bin/maestro"
+    "maestro": "bin/maestro.js"
   },
   "files": [
-    "bin/maestro",
-    "bin/maestro.cmd",
-    "bin/maestro.ps1",
     "bin/maestro.js",
-    "lib/browser.js",
-    "lib/cli.js",
-    "lib/docker-plan.js",
-    "lib/install-skills.js",
-    "lib/runtime-state.js",
-    "share/skills/maestro",
+    "lib/get-exe-path.js",
     "LICENSE",
     "README.md"
   ],
+  "optionalDependencies": {
+    "@olhapi/maestro-darwin-arm64": "0.1.5-rc.15",
+    "@olhapi/maestro-darwin-x64": "0.1.5-rc.15",
+    "@olhapi/maestro-linux-x64-gnu": "0.1.5-rc.15",
+    "@olhapi/maestro-linux-arm64-gnu": "0.1.5-rc.15",
+    "@olhapi/maestro-win32-x64": "0.1.5-rc.15"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/olhapi/maestro.git"

package/bin/maestro

@@ -1,16 +0,0 @@
-#!/usr/bin/env sh
-
-set -eu
-
-SCRIPT_PATH="$0"
-while [ -L "$SCRIPT_PATH" ]; do
-  LINK_TARGET=$(readlink "$SCRIPT_PATH")
-  case "$LINK_TARGET" in
-    /*) SCRIPT_PATH="$LINK_TARGET" ;;
-    *) SCRIPT_PATH=$(dirname "$SCRIPT_PATH")/$LINK_TARGET ;;
-  esac
-done
-
-SCRIPT_DIR=$(CDPATH= cd -- "$(dirname "$SCRIPT_PATH")" && pwd)
-NODE_BIN="${MAESTRO_NODE_BIN:-node}"
-exec "$NODE_BIN" "$SCRIPT_DIR/maestro.js" "$@"

package/bin/maestro.cmd

@@ -1,8 +0,0 @@
-@ECHO OFF
-SETLOCAL
-SET SCRIPT_DIR=%~dp0
-IF DEFINED MAESTRO_NODE_BIN (
-  "%MAESTRO_NODE_BIN%" "%SCRIPT_DIR%maestro.js" %*
-) ELSE (
-  node "%SCRIPT_DIR%maestro.js" %*
-)

package/bin/maestro.ps1

@@ -1,4 +0,0 @@
-$ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
-$NodeBin = if ($env:MAESTRO_NODE_BIN) { $env:MAESTRO_NODE_BIN } else { "node" }
-& $NodeBin (Join-Path $ScriptDir "maestro.js") @args
-exit $LASTEXITCODE

package/lib/browser.js

@@ -1,79 +0,0 @@
-const { spawn } = require("node:child_process");
-
-const DEFAULT_BROWSER_TIMEOUT_MS = 3000;
-const DEFAULT_BROWSER_POLL_INTERVAL_MS = 50;
-
-function terminalsInteractive(streams = process) {
-  return Boolean(streams.stdout && streams.stdout.isTTY && streams.stderr && streams.stderr.isTTY);
-}
-
-function browserOpenDisabled(env = process.env) {
-  const value = env && env.MAESTRO_DISABLE_BROWSER_OPEN;
-  return typeof value === "string" && value.trim() !== "";
-}
-
-function browserCommandFor(platform, url) {
-  switch (platform) {
-    case "darwin":
-      return ["open", [url]];
-    case "linux":
-    case "freebsd":
-    case "openbsd":
-    case "netbsd":
-      return ["xdg-open", [url]];
-    case "win32":
-      return ["rundll32", ["url.dll,FileProtocolHandler", url]];
-    default:
-      throw new Error(`unsupported platform ${platform}`);
-  }
-}
-
-async function waitForHealthy(url, options = {}) {
-  const timeoutMs = options.timeoutMs || DEFAULT_BROWSER_TIMEOUT_MS;
-  const pollIntervalMs = options.pollIntervalMs || DEFAULT_BROWSER_POLL_INTERVAL_MS;
-  const fetchImpl = options.fetchImpl || fetch;
-  const deadline = Date.now() + timeoutMs;
-  let lastError = null;
-
-  while (Date.now() < deadline) {
-    try {
-      const response = await fetchImpl(url);
-      if (response.ok) {
-        await response.arrayBuffer();
-        return;
-      }
-      lastError = new Error(`health returned ${response.status}`);
-    } catch (error) {
-      lastError = error;
-    }
-    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
-  }
-
-  if (lastError) {
-    throw lastError;
-  }
-  throw new Error(`timed out waiting for ${url}`);
-}
-
-async function openDashboardWhenReady(baseURL, options = {}) {
-  if (!baseURL || browserOpenDisabled(options.env || process.env) || !terminalsInteractive(options.streams || process)) {
-    return;
-  }
-
-  const normalizedBaseURL = String(baseURL).replace(/\/+$/, "");
-  await waitForHealthy(`${normalizedBaseURL}/health`, options);
-  const [command, args] = browserCommandFor(options.platform || process.platform, normalizedBaseURL);
-  const child = spawn(command, args, {
-    detached: true,
-    stdio: "ignore",
-  });
-  child.unref();
-}
-
-module.exports = {
-  browserOpenDisabled,
-  browserCommandFor,
-  openDashboardWhenReady,
-  terminalsInteractive,
-  waitForHealthy,
-};