@lszio/zio 0.0.0-stage → 0.2.0

package/README.md

@@ -1,3 +1,28 @@
-# Temporary Holding Version
+# @lszio/zio
 
-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 Zio language toolchain. The package carries no binaries of its own:
+on first run it downloads the release archive that matches the installed
+version, checks it against the published checksum, and runs the `zio`
+inside it.
+
+```bash
+npm install -g @lszio/zio
+zio program.zio          # run a script
+zio                     # REPL
+zio fmt program.zio     # format
+zio lsp                 # language server on stdio
+zio-lsp                 # the same server, directly
+```
+
+Supported platforms are the ones the release publishes archives for:
+linux x86_64/arm64, macOS x86_64/arm64, Windows x86_64. The download
+needs `curl` (or a curl-compatible tool) and `tar` on PATH; on Windows
+the archive unpacks through PowerShell.
+
+The engine as WebAssembly — interpreter, compiler and the same session
+the CLI runs — is published separately as
+[`@lszio/zio-core`](https://www.npmjs.com/package/@lszio/zio-core), for
+browser and Node embedding.
+
+Documentation and the language reference live in the
+[Zio repository](https://github.com/lszio/zio).

package/bin/zio-lsp.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+// `zio-lsp` on PATH: the language server that ships inside the platform
+// archive, reached through the CLI wrapper so an editor that starts
+// `zio-lsp` gets the server that belongs to this install.
+"use strict";
+
+const path = require("path");
+const { spawnSync } = require("child_process");
+const { ensureBinary } = require("../install.js");
+
+const binary = ensureBinary();
+const sibling = path.join(path.dirname(binary), "zio-lsp");
+const child = spawnSync(sibling, process.argv.slice(2), { stdio: "inherit" });
+if (child.error) {
+  console.error(`zio: cannot run the language server at ${sibling}: ${child.error.message}`);
+  process.exit(1);
+}
+process.exit(child.status === null ? 1 : child.status);

package/bin/zio.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+// `zio` on PATH: make sure the platform binary is present, then run it
+// with this process's stdio and exit with its status, so a wrapper in
+// front of the real CLI is invisible to the shell.
+"use strict";
+
+const { spawnSync } = require("child_process");
+const { ensureBinary } = require("../install.js");
+
+const binary = ensureBinary();
+const child = spawnSync(binary, process.argv.slice(2), { stdio: "inherit" });
+if (child.error) {
+  console.error(`zio: cannot run ${binary}: ${child.error.message}`);
+  process.exit(1);
+}
+process.exit(child.status === null ? 1 : child.status);

package/install.js

@@ -0,0 +1,118 @@
+// Fetch the platform binary for this @lszio/zio install.
+//
+// The npm package ships no binaries of its own: it downloads the archive
+// that matches the installed version from the release tagged with that
+// same version, verifies it against the published checksum, and unpacks
+// it beside this file. The version the wrapper installs and the version
+// of the CLI it runs are therefore the same number by construction —
+// there is no second version to drift.
+//
+// The download happens on first run rather than on install, so an
+// install inside an offline build does not fail; the first `zio`
+// invocation reports the failure it actually hit.
+"use strict";
+
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const REPO = "lszio/zio";
+const VERSION = require("../package.json").version;
+const BASE = `https://github.com/${REPO}/releases/download/v${VERSION}`;
+
+const TARGETS = {
+  "linux-x64": "zio-linux-x86_64.tar.gz",
+  "linux-arm64": "zio-linux-aarch64.tar.gz",
+  "darwin-x64": "zio-macos-x86_64.tar.gz",
+  "darwin-arm64": "zio-macos-aarch64.tar.gz",
+  "win32-x64": "zio-windows-x86_64.zip",
+};
+
+const key = `${process.platform}-${process.arch}`;
+const archive = TARGETS[key];
+if (!archive) {
+  console.error(
+    `zio: no release archive for ${key}; build from source or download a ` +
+      `platform archive from https://github.com/${REPO}/releases`,
+  );
+  process.exit(1);
+}
+
+const vendor = path.join(__dirname, "..", "vendor");
+const archivePath = path.join(vendor, archive);
+const tree = path.join(vendor, archive.replace(/\.(tar\.gz|zip)$/, ""));
+const binary = path.join(tree, "bin", process.platform === "win32" ? "zio.exe" : "zio");
+
+/// Download, verify and unpack the archive for this platform, then
+/// return the path of the `zio` binary inside it.
+function ensureBinary() {
+  if (!fs.existsSync(binary)) {
+    download();
+  }
+  return binary;
+}
+
+function fail(message) {
+  console.error(`zio: ${message}`);
+  process.exit(1);
+}
+
+function fetch(url) {
+  const curl = spawnSync("curl", ["-fsSL", "--retry", "3", url], {
+    maxBuffer: 512 * 1024 * 1024,
+  });
+  if (curl.error) {
+    fail(`cannot download ${url}: ${curl.error.message}`);
+  }
+  if (curl.status !== 0) {
+    fail(
+      `cannot download ${url} (curl exit ${curl.status}); ` +
+        `check that release v${VERSION} publishes ${archive}`,
+    );
+  }
+  return curl.stdout;
+}
+
+function download() {
+  fs.mkdirSync(vendor, { recursive: true });
+  process.stderr.write(`zio: downloading ${archive} (v${VERSION})…\n`);
+
+  const bytes = fetch(`${BASE}/${archive}`);
+  fs.writeFileSync(archivePath, bytes);
+
+  // The release publishes a checksum beside the archive. A binary that
+  // does not match its checksum is a supply-chain event, not a warning.
+  const expected = fetch(`${BASE}/${archive}.sha256`).toString("utf8").trim().split(/\s+/)[0];
+  const actual = crypto.createHash("sha256").update(bytes).digest("hex");
+  if (expected !== actual) {
+    fs.rmSync(archivePath, { force: true });
+    fail(`checksum mismatch for ${archive}: expected ${expected}, got ${actual}`);
+  }
+
+  if (archive.endsWith(".zip")) {
+    const unzip = spawnSync(
+      "powershell",
+      [
+        "-NoProfile",
+        "-Command",
+        `Expand-Archive -LiteralPath '${archivePath}' -DestinationPath '${vendor}' -Force`,
+      ],
+      { stdio: "inherit" },
+    );
+    if (unzip.error || unzip.status !== 0) {
+      fail(`cannot unpack ${archive}`);
+    }
+  } else {
+    const tar = spawnSync("tar", ["-xzf", archivePath, "-C", vendor], { stdio: "inherit" });
+    if (tar.error || tar.status !== 0) {
+      fail(`cannot unpack ${archive} (GNU tar must be on PATH)`);
+    }
+  }
+  fs.rmSync(archivePath, { force: true });
+  if (!fs.existsSync(binary)) {
+    fail(`the unpacked archive did not contain bin/${path.basename(binary)}`);
+  }
+}
+
+module.exports = { ensureBinary, binary };

package/package.json

@@ -1,6 +1,35 @@
 {
   "name": "@lszio/zio",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "The Zio language: a general-purpose Lisp with a self-hosting compiler, an image runtime, and one CLI — REPL, script runner, compiler, formatter and language server",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lszio/zio.git"
+  },
+  "homepage": "https://github.com/lszio/zio#readme",
+  "bugs": "https://github.com/lszio/zio/issues",
+  "keywords": [
+    "zio",
+    "lisp",
+    "language",
+    "compiler",
+    "cli"
+  ],
+  "type": "commonjs",
+  "bin": {
+    "zio": "bin/zio.js",
+    "zio-lsp": "bin/zio-lsp.js"
+  },
+  "files": [
+    "bin",
+    "install.js",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}