jam 0.7.0 → 0.7.2

package/README.md

@@ -1,44 +1,60 @@
 # jam
 
-Install and run the Jam server binary from npm.
+Jam is an application server for isolated JavaScript. It runs JavaScript (and TypeScript) per request with isolated execution contexts, inspired by the PHP-FPM model.
 
-## Usage
+## Install
 
 ```sh
 npm install -g jam
 jam --help
 ```
 
-You can also use it without a global install:
+## Usage
+
+Create a `scripts/app.ts` file:
+
+```ts
+export default {
+  fetch(request: Request): Response {
+    return new Response("Hello from Jam");
+  }
+};
+```
+
+Start Jam, pointing it at the scripts folder:
 
 ```sh
-npx jam --help
+jam ./scripts
 ```
 
-## How it works
+Now make a request. Jam maps `/app` to `app.ts`.
 
-On install, this package detects your OS/CPU target and downloads the matching Jam binary from GitHub Releases.
+```sh
+curl http://localhost:3000/app
+```
 
-Expected release asset names:
+Edit the file and make the same request again. The next request runs the updated script immediately, with no rebuilds or restarts.
 
-- `jam-darwin-arm64`
-- `jam-darwin-x64`
-- `jam-linux-x64`
-- `jam-linux-arm64`
+## Documentation
 
-Current support is macOS (`darwin`) and Linux glibc builds. Linux musl and Windows targets are not published yet.
+To learn more, see [the documentation](https://github.com/mjackson/jam/tree/main/docs).
+
+## How platform binaries are downloaded
 
-The binary is stored inside this package at `downloaded/jam`, and the `jam` npm bin shim executes it.
+The `jam` package uses platform-specific optional dependencies. During install, npm picks the matching package for your OS/CPU target:
+
+- [`jam-darwin-arm64`](https://www.npmjs.com/package/jam-darwin-arm64)
+- [`jam-darwin-x64`](https://www.npmjs.com/package/jam-darwin-x64)
+- [`jam-linux-x64`](https://www.npmjs.com/package/jam-linux-x64)
+- [`jam-linux-arm64`](https://www.npmjs.com/package/jam-linux-arm64)
+
+Current support is macOS (`darwin`) and Linux glibc builds. Linux musl and Windows targets are not published yet.
 
 ## Environment overrides
 
-- `JAM_SKIP_DOWNLOAD=1`: skip binary download during install.
-- `JAM_FORCE_DOWNLOAD=1`: force download even in the Jam source checkout.
-- `JAM_BINARY_VERSION=<version>`: download a different Jam release version.
-- `JAM_BINARY_BASE_URL=<url>`: override the release URL prefix.
 - `JAM_LIBC=glibc|musl`: override Linux libc detection.
-- `JAM_BINARY_PATH=<path>`: run a specific local binary instead of the downloaded one.
+- `JAM_BINARY_PATH=<path>`: run a specific local binary instead of the optional dependency binary.
 
 ## Local development
 
-When installing from the Jam source checkout (`packages/jam` workspace), postinstall download is skipped automatically. Set `JAM_FORCE_DOWNLOAD=1` to force a download during local testing.
+Install dependencies with optional dependencies enabled so the matching platform package is available.

package/lib/resolve-binary.js

@@ -1,37 +1,30 @@
 "use strict";
 
-let fs = require("node:fs");
-let path = require("node:path");
-
+let {
+  packageNameForTarget,
+  resolveOptionalPackageBinaryPath,
+} = require("./resolve-optional-package");
 let { getRuntimeDescriptor } = require("./platform");
 
-function packageRoot() {
-  return path.join(__dirname, "..");
-}
-
-function downloadedBinaryPath(runtimeDescriptor) {
-  let descriptor = runtimeDescriptor || getRuntimeDescriptor();
-  return path.join(packageRoot(), "downloaded", descriptor.binaryName);
-}
-
 function resolveBinaryPath() {
   let fromEnv = process.env.JAM_BINARY_PATH;
   if (fromEnv) return fromEnv;
 
   let descriptor = getRuntimeDescriptor();
-  let targetPath = downloadedBinaryPath(descriptor);
-  if (fs.existsSync(targetPath)) return targetPath;
+  let optionalPath = resolveOptionalPackageBinaryPath(descriptor);
+  if (optionalPath) return optionalPath;
+
+  let packageName = packageNameForTarget(descriptor.target);
+
+  if (!packageName) {
+    throw new Error(`No optional dependency package is configured for ${descriptor.target}.`);
+  }
 
   throw new Error(
-    [
-      `Jam binary not found for ${descriptor.target}.`,
-      `Expected: ${targetPath}`,
-      "Try reinstalling the package or run `npm rebuild jam`.",
-    ].join("\n")
+    `Jam optional dependency package not installed for ${descriptor.target}: ${packageName}. Try reinstalling with optional dependencies enabled.`
   );
 }
 
 module.exports = {
-  downloadedBinaryPath,
   resolveBinaryPath,
 };

package/lib/resolve-optional-package.js

@@ -0,0 +1,43 @@
+"use strict";
+
+let fs = require("node:fs");
+let path = require("node:path");
+
+let TARGET_TO_PACKAGE = {
+  "darwin-arm64": "jam-darwin-arm64",
+  "darwin-x64": "jam-darwin-x64",
+  "linux-x64": "jam-linux-x64",
+  "linux-arm64": "jam-linux-arm64",
+};
+
+function packageNameForTarget(target) {
+  return TARGET_TO_PACKAGE[target] || null;
+}
+
+function packageRootFromName(packageName) {
+  try {
+    let packageJsonPath = require.resolve(`${packageName}/package.json`, {
+      paths: [path.join(__dirname, "..")],
+    });
+    return path.dirname(packageJsonPath);
+  } catch {
+    return null;
+  }
+}
+
+function resolveOptionalPackageBinaryPath(runtimeDescriptor) {
+  let packageName = packageNameForTarget(runtimeDescriptor.target);
+  if (!packageName) return null;
+
+  let packageRoot = packageRootFromName(packageName);
+  if (!packageRoot) return null;
+
+  let binaryPath = path.join(packageRoot, "bin", runtimeDescriptor.binaryName);
+  if (!fs.existsSync(binaryPath)) return null;
+  return binaryPath;
+}
+
+module.exports = {
+  packageNameForTarget,
+  resolveOptionalPackageBinaryPath,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jam",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "An application server for isolated JavaScript",
   "license": "MIT",
   "type": "commonjs",
@@ -16,18 +16,21 @@
   "bin": {
     "jam": "bin/jam.js"
   },
+  "optionalDependencies": {
+    "jam-darwin-arm64": "0.7.2",
+    "jam-darwin-x64": "0.7.2",
+    "jam-linux-x64": "0.7.2",
+    "jam-linux-arm64": "0.7.2"
+  },
   "files": [
     "bin",
     "lib",
-    "install.js",
     "README.md"
   ],
-  "scripts": {
-    "postinstall": "node install.js",
-    "test": "node test/platform.test.js",
-    "prepublishOnly": "node test/platform.test.js"
-  },
   "engines": {
     "node": ">=18"
+  },
+  "scripts": {
+    "test": "node test/platform.test.js && node test/resolve-optional-package.test.js"
   }
-}
+}

package/install.js

@@ -1,108 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-
-let fs = require("node:fs");
-let path = require("node:path");
-let { Readable } = require("node:stream");
-let { pipeline } = require("node:stream/promises");
-
-let { getRuntimeDescriptor } = require("./lib/platform");
-let { downloadedBinaryPath } = require("./lib/resolve-binary");
-
-let MAX_REDIRECTS = 5;
-let REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
-
-function loadPackageVersion() {
-  let pkgPath = path.join(__dirname, "package.json");
-  let pkgJson = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-  return pkgJson.version;
-}
-
-function shouldSkipInstall(version) {
-  if (process.env.JAM_SKIP_DOWNLOAD === "1") return true;
-  if (isJamSourceCheckout() && process.env.JAM_FORCE_DOWNLOAD !== "1") return true;
-  return version.startsWith("0.0.0-");
-}
-
-function isJamSourceCheckout() {
-  let repoRoot = path.join(__dirname, "..", "..");
-  return (
-    fs.existsSync(path.join(repoRoot, "go.mod")) &&
-    fs.existsSync(path.join(repoRoot, "cmd", "jam", "main.go")) &&
-    fs.existsSync(path.join(repoRoot, "pnpm-workspace.yaml"))
-  );
-}
-
-function buildDownloadUrl(target, binaryName, version) {
-  let releaseVersion = process.env.JAM_BINARY_VERSION || version;
-  let explicitBaseUrl = process.env.JAM_BINARY_BASE_URL;
-  let baseUrl =
-    explicitBaseUrl ||
-    `https://github.com/mjackson/jam/releases/download/v${releaseVersion}`;
-  return `${baseUrl.replace(/\/+$/, "")}/jam-${target}${binaryName.endsWith(".exe") ? ".exe" : ""}`;
-}
-
-async function fetchToFile(url, filePath, redirects) {
-  if (redirects > MAX_REDIRECTS) {
-    throw new Error(`Too many redirects while downloading ${url}`);
-  }
-
-  let response = await fetch(url, {
-    headers: {
-      "user-agent": "jam-npm-installer",
-    },
-    redirect: "manual",
-  });
-
-  if (REDIRECT_STATUSES.has(response.status)) {
-    let location = response.headers.get("location");
-    if (!location) {
-      throw new Error(`Redirect missing location header: ${response.status} ${url}`);
-    }
-    let redirectUrl = new URL(location, url).toString();
-    await fetchToFile(redirectUrl, filePath, redirects + 1);
-    return;
-  }
-
-  if (response.status !== 200) {
-    throw new Error(`Download failed: ${response.status} ${url}`);
-  }
-
-  if (!response.body) {
-    throw new Error(`Download failed: empty response body for ${url}`);
-  }
-
-  let out = fs.createWriteStream(filePath, { mode: 0o755 });
-  await pipeline(Readable.fromWeb(response.body), out);
-}
-
-async function install() {
-  let version = loadPackageVersion();
-  if (shouldSkipInstall(version)) {
-    if (isJamSourceCheckout()) {
-      console.log("[jam] Skipping binary download in Jam source checkout.");
-      return;
-    }
-    console.log("[jam] Skipping binary download.");
-    return;
-  }
-
-  let descriptor = getRuntimeDescriptor();
-  let downloadUrl = buildDownloadUrl(descriptor.target, descriptor.binaryName, version);
-  let outputPath = downloadedBinaryPath(descriptor);
-
-  fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-  console.log(`[jam] Downloading ${descriptor.target} binary from ${downloadUrl}`);
-  await fetchToFile(downloadUrl, outputPath, 0);
-
-  if (descriptor.platform !== "win32") {
-    fs.chmodSync(outputPath, 0o755);
-  }
-
-  console.log(`[jam] Installed binary to ${outputPath}`);
-}
-
-install().catch((error) => {
-  console.error(`[jam] ${error.message}`);
-  process.exit(1);
-});