php-composer-cli 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 gh110919
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,101 @@
+# php-composer-cli
+
+An **npm CLI package** that automatically downloads **PHP** and **Composer** for your current platform and exposes them as `php` and `composer` terminal commands.
+
+## Supported platforms
+
+| OS      | Arch  | PHP binary source                                                                           |
+|---------|-------|---------------------------------------------------------------------------------------------|
+| Linux   | x64   | [crazywhalecc/static-php-cli](https://github.com/crazywhalecc/static-php-cli)              |
+| Linux   | arm64 | [crazywhalecc/static-php-cli](https://github.com/crazywhalecc/static-php-cli)              |
+| macOS   | x64   | [crazywhalecc/static-php-cli](https://github.com/crazywhalecc/static-php-cli)              |
+| macOS   | arm64 | [crazywhalecc/static-php-cli](https://github.com/crazywhalecc/static-php-cli)              |
+| Windows | x64   | [shivammathur/php-builder-windows](https://github.com/shivammathur/php-builder-windows)    |
+
+PHP version is resolved from [php/php-src](https://github.com/php/php-src) releases.  
+Composer is resolved from [composer/composer](https://github.com/composer/composer) releases.
+
+## Installation
+
+### Global (recommended)
+
+```bash
+npm install -g php-composer-cli
+```
+
+During install, the `postinstall` script automatically downloads the correct PHP binary and `composer.phar` into the package's `dist/` folder.
+
+### Local (per-project)
+
+```bash
+npm install php-composer-cli
+npx php --version
+npx composer --version
+```
+
+## Usage
+
+After a global install:
+
+```bash
+# Check versions
+php --version
+composer --version
+
+# Run a PHP script
+php my-script.php
+
+# Create a new Laravel project
+composer create-project laravel/laravel my-app
+
+# Install dependencies from composer.json
+composer install
+
+# Add a package
+composer require guzzlehttp/guzzle
+```
+
+## Project structure
+
+```
+php-composer-cli/
+├── bin/
+│   ├── php.js          # `php` CLI wrapper
+│   └── composer.js     # `composer` CLI wrapper
+├── dist/               # Downloaded binaries (created at install time)
+│   ├── php  /  php.exe
+│   └── composer.phar
+├── lib/
+│   ├── github.js       # GitHub Releases API helpers
+│   ├── platform.js     # Platform detection + version resolution via GitHub API
+│   └── download.js     # HTTP download + archive extraction
+├── install.js          # postinstall script
+└── package.json
+```
+
+## How it works
+
+1. `npm install` triggers the `postinstall` script (`install.js`).
+2. The script detects the OS and CPU architecture.
+3. **PHP version** is resolved via the [GitHub Releases API](https://api.github.com/repos/php/php-src/releases/latest) of the official **[php/php-src](https://github.com/php/php-src)** repository.
+4. **PHP binary** (precompiled static executable) is downloaded from GitHub releases — no build step required:
+   - **Windows x64**: [shivammathur/php-builder-windows](https://github.com/shivammathur/php-builder-windows) — official prebuilt NTS ZIPs
+   - **Linux / macOS**: [crazywhalecc/static-php-cli](https://github.com/crazywhalecc/static-php-cli) — static builds compiled from [php/php-src](https://github.com/php/php-src)
+5. **Composer** (`composer.phar`) is downloaded from **[composer/composer](https://github.com/composer/composer/releases)** GitHub releases — the official Composer repository.
+6. Both are placed in `dist/`.
+7. `bin/php.js` and `bin/composer.js` are thin wrappers that delegate all CLI arguments via `child_process.spawnSync`.
+
+## Updating PHP / Composer
+
+To force a fresh download (e.g. after a new PHP or Composer release), delete `dist/` and run `npm install` again:
+
+```bash
+rm -rf node_modules/php-composer-cli/dist
+npm install
+```
+
+Versions are always resolved dynamically from GitHub — no manual edits needed.
+
+## License
+
+MIT

package/bin/composer.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+"use strict";
+
+const { spawnSync } = require("child_process");
+const { existsSync } = require("fs");
+const { platform } = require("os");
+const { join } = require("path");
+
+const DIST = join(__dirname, "..", "dist");
+
+const phpBin =
+  platform() === "win32" ? join(DIST, "php.exe") : join(DIST, "php");
+
+const composerPhar = join(DIST, "composer.phar");
+
+if (!existsSync(phpBin)) {
+  console.error(
+    "[php-composer-cli] PHP binary not found.\n" +
+    "  If you installed with --ignore-scripts, run once:\n" +
+    "  node node_modules/php-composer-cli/install.js\n" +
+    `  Expected binary: ${phpBin}`,
+  );
+  process.exit(1);
+}
+
+if (!existsSync(composerPhar)) {
+  console.error(
+    "[php-composer-cli] composer.phar not found.\n" +
+    "  If you installed with --ignore-scripts, run once:\n" +
+    "  node node_modules/php-composer-cli/install.js\n" +
+    `  Expected: ${composerPhar}`,
+  );
+  process.exit(1);
+}
+
+const result = spawnSync(phpBin, [composerPhar, ...process.argv.slice(2)], {
+  stdio: "inherit",
+  env: process.env,
+});
+
+process.exit(result.status ?? 1);

package/bin/php.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+"use strict";
+
+const { spawnSync } = require("child_process");
+const { existsSync } = require("fs");
+const { platform } = require("os");
+const { join } = require("path");
+
+const DIST = join(__dirname, "..", "dist");
+const phpBin =
+  platform() === "win32" ? join(DIST, "php.exe") : join(DIST, "php");
+
+if (!existsSync(phpBin)) {
+  console.error(
+    "[php-composer-cli] PHP binary not found.\n" +
+    "  If you installed with --ignore-scripts, run once:\n" +
+    "  node node_modules/php-composer-cli/install.js\n" +
+    `  Expected binary: ${phpBin}`,
+  );
+  process.exit(1);
+}
+
+const result = spawnSync(phpBin, process.argv.slice(2), {
+  stdio: "inherit",
+  env: process.env,
+});
+
+process.exit(result.status ?? 1);

package/install.js

@@ -0,0 +1,146 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const {
+  detectPlatform,
+  getPhpDownloadInfo,
+  getComposerDownloadUrl,
+  getDistDir,
+} = require("./lib/platform");
+
+const { download, extractZip, extractTarGz } = require("./lib/download");
+
+async function main() {
+  console.log("\n[php-composer-cli] Checking for PHP + Composer binaries...");
+  console.log(
+    "  PHP version  → github.com/php/php-src\n" +
+      "  PHP Windows  → github.com/shivammathur/php-builder-windows\n" +
+      "  PHP Linux    → github.com/crazywhalecc/static-php-cli (static build from php/php-src)\n" +
+      "  PHP macOS    → github.com/crazywhalecc/static-php-cli (static build from php/php-src)\n" +
+      "  Composer     → github.com/composer/composer\n",
+  );
+
+  let platformInfo;
+  try {
+    platformInfo = detectPlatform();
+  } catch (err) {
+    console.error("[php-composer-cli] ERROR:", err.message);
+    process.exit(1);
+  }
+
+  const DIST = getDistDir();
+  fs.mkdirSync(DIST, { recursive: true });
+
+  console.log("[php-composer-cli] Resolving PHP download via GitHub API...");
+
+  let phpInfo;
+  try {
+    phpInfo = await getPhpDownloadInfo();
+  } catch (err) {
+    console.error(
+      "[php-composer-cli] Failed to resolve PHP download info:",
+      err.message,
+    );
+    process.exit(1);
+  }
+
+  const { phpUrl, phpBinary, archiveExt, phpVersion, source } = phpInfo;
+  const phpDest = path.join(DIST, phpBinary);
+
+  if (fs.existsSync(phpDest)) {
+    console.log(`[php-composer-cli] PHP already present → ${phpDest}`);
+  } else {
+    console.log(
+      `[php-composer-cli] Downloading PHP ${phpVersion} from ${source}...`,
+    );
+    console.log(`  ${phpUrl}`);
+
+    const archivePath = path.join(DIST, `php-archive.${archiveExt}`);
+
+    try {
+      await download(phpUrl, archivePath);
+    } catch (err) {
+      console.error(
+        "\n[php-composer-cli] Failed to download PHP:",
+        err.message,
+      );
+      process.exit(1);
+    }
+
+    console.log("[php-composer-cli] Extracting PHP...");
+    try {
+      if (archiveExt === "zip") {
+        await extractZip(archivePath, DIST);
+      } else {
+        await extractTarGz(archivePath, DIST);
+      }
+    } catch (err) {
+      console.error("[php-composer-cli] Failed to extract PHP:", err.message);
+      process.exit(1);
+    }
+
+    try {
+      fs.unlinkSync(archivePath);
+    } catch (_) {}
+
+    if (!platformInfo.isWindows) {
+      try {
+        fs.chmodSync(phpDest, 0o755);
+      } catch (_) {}
+    }
+
+    console.log(`[php-composer-cli] PHP ${phpVersion} installed → ${phpDest}`);
+  }
+
+  const composerDest = path.join(DIST, "composer.phar");
+
+  if (fs.existsSync(composerDest)) {
+    console.log(
+      `[php-composer-cli] Composer already present → ${composerDest}`,
+    );
+  } else {
+    console.log(
+      "\n[php-composer-cli] Resolving Composer download via GitHub API...",
+    );
+
+    let composerInfo;
+    try {
+      composerInfo = await getComposerDownloadUrl();
+    } catch (err) {
+      console.error(
+        "[php-composer-cli] Failed to resolve Composer download info:",
+        err.message,
+      );
+      process.exit(1);
+    }
+
+    const { composerUrl, composerVersion } = composerInfo;
+    console.log(
+      `[php-composer-cli] Downloading Composer ${composerVersion}...`,
+    );
+    console.log(`  ${composerUrl}`);
+
+    try {
+      await download(composerUrl, composerDest);
+    } catch (err) {
+      console.error(
+        "\n[php-composer-cli] Failed to download Composer:",
+        err.message,
+      );
+      process.exit(1);
+    }
+
+    console.log(`[php-composer-cli] Composer installed → ${composerDest}`);
+  }
+
+  console.log(
+    "\n[php-composer-cli] Ready!  Use `php` and `composer` commands.\n",
+  );
+}
+
+main().catch((err) => {
+  console.error("[php-composer-cli] Unexpected error:", err);
+  process.exit(1);
+});

package/lib/download.js

@@ -0,0 +1,97 @@
+"use strict";
+
+const https = require("https");
+const http = require("http");
+const fs = require("fs");
+
+const DEFAULT_HEADERS = {
+  "User-Agent":
+    "Mozilla/5.0 (compatible; php-composer-npm-cli/1.0; +https://github.com)",
+  Accept: "*/*",
+};
+
+function getInto(url, outFile, resolve, reject) {
+  const client = url.startsWith("https") ? https : http;
+  const parsed = new URL(url);
+  const options = {
+    hostname: parsed.hostname,
+    path: parsed.pathname + parsed.search,
+    method: "GET",
+    headers: DEFAULT_HEADERS,
+  };
+
+  client
+    .request(options, (res) => {
+      if (
+        [301, 302, 307, 308].includes(res.statusCode) &&
+        res.headers.location
+      ) {
+        const next = res.headers.location.startsWith("http")
+          ? res.headers.location
+          : `${parsed.protocol}//${parsed.host}${res.headers.location}`;
+        res.resume();
+        return getInto(next, outFile, resolve, reject);
+      }
+
+      if (res.statusCode !== 200) {
+        outFile.close();
+        return reject(
+          new Error(`Download failed. Status: ${res.statusCode} — ${url}`),
+        );
+      }
+
+      const total = parseInt(res.headers["content-length"] || "0", 10);
+      let received = 0;
+      let lastPct = -1;
+
+      res.on("data", (chunk) => {
+        received += chunk.length;
+        if (total) {
+          const pct = Math.floor((received / total) * 100);
+          if (pct !== lastPct && pct % 10 === 0) {
+            process.stdout.write(`\r  ${pct}%`);
+            lastPct = pct;
+          }
+        }
+      });
+
+      res.pipe(outFile);
+
+      outFile.on("finish", () => {
+        process.stdout.write("\r  100%\n");
+        outFile.close(resolve);
+      });
+
+      outFile.on("error", (err) => {
+        reject(err);
+      });
+    })
+    .on("error", reject)
+    .end();
+}
+
+function download(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+    file.on("error", (err) => {
+      try {
+        fs.unlinkSync(dest);
+      } catch (_) {}
+      reject(err);
+    });
+    getInto(url, file, resolve, reject);
+  });
+}
+
+async function extractZip(zipPath, destDir) {
+  const AdmZip = require("adm-zip");
+  const zip = new AdmZip(zipPath);
+  zip.extractAllTo(destDir, true);
+}
+
+async function extractTarGz(tgzPath, destDir) {
+  const tar = require("tar");
+  await tar.x({ file: tgzPath, cwd: destDir, strip: 0 });
+}
+
+module.exports = { download, extractZip, extractTarGz };

package/lib/github.js

@@ -0,0 +1,111 @@
+"use strict";
+
+const https = require("https");
+
+function ghGet(apiPath) {
+  return new Promise((resolve, reject) => {
+    const headers = {
+      "User-Agent": "php-composer-npm-cli/1.0 (node.js)",
+      Accept: "application/vnd.github+json",
+    };
+
+    if (process.env.GITHUB_TOKEN) {
+      headers["Authorization"] = `Bearer ${process.env.GITHUB_TOKEN}`;
+    }
+
+    const req = https.request(
+      { hostname: "api.github.com", path: apiPath, method: "GET", headers },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          if (res.statusCode === 301 || res.statusCode === 302) {
+            return ghGetUrl(res.headers.location).then(resolve).catch(reject);
+          }
+          if (res.statusCode === 403 || res.statusCode === 429) {
+            const reset = res.headers["x-ratelimit-reset"];
+            const resetTime = reset
+              ? new Date(parseInt(reset, 10) * 1000).toLocaleTimeString()
+              : "unknown";
+            return reject(
+              new Error(
+                `GitHub API rate limit exceeded (${res.statusCode}).\n` +
+                `Resets at: ${resetTime}\n` +
+                `Tip: set the GITHUB_TOKEN env variable to raise the limit to 5000 req/hr.`,
+              ),
+            );
+          }
+          if (res.statusCode !== 200) {
+            return reject(
+              new Error(`GitHub API error ${res.statusCode}: ${apiPath}\n${data}`),
+            );
+          }
+          try {
+            resolve(JSON.parse(data));
+          } catch (e) {
+            reject(new Error(`Failed to parse GitHub API response: ${e.message}`));
+          }
+        });
+      },
+    );
+
+    req.setTimeout(15000, () => {
+      req.destroy(new Error(`GitHub API request timed out: ${apiPath}`));
+    });
+    req.on("error", reject);
+    req.end();
+  });
+}
+
+function ghGetUrl(url) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const req = https.request(
+      {
+        hostname: parsed.hostname,
+        path: parsed.pathname + parsed.search,
+        method: "GET",
+        headers: {
+          "User-Agent": "php-composer-npm-cli/1.0",
+          Accept: "application/vnd.github+json",
+        },
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (c) => (data += c));
+        res.on("end", () => {
+          if (res.statusCode !== 200)
+            return reject(new Error(`HTTP ${res.statusCode} at ${url}`));
+          try {
+            resolve(JSON.parse(data));
+          } catch (e) {
+            reject(e);
+          }
+        });
+      },
+    );
+    req.setTimeout(15000, () => {
+      req.destroy(new Error(`Request timed out: ${url}`));
+    });
+    req.on("error", reject);
+    req.end();
+  });
+}
+
+async function getLatestRelease(owner, repo) {
+  return ghGet(`/repos/${owner}/${repo}/releases/latest`);
+}
+
+async function ghGetTag(owner, repo, tag) {
+  return ghGet(`/repos/${owner}/${repo}/releases/tags/${tag}`);
+}
+
+function findAsset(release, pattern) {
+  const test =
+    pattern instanceof RegExp
+      ? (n) => pattern.test(n)
+      : (n) => n.includes(pattern);
+  return release.assets.find((a) => test(a.name));
+}
+
+module.exports = { getLatestRelease, ghGetTag, findAsset };

package/lib/platform.js

@@ -0,0 +1,115 @@
+"use strict";
+
+const os = require("os");
+const path = require("path");
+const { getLatestRelease, ghGetTag, findAsset } = require("./github");
+
+function detectPlatform() {
+  const platform = os.platform();
+  const arch = os.arch();
+  const isWindows = platform === "win32";
+  const isMac = platform === "darwin";
+  const isLinux = platform === "linux";
+
+  if (!isWindows && !isMac && !isLinux)
+    throw new Error(`Unsupported platform: ${platform}`);
+  if (arch !== "x64" && arch !== "arm64")
+    throw new Error(`Unsupported architecture: ${arch}`);
+
+  return { platform, arch, isWindows, isMac, isLinux };
+}
+
+async function getLatestPhpVersion() {
+  const release = await getLatestRelease("php", "php-src");
+  return release.tag_name.replace(/^php-/, "");
+}
+
+async function resolveWindowsPhpUrl(phpVersion) {
+  const [major, minor] = phpVersion.split(".");
+  const tag = `php${major}.${minor}`;
+
+  const release = await ghGetTag("shivammathur", "php-builder-windows", tag);
+
+  const asset = findAsset(
+    release,
+    /^php-(\d+\.\d+\.\d+)-nts-Win32-vs\d+-x64\.zip$/,
+  );
+
+  if (!asset) {
+    const names = release.assets.map((a) => "  " + a.name).join("\n");
+    throw new Error(
+      `No stable NTS x64 ZIP found in shivammathur/php-builder-windows ` +
+        `release ${tag}.\nAvailable:\n${names}`,
+    );
+  }
+
+  const versionMatch = asset.name.match(/^php-([\d.]+)-nts/);
+  const resolvedVersion = versionMatch ? versionMatch[1] : phpVersion;
+
+  console.log(
+    `[php-composer-cli] Windows PHP (github.com/shivammathur/php-builder-windows): ${asset.name}`,
+  );
+  return { url: asset.browser_download_url, version: resolvedVersion };
+}
+
+function resolveUnixPhpUrl(phpVersion, isMac, arch) {
+  const osSuffix = isMac ? "macos" : "linux";
+  const archSuffix = arch === "arm64" ? "aarch64" : "x86_64";
+  return `https://dl.static-php.dev/static-php-cli/common/php-${phpVersion}-cli-${osSuffix}-${archSuffix}.tar.gz`;
+}
+
+async function getPhpDownloadInfo() {
+  const { isWindows, isMac, arch } = detectPlatform();
+
+  const phpVersion = await getLatestPhpVersion();
+  console.log(
+    `[php-composer-cli] Latest PHP (github.com/php/php-src): ${phpVersion}`,
+  );
+
+  let phpUrl, phpBinary, archiveExt, source, resolvedVersion;
+
+  if (isWindows) {
+    const win = await resolveWindowsPhpUrl(phpVersion);
+    phpUrl = win.url;
+    resolvedVersion = win.version;
+    phpBinary = "php.exe";
+    archiveExt = "zip";
+    source = "github.com/shivammathur/php-builder-windows";
+  } else {
+    phpUrl = resolveUnixPhpUrl(phpVersion, isMac, arch);
+    resolvedVersion = phpVersion;
+    phpBinary = "php";
+    archiveExt = "tar.gz";
+    source =
+      "github.com/crazywhalecc/static-php-cli (static build from php/php-src)";
+  }
+
+  return { phpUrl, phpBinary, archiveExt, phpVersion: resolvedVersion, source };
+}
+
+async function getComposerDownloadUrl() {
+  const release = await getLatestRelease("composer", "composer");
+  const version = release.tag_name;
+
+  const asset = findAsset(release, /^composer\.phar$/);
+  const composerUrl = asset
+    ? asset.browser_download_url
+    : `https://github.com/composer/composer/releases/download/${version}/composer.phar`;
+
+  console.log(
+    `[php-composer-cli] Latest Composer (github.com/composer/composer): ${version}`,
+  );
+  return { composerUrl, composerVersion: version };
+}
+
+function getDistDir() {
+  return path.join(__dirname, "..", "dist");
+}
+
+module.exports = {
+  detectPlatform,
+  getLatestPhpVersion,
+  getPhpDownloadInfo,
+  getComposerDownloadUrl,
+  getDistDir,
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "author": "gh110919",
+  "bin": {
+    "composer": "bin/composer.js",
+    "php": "bin/php.js"
+  },
+  "bugs": {
+    "url": "https://github.com/gh110919/php-composer-cli/issues"
+  },
+  "dependencies": {
+    "adm-zip": "^0.5.10",
+    "tar": "^7.5.9"
+  },
+  "description": "PHP and Composer as npm CLI package — automatically downloads PHP binaries and Composer for the current platform",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "install.js",
+    "README.md"
+  ],
+  "homepage": "https://github.com/gh110919/php-composer-cli#readme",
+  "keywords": [
+    "php",
+    "composer",
+    "cli",
+    "bin",
+    "php-cli",
+    "php-binary"
+  ],
+  "license": "MIT",
+  "name": "php-composer-cli",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gh110919/php-composer-cli.git"
+  },
+  "scripts": {
+    "_login": "npm login && npm whoami",
+    "_publish": "bash cmd/publish.sh",
+    "postinstall": "node install.js"
+  },
+  "type": "commonjs",
+  "version": "1.0.0"
+}