@drops-it/dpm 1.0.6 → 1.1.1

package/dist/runtime.js

@@ -0,0 +1,234 @@
+import { execFileSync, spawn, spawnSync } from "node:child_process";
+import { access, chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { readdirSync, statSync } from "node:fs";
+import { homedir, platform, tmpdir } from "node:os";
+import path from "node:path";
+/** Pinned managed runtime version (oven-sh/bun release tag without prefix). */
+export const RUNTIME_VERSION = "1.2.19";
+const RUNTIME_NAME = process.platform === "win32" ? "dpm-runtime.exe" : "dpm-runtime";
+function runtimeRoot() {
+    if (process.env.DPM_RUNTIME_DIR)
+        return process.env.DPM_RUNTIME_DIR;
+    if (process.platform === "win32") {
+        const base = process.env.LOCALAPPDATA || path.join(homedir(), "AppData", "Local");
+        return path.join(base, "Programs", "DPM", "runtime");
+    }
+    return path.join(homedir(), ".dpm", "runtime");
+}
+export function managedRuntimePath() {
+    return path.join(runtimeRoot(), RUNTIME_NAME);
+}
+async function exists(p) {
+    try {
+        await access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function assetForPlatform() {
+    const os = platform();
+    const arch = process.arch;
+    if (os === "win32") {
+        return {
+            asset: arch === "arm64" ? "bun-windows-x64.zip" : "bun-windows-x64.zip",
+            isZip: true,
+        };
+    }
+    if (os === "darwin") {
+        return {
+            asset: arch === "arm64" ? "bun-darwin-aarch64.zip" : "bun-darwin-x64.zip",
+            isZip: true,
+        };
+    }
+    // linux
+    if (arch === "arm64") {
+        return { asset: "bun-linux-aarch64.zip", isZip: true };
+    }
+    return { asset: "bun-linux-x64.zip", isZip: true };
+}
+function releaseUrl(asset) {
+    return `https://github.com/oven-sh/bun/releases/download/bun-v${RUNTIME_VERSION}/${asset}`;
+}
+async function downloadFile(url, dest) {
+    const res = await fetch(url, {
+        headers: { "user-agent": "dpm-runtime-installer" },
+        redirect: "follow",
+    });
+    if (!res.ok) {
+        throw new Error(`DPM runtime download failed (${res.status}).`);
+    }
+    await mkdir(path.dirname(dest), { recursive: true });
+    await writeFile(dest, Buffer.from(await res.arrayBuffer()));
+}
+async function extractZip(zipPath, destDir) {
+    await mkdir(destDir, { recursive: true });
+    if (process.platform === "win32") {
+        const ps = `
+$ErrorActionPreference = 'Stop'
+Expand-Archive -LiteralPath '${zipPath.replace(/'/g, "''")}' -DestinationPath '${destDir.replace(/'/g, "''")}' -Force
+`;
+        execFileSync("powershell", ["-NoProfile", "-NonInteractive", "-Command", ps], { windowsHide: true, stdio: "ignore" });
+    }
+    else {
+        execFileSync("unzip", ["-o", zipPath, "-d", destDir], { stdio: "ignore" });
+    }
+    const walk = (dir) => {
+        for (const name of readdirSync(dir)) {
+            const full = path.join(dir, name);
+            const st = statSync(full);
+            if (st.isDirectory()) {
+                const found = walk(full);
+                if (found)
+                    return found;
+            }
+            else if (/^bun(\.exe)?$/i.test(name)) {
+                return full;
+            }
+        }
+        return null;
+    };
+    const binary = walk(destDir);
+    if (!binary)
+        throw new Error("DPM runtime archive did not contain a binary.");
+    return binary;
+}
+/**
+ * Ensures the managed DPM runtime binary exists at a stable path.
+ * Downloads a pinned release from GitHub when missing or version-mismatched.
+ */
+export async function ensureRuntime() {
+    if (process.env.DPM_RUNTIME && (await exists(process.env.DPM_RUNTIME))) {
+        return process.env.DPM_RUNTIME;
+    }
+    const target = managedRuntimePath();
+    const versionFile = path.join(runtimeRoot(), "version");
+    if (await exists(target) && (await exists(versionFile))) {
+        const v = (await readFile(versionFile, "utf8")).trim();
+        if (v === RUNTIME_VERSION)
+            return target;
+    }
+    const { asset } = assetForPlatform();
+    const url = releaseUrl(asset);
+    const tmpDir = path.join(tmpdir(), `dpm-runtime-${Date.now()}`);
+    await mkdir(tmpDir, { recursive: true });
+    const zipPath = path.join(tmpDir, asset);
+    try {
+        process.stderr.write("Installing DPM runtime…\n");
+        await downloadFile(url, zipPath);
+        const extracted = await extractZip(zipPath, path.join(tmpDir, "out"));
+        await mkdir(runtimeRoot(), { recursive: true });
+        const tmpTarget = `${target}.tmp`;
+        await rm(tmpTarget, { force: true });
+        // copy via read/write for cross-device moves
+        const data = await readFile(extracted);
+        await writeFile(tmpTarget, data);
+        if (process.platform !== "win32")
+            await chmod(tmpTarget, 0o755);
+        await rm(target, { force: true });
+        await rename(tmpTarget, target);
+        await writeFile(versionFile, `${RUNTIME_VERSION}\n`);
+        return target;
+    }
+    finally {
+        await rm(tmpDir, { recursive: true, force: true });
+    }
+}
+/**
+ * Resolves a runnable runtime path: managed binary, else PATH fallback branded as DPM.
+ */
+export async function resolveRuntime() {
+    try {
+        return await ensureRuntime();
+    }
+    catch (err) {
+        const fallback = process.platform === "win32" ? "bun.exe" : "bun";
+        const which = spawnSync(process.platform === "win32" ? "where" : "which", [fallback.replace(/\.exe$/, "")], {
+            encoding: "utf8",
+            windowsHide: true,
+        });
+        if (which.status === 0 && which.stdout?.trim()) {
+            return which.stdout.trim().split(/\r?\n/)[0];
+        }
+        const msg = err instanceof Error ? err.message : String(err);
+        throw new Error(`DPM runtime is not available (${msg}). Re-run the DPM installer or set DPM_RUNTIME.`);
+    }
+}
+function brandStderr(chunk) {
+    return Buffer.from(chunk
+        .toString("utf8")
+        .replace(/\bBun\b/g, "DPM")
+        .replace(/\bbun\b/g, "dpm"));
+}
+/**
+ * Spawns the managed runtime with inherited stdio and returns the exit code.
+ */
+export async function spawnRuntime(opts) {
+    const bin = await resolveRuntime();
+    const env = {
+        ...process.env,
+        ...opts.env,
+        // Keep npm-compatible clients pointed at DPM when nested tools spawn.
+        npm_config_registry: opts.env?.npm_config_registry ?? process.env.npm_config_registry,
+    };
+    return new Promise((resolve, reject) => {
+        const child = spawn(bin, opts.args, {
+            cwd: opts.cwd ?? process.cwd(),
+            env,
+            stdio: opts.brandOutput ? ["inherit", "inherit", "pipe"] : "inherit",
+            windowsHide: true,
+        });
+        if (opts.brandOutput && child.stderr) {
+            child.stderr.on("data", (chunk) => {
+                process.stderr.write(brandStderr(chunk));
+            });
+        }
+        child.on("error", reject);
+        child.on("close", (code) => resolve(code ?? 1));
+    });
+}
+/**
+ * Resolves the install registry URL.
+ * DPM hosts use the `/npm` facade; plain npmjs (or DPM_BOOTSTRAP=1) uses the URL as-is.
+ */
+export function resolveInstallRegistryUrl(registry) {
+    const base = registry.replace(/\/$/, "").replace(/\/npm$/i, "");
+    const bootstrap = process.env.DPM_BOOTSTRAP === "1" ||
+        /registry\.npmjs\.org/i.test(base) ||
+        process.env.DPM_USE_NPM_UPSTREAM === "1";
+    if (bootstrap)
+        return `${base}/`;
+    return `${base}/npm/`;
+}
+/**
+ * Writes project-local registry config so the runtime installer hits the DPM npm facade
+ * (or npmjs when bootstrapping / pointed at registry.npmjs.org).
+ */
+export async function ensureInstallConfig(config, cwd = process.cwd()) {
+    const registryUrl = resolveInstallRegistryUrl(config.registry);
+    const host = new URL(registryUrl).host;
+    const pathPrefix = registryUrl.includes("/npm") ? "/npm" : "";
+    const npmrcLines = [
+        `registry=${registryUrl}`,
+        `//${host}${pathPrefix}/:_authToken=${config.token ?? ""}`,
+    ];
+    await writeFile(path.join(cwd, ".npmrc"), `${npmrcLines.join("\n")}\n`, { mode: 0o600 });
+    const bunfig = `[install]
+registry = "${registryUrl}"
+`;
+    await writeFile(path.join(cwd, "bunfig.toml"), bunfig);
+}
+/** Builds npm_config_* env for a one-shot install without relying only on files. */
+export function runtimeInstallEnv(config) {
+    const registryUrl = resolveInstallRegistryUrl(config.registry);
+    return {
+        npm_config_registry: registryUrl,
+        ...(config.token
+            ? {
+                npm_config__authToken: config.token,
+                BUN_CONFIG_TOKEN: config.token,
+            }
+            : {}),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drops-it/dpm",
-  "version": "1.0.6",
+  "version": "1.1.1",
   "description": "Drops Package Manager CLI",
   "type": "module",
   "bin": {
@@ -9,9 +9,6 @@
   "files": [
     "dist"
   ],
-  "engines": {
-    "node": ">=22"
-  },
   "scripts": {
     "dev": "tsx src/index.ts",
     "build": "tsc -p tsconfig.json",
@@ -26,8 +23,7 @@
     "commander": "^12.1.0",
     "semver": "^7.6.3",
     "tar": "^7.4.3",
-    "yaml": "^2.7.0",
-    "magmastream": "^2.10.2"
+    "yaml": "^2.7.0"
   },
   "devDependencies": {
     "@types/node": "^22.10.5",