@tomasko/podcomp 0.0.0-stage → 0.1.1

package/README.md

@@ -1,3 +1,95 @@
-# Temporary Holding Version
+# `@tomasko/podcomp`
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The npm launcher for [`podcomp`](https://github.com/tomasky/podcomp) — a
+Compose Spec implementation that runs on Podman, written in MoonBit.
+
+```sh
+npm install -g @tomasko/podcomp
+podcomp up
+podcomp ps
+podcomp logs -f web
+podcomp down
+```
+
+`podcomp` reads the same `compose.yaml` / `compose.yml` / `docker-compose.yml`
+files Docker Compose reads, merges and interpolates them, and drives `podman`
+directly. There is no daemon, no Python runtime and no background state: one
+native binary.
+
+## What this package contains
+
+A small launcher, not the binary itself. On the first `podcomp` run it
+downloads the prebuilt native binary for your platform from the GitHub release
+and caches it. Nothing is downloaded at install time.
+
+| Platform | Target |
+| --- | --- |
+| Linux x86-64 | `podcomp-linux-x86_64` (static, musl) |
+| Linux arm64 | `podcomp-linux-aarch64` (static, musl) |
+| macOS Apple silicon | `podcomp-darwin-aarch64` |
+
+The Linux builds are linked statically against musl, so they run on any
+distribution regardless of its glibc version.
+
+## Why there is no `postinstall`
+
+This package deliberately declares **no install script**. Since npm 12,
+dependency lifecycle scripts are blocked unless the user opts in; and pnpm 12
+fails a *project* install outright with `ERR_PNPM_IGNORED_BUILDS` when a
+dependency declares one:
+
+```console
+$ pnpm add @tomasko/podcomp
+Error: ERR_PNPM_IGNORED_BUILDS
+  × adding a new package
+  ╰─▶ Ignored build scripts: @tomasko/podcomp@0.1.1
+```
+
+Downloading lazily from `bin/podcomp.js` sidesteps all of it: it works under
+npm, pnpm, yarn, bun, `npx`, and `--ignore-scripts`, because it is an ordinary
+command rather than an install hook.
+
+## Cache location
+
+The downloaded binary is kept outside the package, so reinstalling or clearing
+`node_modules` never triggers a second download:
+
+| Platform | Path |
+| --- | --- |
+| Linux | `$XDG_CACHE_HOME/podcomp` or `~/.cache/podcomp` |
+| macOS | `~/Library/Caches/podcomp` |
+
+## Environment variables
+
+| Variable | Effect |
+| --- | --- |
+| `PODCOMP_BINARY` | Run this binary and never download anything |
+| `PODCOMP_CACHE_DIR` | Where to keep the downloaded binary |
+| `PODCOMP_VERSION` | Release version to fetch (default: this package's version) |
+| `PODCOMP_REPO` | `owner/repo` to download from (default: `tomasky/podcomp`) |
+| `PODCOMP_DOWNLOAD_BASE` | Full base URL, overriding `PODCOMP_REPO`/`PODCOMP_VERSION` |
+| `PODCOMP_FORCE_DOWNLOAD` | Re-download even if the cached binary exists |
+| `PODCOMP_SKIP_DOWNLOAD` | Never download; fail if the binary is absent |
+| `PODCOMP_NO_VERIFY` | Skip SHA-256 verification of the download |
+
+`PODCOMP_DOWNLOAD_BASE` and `PODCOMP_REPO` are there for forks, private mirrors
+and air-gapped installs:
+
+```sh
+PODCOMP_DOWNLOAD_BASE=https://internal.example.com/podcomp npm install -g @tomasko/podcomp
+```
+
+## Other ways to install
+
+```sh
+# Installer script (no Node.js required)
+curl -LsSf https://raw.githubusercontent.com/tomasky/podcomp/main/install.sh | bash
+
+# Build from source
+git clone https://github.com/tomasky/podcomp && cd podcomp
+moon build --target native --release
+```
+
+## License
+
+Apache-2.0

package/bin/podcomp.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+// Launcher for the native `podcomp` binary.
+//
+// The package ships no install script, so this is where the binary is fetched:
+// on the first run, straight into the user cache. Arguments, stdio, signals and
+// the exit code are all forwarded to the real binary.
+"use strict";
+
+const { spawn } = require("child_process");
+const { ensureBinary } = require("../lib.js");
+
+const SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP", "SIGQUIT"];
+
+async function main() {
+  let binary;
+  try {
+    binary = await ensureBinary({
+      log: (line) => process.stderr.write(`${line}\n`),
+    });
+  } catch (err) {
+    process.stderr.write(`podcomp: ${err.message}\n`);
+    process.exit(1);
+  }
+
+  const child = spawn(binary, process.argv.slice(2), { stdio: "inherit" });
+
+  // Forward signals so Ctrl-C reaches the CLI rather than killing only the
+  // wrapper and orphaning the child.
+  for (const signal of SIGNALS) {
+    process.on(signal, () => {
+      try {
+        child.kill(signal);
+      } catch {
+        /* already gone */
+      }
+    });
+  }
+
+  child.on("error", (err) => {
+    process.stderr.write(`podcomp: failed to launch ${binary}: ${err.message}\n`);
+    process.exit(1);
+  });
+
+  child.on("exit", (code, signal) => {
+    if (signal) {
+      // Mirror the child's death by signal instead of inventing an exit code.
+      process.removeAllListeners(signal);
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exit(code === null ? 1 : code);
+  });
+}
+
+main().catch((err) => {
+  process.stderr.write(`podcomp: ${err && err.stack ? err.stack : err}\n`);
+  process.exit(1);
+});

package/lib.js

@@ -0,0 +1,270 @@
+"use strict";
+
+// Shared logic for the npm launcher: work out which prebuilt `podcomp` binary
+// belongs on this machine, and fetch it from GitHub Releases on demand.
+//
+// podcomp deliberately ships **no install script**. As of npm 12 dependency
+// lifecycle scripts are blocked unless the user opts in, and pnpm 12 fails a
+// *project* install outright with ERR_PNPM_IGNORED_BUILDS when a dependency
+// declares one. Downloading on first run works under every package manager,
+// under `--ignore-scripts`, and under `npx`, so that is what this does.
+//
+// Overrides (all optional):
+//   PODCOMP_REPO            owner/repo       (default: tomasky/podcomp)
+//   PODCOMP_VERSION         release version  (default: this package's version)
+//   PODCOMP_DOWNLOAD_BASE   full base URL    (overrides PODCOMP_REPO/PODCOMP_VERSION)
+//   PODCOMP_CACHE_DIR       where the binary is kept
+//   PODCOMP_BINARY          run this binary and never download
+//   PODCOMP_FORCE_DOWNLOAD  re-download even if the binary is already present
+//   PODCOMP_SKIP_DOWNLOAD   never download; fail if the binary is absent
+//   PODCOMP_NO_VERIFY       skip SHA-256 verification
+
+const crypto = require("crypto");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const https = require("https");
+const http = require("http");
+
+const pkg = require("./package.json");
+
+// Node's `platform-arch` -> the release target name. Intel macOS is absent on
+// purpose: the MoonBit toolchain no longer ships a darwin-x86_64 target.
+const TARGETS = {
+  "linux-x64": "linux-x86_64",
+  "linux-arm64": "linux-aarch64",
+  "darwin-arm64": "darwin-aarch64",
+};
+
+const SUPPORTED = "linux-x86_64, linux-aarch64 and darwin-aarch64";
+
+function targetName() {
+  return TARGETS[`${process.platform}-${process.arch}`];
+}
+
+function repoSlug() {
+  if (process.env.PODCOMP_REPO) return process.env.PODCOMP_REPO;
+  const url =
+    typeof pkg.repository === "string"
+      ? pkg.repository
+      : (pkg.repository && pkg.repository.url) || "";
+  const m = url.match(/github\.com[/:]([^/]+)\/([^/.]+)/);
+  return m ? `${m[1]}/${m[2]}` : "tomasky/podcomp";
+}
+
+function version() {
+  return (process.env.PODCOMP_VERSION || pkg.version).replace(/^v/, "");
+}
+
+function assetName(target) {
+  return `podcomp-${target}`;
+}
+
+// Both URLs are tried in order: the pinned version first, then whatever is
+// latest. The fallback keeps the launcher useful when a release was re-cut
+// under a different tag, or when package.json was bumped ahead of the tag.
+function downloadUrls(target) {
+  const asset = assetName(target);
+  if (process.env.PODCOMP_DOWNLOAD_BASE) {
+    const base = process.env.PODCOMP_DOWNLOAD_BASE.replace(/\/+$/, "");
+    return [`${base}/${asset}`];
+  }
+  const repo = repoSlug();
+  return [
+    `https://github.com/${repo}/releases/download/v${version()}/${asset}`,
+    `https://github.com/${repo}/releases/latest/download/${asset}`,
+  ];
+}
+
+function cacheDir() {
+  if (process.env.PODCOMP_CACHE_DIR) return process.env.PODCOMP_CACHE_DIR;
+  const home = os.homedir();
+  if (process.platform === "darwin") {
+    return path.join(home, "Library", "Caches", "podcomp");
+  }
+  const base = process.env.XDG_CACHE_HOME || path.join(home, ".cache");
+  return path.join(base, "podcomp");
+}
+
+function binaryPath(target) {
+  return path.join(cacheDir(), `podcomp-${version()}-${target}`);
+}
+
+function isRunnable(file) {
+  try {
+    fs.accessSync(file, fs.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// --- HTTP ------------------------------------------------------------------
+
+function fetch(url, redirects) {
+  return new Promise((resolve, reject) => {
+    if (redirects > 10) {
+      reject(new Error("too many redirects"));
+      return;
+    }
+    const client = url.startsWith("http:") ? http : https;
+    const req = client.get(
+      url,
+      { headers: { "user-agent": `podcomp-npm/${pkg.version}` } },
+      (res) => {
+        const { statusCode, headers } = res;
+        if (statusCode >= 300 && statusCode < 400 && headers.location) {
+          res.resume();
+          resolve(fetch(new URL(headers.location, url).toString(), redirects + 1));
+          return;
+        }
+        if (statusCode !== 200) {
+          res.resume();
+          const err = new Error(`GET ${url} -> HTTP ${statusCode}`);
+          err.statusCode = statusCode;
+          reject(err);
+          return;
+        }
+        resolve(res);
+      }
+    );
+    req.on("error", reject);
+    req.setTimeout(120000, () => req.destroy(new Error(`timed out fetching ${url}`)));
+  });
+}
+
+async function fetchBuffer(url) {
+  const res = await fetch(url, 0);
+  const chunks = [];
+  for await (const chunk of res) chunks.push(chunk);
+  return Buffer.concat(chunks);
+}
+
+async function fetchText(url) {
+  return (await fetchBuffer(url)).toString("utf8");
+}
+
+// --- install ---------------------------------------------------------------
+
+// Download to a sibling temp file and rename into place, so a crashed or
+// concurrent run can never leave a half-written binary at `dest`.
+async function downloadTo(url, dest) {
+  const res = await fetch(url, 0);
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  const tmp = `${dest}.${process.pid}.${Date.now()}.part`;
+  try {
+    await new Promise((resolve, reject) => {
+      const out = fs.createWriteStream(tmp, { mode: 0o755 });
+      res.pipe(out);
+      out.on("finish", () => out.close(resolve));
+      out.on("error", reject);
+      res.on("error", reject);
+    });
+    const size = fs.statSync(tmp).size;
+    if (size === 0) throw new Error(`${url} returned an empty file`);
+    fs.chmodSync(tmp, 0o755);
+    fs.renameSync(tmp, dest);
+  } catch (err) {
+    fs.rmSync(tmp, { force: true });
+    throw err;
+  }
+}
+
+// Verify against the `<asset>.sha256` published next to the binary. A missing
+// checksum is a warning, not a failure, so older releases keep working.
+async function verify(dest, url, log) {
+  if (process.env.PODCOMP_NO_VERIFY) return;
+  let published;
+  try {
+    published = (await fetchText(`${url}.sha256`)).trim();
+  } catch {
+    log(`podcomp: warning: no checksum published for ${path.basename(url)}`);
+    return;
+  }
+  const expected = (published.split(/\s+/)[0] || "").toLowerCase();
+  if (!/^[0-9a-f]{64}$/.test(expected)) {
+    log("podcomp: warning: published checksum is not a SHA-256 digest");
+    return;
+  }
+  const actual = crypto.createHash("sha256").update(fs.readFileSync(dest)).digest("hex");
+  if (actual !== expected) {
+    fs.rmSync(dest, { force: true });
+    throw new Error(
+      `checksum mismatch for ${path.basename(url)}\n` +
+        `  expected ${expected}\n  actual   ${actual}`
+    );
+  }
+}
+
+/**
+ * Resolve to a runnable `podcomp` binary, downloading it when it is missing.
+ */
+async function ensureBinary({ force = false, log = () => {} } = {}) {
+  if (process.env.PODCOMP_BINARY) {
+    if (!fs.existsSync(process.env.PODCOMP_BINARY)) {
+      throw new Error(
+        `PODCOMP_BINARY points at ${process.env.PODCOMP_BINARY}, which does not exist`
+      );
+    }
+    return process.env.PODCOMP_BINARY;
+  }
+
+  const target = targetName();
+  if (!target) {
+    throw new Error(
+      `podcomp does not ship a binary for ${process.platform}/${process.arch}; ` +
+        `supported: ${SUPPORTED}. Build from source instead: ` +
+        `https://github.com/${repoSlug()}#build-from-source`
+    );
+  }
+
+  const dest = binaryPath(target);
+  const wanted = force || process.env.PODCOMP_FORCE_DOWNLOAD;
+  if (!wanted && isRunnable(dest)) return dest;
+
+  if (process.env.PODCOMP_SKIP_DOWNLOAD) {
+    if (isRunnable(dest)) return dest;
+    throw new Error(
+      `PODCOMP_SKIP_DOWNLOAD is set but no podcomp binary is installed at ${dest}`
+    );
+  }
+
+  const urls = downloadUrls(target);
+  let lastError;
+  for (const url of urls) {
+    try {
+      log(`podcomp: downloading ${url}`);
+      await downloadTo(url, dest);
+      await verify(dest, url, log);
+      log(`podcomp: installed ${dest}`);
+      return dest;
+    } catch (err) {
+      lastError = err;
+      log(`podcomp: ${err.message}`);
+    }
+  }
+
+  throw new Error(
+    `could not download the podcomp binary for ${target}.\n` +
+      `Tried:\n${urls.map((u) => `  ${u}`).join("\n")}\n` +
+      `Last error: ${lastError && lastError.message}\n\n` +
+      `Install it another way instead:\n` +
+      `  curl -LsSf https://raw.githubusercontent.com/${repoSlug()}/main/install.sh | bash\n` +
+      `or set PODCOMP_DOWNLOAD_BASE to a mirror.`
+  );
+}
+
+module.exports = {
+  pkg,
+  TARGETS,
+  SUPPORTED,
+  targetName,
+  repoSlug,
+  version,
+  assetName,
+  downloadUrls,
+  cacheDir,
+  binaryPath,
+  isRunnable,
+  ensureBinary,
+};

package/package.json

@@ -1,6 +1,44 @@
 {
   "name": "@tomasko/podcomp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "Run Compose files with Podman , a single native binary, no daemon, no Python.",
+  "license": "Apache-2.0",
+  "bin": {
+    "podcomp": "bin/podcomp.js"
+  },
+  "files": [
+    "bin/podcomp.js",
+    "lib.js",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "os": [
+    "darwin",
+    "linux"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "scripts": {
+    "test": "node --test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tomasky/podcomp.git"
+  },
+  "homepage": "https://github.com/tomasky/podcomp",
+  "bugs": "https://github.com/tomasky/podcomp/issues",
+  "keywords": [
+    "podman",
+    "docker-compose",
+    "compose",
+    "containers",
+    "orchestration",
+    "cli",
+    "moonbit"
+  ],
+  "preferGlobal": true
+}