@tdio/static-serve 0.0.4 → 0.0.5-dev.5

package/README.md

@@ -92,8 +92,10 @@ If `ROOT_DIR` is not specified, it defaults to the current directory (`./`).
 | Flag | Description | Default |
 |------|-------------|---------|
 | `--address` | The TCP address to listen on. | `:3000` |
+| `--config` | Load options from a YAML config file. CLI scalar flags override config values; repeated `--proxy` and `--mount` flags append to config lists. | `""` |
+| `--log-level` | Server log level. Supported values: `error`, `warn`, `info`, `debug`, `trace`. | `info` |
 | `--mount` | Mount specific directory to a virtual path (can be repeated). Format: `<physical_path>:<virtual_path>` or `src=<physical_path>,dst=<virtual_path>`  | `""` |
-| `--proxy` | Proxy specific upstream to a virtual path (can be repeated). | `""` |
+| `--proxy` | Proxy specific upstream to a virtual path (can be repeated), including `unix:///path.sock` upstreams. | `""` |
 | `--spa` | Enable SPA mode (redirects missing files to `/index.html`). | `false` |
 | `--logger-format` | Custom server logger format (Go template syntax). | `{{.Method}} {{.URL.Path}} {{.Status}} {{.RemoteAddr}} {{.UserAgent}}` |
 | `--tls-cert` | Path to TLS certificate file. Enables HTTPS (requires `--tls-key`). | `""` |
@@ -156,6 +158,8 @@ This is useful for:
 
 Example: `/api:http://localhost:8080`
 
+Unix socket example: `/api:unix:///tmp/app.sock`
+
 _Note: This format automatically enables `change_origin` and `strip_prefix`._
 
 #### Advanced Format (Key-Value)
@@ -164,11 +168,72 @@ _Note: This format automatically enables `change_origin` and `strip_prefix`._
 
 Parameters:
 - `path`: The virtual path on the current server to match.
-- `url`: The upstream URL to forward requests to.
+- `url`: The upstream URL to forward requests to. Supports `http://...`, `https://...`, and `unix:///path.sock` for HTTP over Unix domain sockets.
 - `change_origin`: Whether to rewrite the `Host` header to match the upstream URL. **Default: `true`**.
 - `strip_prefix`: Whether to strip the matched path prefix before forwarding the request. **Default: `true`**.
 - `method(s)`: pipe-separated list of HTTP methods to proxy. If specified, only these methods will be proxied. Others will pass through to local file serving or return 405. **Default: all methods**.
 
+### YAML Config
+
+For larger setups, you can keep server options in YAML and load them with `--config`.
+
+An example config template is included at `docs/static-serve.example.yaml`. It shows a fuller setup with SPA, proxy, mount, TLS, and CORS settings, but you will need to update the sample paths and upstreams for your environment before using it.
+
+```yaml
+address: ":3001"
+root_dir: "./"
+spa: false
+log_level: info
+
+proxies:
+  - path: /
+    url: unix:///tmp/nextjs.sock
+  - path: /dify/console/api
+    url: http://192.168.0.57:5001/console/api
+    strip_prefix: true
+  - path: /dify/api
+    url: http://192.168.0.57:5001/api
+    strip_prefix: true
+
+mounts:
+  - src: ./assets
+    dst: /static
+```
+
+Run it with:
+
+```sh
+static-serve --config ./static-serve.yaml
+```
+
+CLI scalar flags override the YAML values:
+
+```sh
+static-serve --config ./static-serve.yaml --address :4000 ./dist
+```
+
+Repeated route flags append after the YAML lists:
+
+```sh
+static-serve --config ./static-serve.yaml --proxy /:unix:///tmp/nextjs.sock --mount ./extra-assets:/extra
+```
+
+Supported YAML fields mirror the existing CLI options:
+
+- `address`
+- `root_dir`
+- `spa`
+- `log_level`
+- `logger_format`
+- `tls_cert`
+- `tls_key`
+- `cors`
+- `cors_allow_origins`
+- `cors_allow_credentials`
+- `cors_max_age`
+- `proxies`
+- `mounts`
+
 ### Examples
 
 **Serve current directory on port 8080:**
@@ -209,14 +274,21 @@ static-serve --mount "src=./config.json,dst=/api/config"
    ```
    Requests to `http://localhost:3000/api/users` will be forwarded to `http://localhost:8080/api/users` (if no local file exists).
 
-3. **Method Filtering**: Only proxy POST and PUT requests to the upstream server.
+3. **Unix Socket Upstream**: Forward `/api` to an HTTP server listening on a Unix domain socket.
+   ```sh
+   static-serve --proxy "/api:unix:///tmp/app.sock"
+   static-serve --proxy "path=/api,url=unix:///tmp/app.sock"
+   ```
+   Requests to `http://localhost:3000/api/users` will be forwarded over the Unix socket to `/users` (if no local file exists).
+
+4. **Method Filtering**: Only proxy POST and PUT requests to the upstream server.
    ```sh
    static-serve --proxy "path=/api,url=http://localhost:8080,methods=POST|PUT"
    ```
    - `GET /api/users` → serves local `./api/users` or 404
    - `POST /api/users` → proxies to `http://localhost:8080/users` (if no local file exists)
 
-4. **Local Override Pattern**: Override specific upstream assets with local versions.
+5. **Local Override Pattern**: Override specific upstream assets with local versions.
    ```sh
    # Create local override
    mkdir -p ./assets
@@ -228,6 +300,16 @@ static-serve --mount "src=./config.json,dst=/api/config"
    - `GET /assets/config.json` → serves local `./assets/config.json`
    - `GET /assets/other.js` → proxies to `http://cdn.example.com/assets/other.js`
 
+6. **Trace Proxy Requests**: Emit detailed per-request proxy logs such as `Proxying "GET ..."` only in trace mode.
+   ```sh
+   static-serve --log-level trace --proxy "/api:http://localhost:8080"
+   ```
+
+7. **Show Route Wiring Details**: Use debug mode to inspect mount and proxy registration without enabling full trace noise.
+   ```sh
+   static-serve --log-level debug --mount ./assets:/static --proxy "/api:http://localhost:8080"
+   ```
+
 **Serve over HTTPS:**
 ```sh
 static-serve --tls-cert ./cert.pem --tls-key ./key.pem ./public

package/bin/static-serve

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// lib/npm/node-platform.ts
+var fs = require("fs");
+var os = require("os");
+var path = require("path");
+var STATIC_SERVE_BINARY_PATH = process.env.STATIC_SERVE_BINARY_PATH || STATIC_SERVE_BINARY_PATH;
+var PACKAGE_PREFIX = "static-serve";
+var PACKAGE_SCOPE = "@tdio";
+var knownPackages = {
+  "darwin arm64 LE": `${PACKAGE_SCOPE}/${PACKAGE_PREFIX}-darwin-arm64`,
+  "darwin x64 LE": `${PACKAGE_SCOPE}/${PACKAGE_PREFIX}-darwin-x64`,
+  "linux arm64 LE": `${PACKAGE_SCOPE}/${PACKAGE_PREFIX}-linux-arm64`,
+  "linux x64 LE": `${PACKAGE_SCOPE}/${PACKAGE_PREFIX}-linux-x64`,
+  "win32 arm64 LE": `${PACKAGE_SCOPE}/${PACKAGE_PREFIX}-win32-arm64`,
+  "win32 x64 LE": `${PACKAGE_SCOPE}/${PACKAGE_PREFIX}-win32-x64`
+};
+function pkgAndSubpathForCurrentPlatform() {
+  const platformKey = `${process.platform} ${os.arch()} ${os.endianness()}`;
+  const pkg = knownPackages[platformKey];
+  if (!pkg) {
+    throw new Error(`Unsupported platform: ${platformKey}`);
+  }
+  const subpath = process.platform === "win32" ? "static-serve.exe" : "static-serve";
+  return { pkg, subpath };
+}
+function pkgForSomeOtherPlatform() {
+  const libMainJS = require.resolve("@tdio/static-serve");
+  const nodeModulesDirectory = path.dirname(path.dirname(path.dirname(libMainJS)));
+  if (path.basename(nodeModulesDirectory) === "node_modules") {
+    for (const platformKey in knownPackages) {
+      try {
+        const pkg = knownPackages[platformKey];
+        if (fs.existsSync(path.join(nodeModulesDirectory, pkg))) return pkg;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function downloadedBinPath(pkg, subpath) {
+  const staticServeLibDir = path.dirname(require.resolve("@tdio/static-serve"));
+  return path.join(staticServeLibDir, `downloaded-${pkg.replace("/", "-")}-${path.basename(subpath)}`);
+}
+function generateBinPath() {
+  if (STATIC_SERVE_BINARY_PATH) {
+    if (fs.existsSync(STATIC_SERVE_BINARY_PATH)) {
+      return STATIC_SERVE_BINARY_PATH;
+    }
+    console.warn(`[static-serve] Ignoring bad configuration: STATIC_SERVE_BINARY_PATH=${STATIC_SERVE_BINARY_PATH}`);
+  }
+  const { pkg, subpath } = pkgAndSubpathForCurrentPlatform();
+  let binPath;
+  try {
+    binPath = require.resolve(`${pkg}/${subpath}`);
+  } catch (e) {
+    binPath = downloadedBinPath(pkg, subpath);
+    if (!fs.existsSync(binPath)) {
+      try {
+        require.resolve(pkg);
+      } catch {
+        const otherPkg = pkgForSomeOtherPlatform();
+        if (otherPkg) {
+          let suggestions = `
+Specifically the "${otherPkg}" package is present but this platform
+needs the "${pkg}" package instead. People often get into this
+situation by installing static-serve on Windows or macOS and copying "node_modules"
+into a Docker image that runs Linux, or by copying "node_modules" between
+Windows and WSL environments.
+
+If you are installing with npm, you can try not copying the "node_modules"
+directory when you copy the files over, and running "npm ci" or "npm install"
+on the destination platform after the copy. Or you could consider using yarn
+instead of npm which has built-in support for installing a package on multiple
+platforms simultaneously.
+
+If you are installing with yarn, you can try listing both this platform and the
+other platform in your ".yarnrc.yml" file using the "supportedArchitectures"
+feature: https://yarnpkg.com/configuration/yarnrc/#supportedArchitectures
+Keep in mind that this means multiple copies of static-serve will be present.
+`;
+          const packageDarwin_x64 = `${PACKAGE_SCOPE}/${PACKAGE_PREFIX}-darwin-x64`;
+          const packageDarwin_arm64 = `${PACKAGE_SCOPE}/${PACKAGE_PREFIX}-darwin-arm64`;
+          if (pkg === packageDarwin_x64 && otherPkg === packageDarwin_arm64 || pkg === packageDarwin_arm64 && otherPkg === packageDarwin_x64) {
+            suggestions = `
+Specifically the "${otherPkg}" package is present but this platform
+needs the "${pkg}" package instead. People often get into this
+situation by installing static-serve with npm running inside of Rosetta 2 and then
+trying to use it with node running outside of Rosetta 2, or vice versa (Rosetta
+2 is Apple's on-the-fly x86_64-to-arm64 translation service).
+
+If you are installing with npm, you can try ensuring that both npm and node are
+not running under Rosetta 2 and then reinstalling static-serve. This likely involves
+changing how you installed npm and/or node. For example, installing node with
+the universal installer here should work: https://nodejs.org/en/download/. Or
+you could consider using yarn instead of npm which has built-in support for
+installing a package on multiple platforms simultaneously.
+
+If you are installing with yarn, you can try listing both "arm64" and "x64"
+in your ".yarnrc.yml" file using the "supportedArchitectures" feature:
+https://yarnpkg.com/configuration/yarnrc/#supportedArchitectures
+Keep in mind that this means multiple copies of static-serve will be present.
+`;
+          }
+          throw new Error(`
+You installed static-serve for another platform than the one you're currently using.
+This won't work because static-serve is written with native code and needs to
+install a platform-specific binary executable.
+${suggestions}
+`);
+        }
+        throw new Error(`The package "${pkg}" could not be found, and is needed by static-serve.
+
+If you are installing static-serve with npm, make sure that you don't specify the
+"--no-optional" or "--omit=optional" flags. The "optionalDependencies" feature
+of "package.json" is used by static-serve to install the correct binary executable
+for your current platform.`);
+      }
+      throw e;
+    }
+  }
+  return binPath;
+}
+
+// lib/npm/cli.ts
+var child_process = require("child_process");
+var path2 = require("path");
+var fs2 = require("fs");
+var PACKAGE_PREFIX2 = "static-serve";
+function getLocalBuildPath() {
+  const platform = process.platform;
+  const arch = process.arch;
+  const goOs = platform === "win32" ? "windows" : platform;
+  const goArch = arch === "x64" ? "amd64" : arch;
+  const binFile = platform === "win32" ? `${PACKAGE_PREFIX2}-${goOs}-${goArch}.exe` : `${PACKAGE_PREFIX2}-${goOs}-${goArch}`;
+  const searchPaths = [
+    path2.join(__dirname, "..", "..", "out", binFile),
+    // from lib/npm/
+    path2.join(__dirname, "..", "..", "..", "out", binFile)
+    // from npm/static-serve/bin/
+  ];
+  for (const p of searchPaths) {
+    if (fs2.existsSync(p)) {
+      return p;
+    }
+  }
+  return "";
+}
+var binaryPath;
+try {
+  binaryPath = generateBinPath();
+} catch (err) {
+  const localPath = getLocalBuildPath();
+  if (localPath) {
+    binaryPath = localPath;
+  } else {
+    console.error(`Failed to locate binary for ${process.platform}-${process.arch}.`);
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+}
+var child = child_process.spawn(binaryPath, process.argv.slice(2), {
+  stdio: "inherit"
+});
+child.on("exit", (code) => {
+  process.exit(code ?? 0);
+});

package/install.js

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// lib/npm/node-platform.ts
+var fs = require("fs");
+var os = require("os");
+var path = require("path");
+var STATIC_SERVE_BINARY_PATH = process.env.STATIC_SERVE_BINARY_PATH || STATIC_SERVE_BINARY_PATH;
+var isValidBinaryPath = (x) => !!x && fs.existsSync(x);
+var PACKAGE_PREFIX = "static-serve";
+var PACKAGE_SCOPE = "@tdio";
+var knownPackages = {
+  "darwin arm64 LE": `${PACKAGE_SCOPE}/${PACKAGE_PREFIX}-darwin-arm64`,
+  "darwin x64 LE": `${PACKAGE_SCOPE}/${PACKAGE_PREFIX}-darwin-x64`,
+  "linux arm64 LE": `${PACKAGE_SCOPE}/${PACKAGE_PREFIX}-linux-arm64`,
+  "linux x64 LE": `${PACKAGE_SCOPE}/${PACKAGE_PREFIX}-linux-x64`,
+  "win32 arm64 LE": `${PACKAGE_SCOPE}/${PACKAGE_PREFIX}-win32-arm64`,
+  "win32 x64 LE": `${PACKAGE_SCOPE}/${PACKAGE_PREFIX}-win32-x64`
+};
+function pkgAndSubpathForCurrentPlatform() {
+  const platformKey = `${process.platform} ${os.arch()} ${os.endianness()}`;
+  const pkg = knownPackages[platformKey];
+  if (!pkg) {
+    throw new Error(`Unsupported platform: ${platformKey}`);
+  }
+  const subpath = process.platform === "win32" ? "static-serve.exe" : "static-serve";
+  return { pkg, subpath };
+}
+function downloadedBinPath(pkg, subpath) {
+  const staticServeLibDir = path.dirname(require.resolve("@tdio/static-serve"));
+  return path.join(staticServeLibDir, `downloaded-${pkg.replace("/", "-")}-${path.basename(subpath)}`);
+}
+
+// lib/npm/install.ts
+var fs2 = require("fs");
+var os2 = require("os");
+var path2 = require("path");
+var zlib = require("zlib");
+var https = require("https");
+var child_process = require("child_process");
+var versionFromPackageJSON = require(path2.join(__dirname, "package.json")).version;
+var toPath = path2.join(__dirname, "bin", "static-serve");
+var isToPathJS = true;
+function validateBinaryVersion(...command) {
+  command.push("-v");
+  let stdout;
+  try {
+    stdout = child_process.execFileSync(command.shift(), command, {
+      // Without this, this install script strangely crashes with the error
+      // "EACCES: permission denied, write" but only on Ubuntu Linux when node is
+      // installed from the Snap Store. This is not a problem when you download
+      // the official version of node. The problem appears to be that stderr
+      // (i.e. file descriptor 2) isn't writable?
+      stdio: "pipe"
+    }).toString().trim();
+  } catch (err) {
+    if (os2.platform() === "darwin" && /_SecTrustEvaluateWithError/.test(err + "")) {
+      let osVersion = "this version of macOS";
+      try {
+        osVersion = "macOS " + child_process.execFileSync("sw_vers", ["-productVersion"]).toString().trim();
+      } catch {
+      }
+      throw new Error(`The "static-serve" package cannot be installed because ${osVersion} is too outdated.
+
+The Go compiler (which static-serve relies on) no longer supports ${osVersion},
+which means the "static-serve" binary executable can't be run. You can either:
+
+  * Update your version of macOS to one that the Go compiler supports
+  * Build static-serve yourself using an older version of the Go compiler
+`);
+    }
+    throw err;
+  }
+  const versionMatch = stdout.match(/version\s+([^\s,]+)/);
+  if (versionMatch && versionMatch[1] !== versionFromPackageJSON) {
+    throw new Error(`Expected ${JSON.stringify(versionFromPackageJSON)} but got ${JSON.stringify(versionMatch[1])}`);
+  }
+}
+function isYarn() {
+  const { npm_config_user_agent } = process.env;
+  if (npm_config_user_agent) {
+    return /\byarn\//.test(npm_config_user_agent);
+  }
+  return false;
+}
+function fetch(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      if ((res.statusCode === 301 || res.statusCode === 302) && res.headers.location)
+        return fetch(res.headers.location).then(resolve, reject);
+      if (res.statusCode !== 200)
+        return reject(new Error(`Server responded with ${res.statusCode}`));
+      let chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => resolve(Buffer.concat(chunks)));
+    }).on("error", reject);
+  });
+}
+function extractFileFromTarGzip(buffer, subpath) {
+  try {
+    buffer = zlib.unzipSync(buffer);
+  } catch (err) {
+    throw new Error(`Invalid gzip data in archive: ${err && err.message || err}`);
+  }
+  let str = (i, n) => String.fromCharCode(...buffer.subarray(i, i + n)).replace(/\0.*$/, "");
+  let offset = 0;
+  subpath = `package/${subpath}`;
+  while (offset < buffer.length) {
+    let name = str(offset, 100);
+    let size = parseInt(str(offset + 124, 12), 8);
+    offset += 512;
+    if (!isNaN(size)) {
+      if (name === subpath) return buffer.subarray(offset, offset + size);
+      offset += size + 511 & ~511;
+    }
+  }
+  throw new Error(`Could not find ${JSON.stringify(subpath)} in archive`);
+}
+function installUsingNPM(pkg, subpath, binPath) {
+  const env = { ...process.env, npm_config_global: void 0 };
+  const staticServeLibDir = path2.dirname(require.resolve("@tdio/static-serve"));
+  const installDir = path2.join(staticServeLibDir, "npm-install");
+  fs2.mkdirSync(installDir, { recursive: true });
+  try {
+    fs2.writeFileSync(path2.join(installDir, "package.json"), "{}");
+    child_process.execSync(
+      `npm install --loglevel=error --prefer-offline --no-audit --progress=false ${pkg}@${versionFromPackageJSON}`,
+      { cwd: installDir, stdio: "pipe", env }
+    );
+    const installedBinPath = path2.join(installDir, "node_modules", pkg, subpath);
+    fs2.renameSync(installedBinPath, binPath);
+  } finally {
+    try {
+      removeRecursive(installDir);
+    } catch {
+    }
+  }
+}
+function removeRecursive(dir) {
+  for (const entry of fs2.readdirSync(dir)) {
+    const entryPath = path2.join(dir, entry);
+    let stats;
+    try {
+      stats = fs2.lstatSync(entryPath);
+    } catch {
+      continue;
+    }
+    if (stats.isDirectory()) removeRecursive(entryPath);
+    else fs2.unlinkSync(entryPath);
+  }
+  fs2.rmdirSync(dir);
+}
+function applyManualBinaryPathOverride(overridePath) {
+  const pathString = JSON.stringify(overridePath);
+  fs2.writeFileSync(toPath, `#!/usr/bin/env node
+require('child_process').execFileSync(${pathString}, process.argv.slice(2), { stdio: 'inherit' });
+`);
+  const libMain = path2.join(__dirname, "lib", "main.js");
+  const code = fs2.readFileSync(libMain, "utf8");
+  fs2.writeFileSync(libMain, `var STATIC_SERVE_BINARY_PATH = ${pathString};
+${code}`);
+}
+function maybeOptimizePackage(binPath) {
+  if (os2.platform() !== "win32" && !isYarn()) {
+    const tempPath = path2.join(__dirname, "bin-static-serve");
+    try {
+      fs2.linkSync(binPath, tempPath);
+      fs2.renameSync(tempPath, toPath);
+      isToPathJS = false;
+      fs2.unlinkSync(tempPath);
+    } catch {
+    }
+  }
+}
+async function downloadDirectlyFromNPM(pkg, subpath, binPath) {
+  const pkgName = pkg.replace("@tdio/", "");
+  const url = `https://registry.npmjs.org/${pkg}/-/${pkgName}-${versionFromPackageJSON}.tgz`;
+  console.error(`[static-serve] Trying to download ${JSON.stringify(url)}`);
+  try {
+    fs2.writeFileSync(binPath, extractFileFromTarGzip(await fetch(url), subpath));
+    fs2.chmodSync(binPath, 493);
+  } catch (e) {
+    console.error(`[static-serve] Failed to download ${JSON.stringify(url)}: ${e && e.message || e}`);
+    throw e;
+  }
+}
+async function checkAndPreparePackage() {
+  if (isValidBinaryPath(STATIC_SERVE_BINARY_PATH)) {
+    if (!fs2.existsSync(STATIC_SERVE_BINARY_PATH)) {
+      console.warn(`[static-serve] Ignoring bad configuration: STATIC_SERVE_BINARY_PATH=${STATIC_SERVE_BINARY_PATH}`);
+    } else {
+      applyManualBinaryPathOverride(STATIC_SERVE_BINARY_PATH);
+      return;
+    }
+  }
+  const { pkg, subpath } = pkgAndSubpathForCurrentPlatform();
+  let binPath;
+  let downloadedBinPathToCleanup;
+  try {
+    binPath = require.resolve(`${pkg}/${subpath}`);
+  } catch (e) {
+    console.error(`[static-serve] Failed to find package "${pkg}" on the file system
+
+This can happen if you use the "--no-optional" flag. The "optionalDependencies"
+package.json feature is used by static-serve to install the correct binary executable
+for your current platform. This install script will now attempt to work around
+this. If that fails, you need to remove the "--no-optional" flag to use static-serve.
+`);
+    binPath = downloadedBinPath(pkg, subpath);
+    try {
+      console.error(`[static-serve] Trying to install package "${pkg}" using npm`);
+      installUsingNPM(pkg, subpath, binPath);
+    } catch (e2) {
+      console.error(`[static-serve] Failed to install package "${pkg}" using npm: ${e2 && e2.message || e2}`);
+      try {
+        await downloadDirectlyFromNPM(pkg, subpath, binPath);
+        downloadedBinPathToCleanup = binPath;
+      } catch (e3) {
+        throw new Error(`Failed to install package "${pkg}"`);
+      }
+    }
+  }
+  maybeOptimizePackage(binPath);
+  if (downloadedBinPathToCleanup && !isToPathJS) {
+    try {
+      fs2.unlinkSync(downloadedBinPathToCleanup);
+    } catch {
+    }
+  }
+}
+checkAndPreparePackage().then(() => {
+  if (isToPathJS) {
+    validateBinaryVersion(process.execPath, toPath);
+  } else {
+    validateBinaryVersion(toPath);
+  }
+});

package/main.js

@@ -0,0 +1,26 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// lib/npm/main.ts
+var main_exports = {};
+__export(main_exports, {
+  default: () => main_default
+});
+module.exports = __toCommonJS(main_exports);
+var main_default = {};

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@tdio/static-serve",
-  "version": "0.0.4",
+  "version": "0.0.5-dev.5",
   "description": "A simple, lightweight static file server written in Go, designed with features for modern web application serving",
+  "main": "main.js",
   "bin": {
-    "static-serve": "./bin/cli.js"
+    "static-serve": "bin/static-serve"
   },
   "author": "allex <allex.wxn@gmail.com> (http://iallex.com/)",
   "repository": {
@@ -20,15 +21,22 @@
     "arm64"
   ],
   "files": [
-    "bin/cli.js"
+    "bin",
+    "install.js"
   ],
   "license": "MIT",
+  "scripts": {
+    "postinstall": "node install.js"
+  },
   "optionalDependencies": {
-    "@tdio/static-serve-darwin-x64": "0.0.4",
-    "@tdio/static-serve-darwin-arm64": "0.0.4",
-    "@tdio/static-serve-linux-x64": "0.0.4",
-    "@tdio/static-serve-linux-arm64": "0.0.4",
-    "@tdio/static-serve-win32-x64": "0.0.4",
-    "@tdio/static-serve-win32-arm64": "0.0.4"
+    "@tdio/static-serve-darwin-x64": "0.0.5-dev.5",
+    "@tdio/static-serve-darwin-arm64": "0.0.5-dev.5",
+    "@tdio/static-serve-linux-x64": "0.0.5-dev.5",
+    "@tdio/static-serve-linux-arm64": "0.0.5-dev.5",
+    "@tdio/static-serve-win32-x64": "0.0.5-dev.5",
+    "@tdio/static-serve-win32-arm64": "0.0.5-dev.5"
+  },
+  "engines": {
+    "node": ">=18"
   }
 }

package/bin/cli.js

@@ -1,51 +0,0 @@
-#!/usr/bin/env node
-
-const { spawn } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-
-const PACKAGE_PREFIX = 'static-serve'; // Must match build-npm.js
-const PACKAGE_SCOPE = '@tdio'; // Must match build-npm.js
-
-// Map generic 'x64' to Node's arch if needed, but usually they match.
-// Node: x64, arm64, ia32, etc.
-const platform = process.platform;
-const arch = process.arch;
-
-const targetPackage = `${PACKAGE_SCOPE}/${PACKAGE_PREFIX}-${platform}-${arch}`
-
-let binaryPath;
-
-try {
-  // Resolve the package.json of the platform-specific package
-  // This throws if the package is not installed
-  const pkgJsonPath = require.resolve(`${targetPackage}/package.json`);
-  const pkgDir = path.dirname(pkgJsonPath);
-
-  // Binary name is predictable: static-serve on Unix, static-serve.exe on Windows
-  const binFile = platform === 'win32' ? `${PACKAGE_PREFIX}.exe` : PACKAGE_PREFIX;
-  binaryPath = path.join(pkgDir, binFile);
-
-} catch (err) {
-  // Fallback: Check if we are running from the source repo/local build
-  // Useful for development
-  const localBuildPath = path.join(__dirname, '..', 'out', `${PACKAGE_PREFIX}-${platform === 'win32' ? 'windows' : platform}-${arch === 'x64' ? 'amd64' : arch}${platform === 'win32' ? '.exe' : ''}`);
-
-  if (fs.existsSync(localBuildPath)) {
-    binaryPath = localBuildPath;
-  } else {
-    console.error(`Failed to locate binary for ${platform}-${arch}.`);
-    console.error(`Tried package: ${targetPackage}`);
-    console.error(`Error: ${err.message}`);
-    process.exit(1);
-  }
-}
-
-const child = spawn(binaryPath, process.argv.slice(2), {
-  stdio: 'inherit'
-});
-
-child.on('exit', (code) => {
-  process.exit(code);
-});
-