@drops-it/dpm 1.0.5 → 1.1.1

package/dist/install.js

@@ -1,63 +1,38 @@
-import { createHash } from "node:crypto";
-import { execFile, exec } from "node:child_process";
-import { access, mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { homedir, tmpdir } from "node:os";
+import { access, readdir, readFile, rm, stat } from "node:fs/promises";
+import { homedir } from "node:os";
 import path from "node:path";
-import { promisify } from "node:util";
 import * as tar from "tar";
-import semver from "semver";
 import { auditPackages, formatAuditReport, proposeFixes, } from "./audit.js";
 import { c } from "./colors.js";
-import { loadLockfile, readPackageJson, saveLockfile, writePackageJson, } from "./config.js";
+import { loadConfig, loadLockfile, readPackageJson, saveLockfile, writePackageJson, } from "./config.js";
+import { ensureInstallConfig, runtimeInstallEnv, spawnRuntime, } from "./runtime.js";
 import { createUi } from "./ui.js";
-const execFileAsync = promisify(execFile);
-const execAsync = promisify(exec);
-function quoteNpmArg(value) {
-    if (!/[ \t"&<>|^]/.test(value))
-        return value;
-    return `"${value.replace(/"/g, '\\"')}"`;
-}
-async function runNpm(args) {
-    if (process.platform === "win32") {
-        const cmdline = ["npm", ...args.map(quoteNpmArg)].join(" ");
-        return execAsync(cmdline, {
-            windowsHide: true,
-            maxBuffer: 10 * 1024 * 1024,
-        });
-    }
-    return execFileAsync("npm", args, {
-        windowsHide: true,
-        maxBuffer: 10 * 1024 * 1024,
-    });
-}
 function asUi(log) {
     if ("status" in log && typeof log.status === "function" && "clearStatus" in log) {
         return log;
     }
     return createUi();
 }
-function integrityOf(buf) {
-    return `sha512-${createHash("sha512").update(buf).digest("base64")}`;
+function setStatus(log, msg) {
+    if (log.status)
+        log.status(msg);
+    else
+        log.info(msg);
 }
-async function extractToNodeModules(name, tarball, cwd) {
-    const target = path.join(cwd, "node_modules", ...name.split("/"));
-    await rm(target, { recursive: true, force: true });
-    await mkdir(target, { recursive: true });
-    const tmp = path.join(cwd, "node_modules", `.dpm-tmp-${Date.now()}-${Math.random().toString(16).slice(2)}.tgz`);
-    await writeFile(tmp, tarball);
-    await tar.x({ file: tmp, cwd: target, strip: 1 });
-    await rm(tmp, { force: true });
+function topLevelDeps(pkg) {
+    return {
+        ...(pkg.dependencies || {}),
+        ...(pkg.devDependencies || {}),
+    };
 }
-function pickVersion(versions, range, distTags, preferred) {
-    // Audit-fix preferred versions always win when present in the registry.
-    if (preferred && versions.includes(preferred))
-        return preferred;
-    if (range === "latest" || range === "*" || range === "") {
-        return distTags.latest ?? semver.maxSatisfying(versions, "*");
+function readOverrides(pkg) {
+    const raw = pkg.overrides || {};
+    const out = {};
+    for (const [name, value] of Object.entries(raw)) {
+        if (typeof value === "string")
+            out[name] = value;
     }
-    if (semver.valid(range))
-        return versions.includes(range) ? range : null;
-    return semver.maxSatisfying(versions, range);
+    return out;
 }
 /** Parse `name`, `name@1.2.3`, `name@^1`, `@scope/name`, `@scope/name@1.0.0`. */
 export function parsePackageSpec(spec) {
@@ -89,196 +64,179 @@ async function ensurePackageJson(cwd, log) {
         return pkg;
     }
 }
-async function resolveRange(api, name, range) {
-    const meta = await api.getPackage(name);
-    if (!meta)
-        throw new Error(`Package not found: ${name}`);
-    if (range === "latest" || range === "*") {
-        const latest = meta.latest || meta["dist-tags"]?.latest;
-        if (!latest)
-            throw new Error(`No versions for ${name}`);
-        return `^${latest}`;
+/**
+ * Builds a DPM lock snapshot from installed node_modules for audit tooling.
+ */
+export async function syncLockFromNodeModules(cwd) {
+    const lock = { lockfileVersion: 1, packages: {} };
+    const root = path.join(cwd, "node_modules");
+    try {
+        await access(root);
     }
-    if (semver.valid(range))
-        return range;
-    return range;
-}
-function setStatus(log, msg) {
-    if (log.status)
-        log.status(msg);
-    else
-        log.info(msg);
-}
-function topLevelDeps(pkg) {
-    return {
-        ...(pkg.dependencies || {}),
-        ...(pkg.devDependencies || {}),
-    };
-}
-function readOverrides(pkg) {
-    const raw = pkg.overrides || {};
-    const out = {};
-    for (const [name, value] of Object.entries(raw)) {
-        if (typeof value === "string")
-            out[name] = value;
+    catch {
+        await saveLockfile(lock, cwd);
+        return lock;
     }
-    return out;
+    async function visit(dir, scope) {
+        let entries;
+        try {
+            entries = await readdir(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry === ".bin" || entry.startsWith("."))
+                continue;
+            const full = path.join(dir, entry);
+            let st;
+            try {
+                st = await stat(full);
+            }
+            catch {
+                continue;
+            }
+            if (!st.isDirectory())
+                continue;
+            if (entry.startsWith("@") && !scope) {
+                await visit(full, entry);
+                continue;
+            }
+            const name = scope ? `${scope}/${entry}` : entry;
+            try {
+                const raw = await readFile(path.join(full, "package.json"), "utf8");
+                const meta = JSON.parse(raw);
+                lock.packages[name] = {
+                    version: meta.version || "0.0.0",
+                    resolved: name,
+                    integrity: "",
+                    source: "dpm",
+                    dependencies: meta.dependencies,
+                };
+            }
+            catch {
+                /* skip broken packages */
+            }
+        }
+    }
+    await visit(root);
+    await saveLockfile(lock, cwd);
+    return lock;
+}
+async function prepareRuntimeInstall(cwd) {
+    const config = await loadConfig();
+    await ensureInstallConfig(config, cwd);
+    return { config, env: runtimeInstallEnv(config) };
 }
-export async function installAll(api, cwd = process.cwd(), log = createUi(), options = {}) {
+/** Installs package.json dependencies via the managed DPM runtime. */
+export async function installAll(_api, cwd = process.cwd(), log = createUi(), options = {}) {
     const ui = asUi(log);
-    const pkg = await ensurePackageJson(cwd, ui);
-    const deps = topLevelDeps(pkg);
-    const entries = Object.entries(deps);
-    if (entries.length === 0) {
-        ui.warn("package.json has no dependencies");
-        await saveLockfile({ lockfileVersion: 1, packages: {} }, cwd);
-        return { lockfileVersion: 1, packages: {} };
-    }
-    ui.info(`${c.cyan("→")} resolving ${c.bold(String(entries.length))} top-level dependenc${entries.length === 1 ? "y" : "ies"}`);
-    const lock = { lockfileVersion: 1, packages: {} };
-    const queue = [...entries];
-    let installed = 0;
-    const started = Date.now();
-    const preferred = {
-        ...readOverrides(pkg),
-        ...(options.preferredVersions || {}),
-    };
-    while (queue.length) {
-        const [name, range] = queue.pop();
-        if (lock.packages[name])
-            continue;
-        const progress = () => {
-            const pending = queue.length + 1;
-            return `${c.dim(`${installed} done · ${pending} left`)}`;
+    await ensurePackageJson(cwd, ui);
+    if (options.preferredVersions && Object.keys(options.preferredVersions).length > 0) {
+        const pkg = await readPackageJson(cwd);
+        const overrides = {
+            ...readOverrides(pkg),
+            ...options.preferredVersions,
         };
-        setStatus(ui, `resolve ${c.bold(name)}@${range}  ${progress()}`);
-        const meta = await api.getPackage(name);
-        if (!meta)
-            throw new Error(`Package not found: ${name}`);
-        const versions = meta.versions.map((v) => v.version);
-        const version = pickVersion(versions, range, meta["dist-tags"] || {}, preferred[name]);
-        if (!version)
-            throw new Error(`No version of ${name} matches ${range}`);
-        const ver = meta.versions.find((v) => v.version === version);
-        const source = meta.source || "dpm";
-        const sourceTag = source === "npm" ? c.magenta("[npm]") : c.blue("[dpm]");
-        setStatus(ui, `download ${c.bold(name)}@${c.green(version)} ${sourceTag}  ${progress()}`);
-        const tarball = await api.downloadTarball(ver.dist.tarball);
-        const integrity = ver.dist.integrity || integrityOf(tarball);
-        setStatus(ui, `extract ${c.bold(name)}@${c.green(version)}  ${progress()}`);
-        await extractToNodeModules(name, tarball, cwd);
-        installed += 1;
-        lock.packages[name] = {
-            version,
-            resolved: ver.dist.tarball,
-            integrity,
-            source,
-            dependencies: ver.dependencies,
-        };
-        for (const [dep, depRange] of Object.entries(ver.dependencies || {})) {
-            if (!lock.packages[dep])
-                queue.push([dep, depRange]);
-        }
+        pkg.overrides = overrides;
+        await writePackageJson(pkg, cwd);
     }
+    const { env } = await prepareRuntimeInstall(cwd);
+    setStatus(ui, "installing dependencies…");
+    const started = Date.now();
+    const code = await spawnRuntime({
+        cwd,
+        args: ["install"],
+        env,
+        brandOutput: true,
+    });
     ui.clearStatus();
-    await saveLockfile(lock, cwd);
+    if (code !== 0) {
+        throw new Error(`install failed (exit ${code})`);
+    }
+    const lock = await syncLockFromNodeModules(cwd);
     const elapsed = ((Date.now() - started) / 1000).toFixed(1);
+    const count = Object.keys(lock.packages).length;
     if (ui.success) {
-        ui.success(`added ${c.bold(String(installed))} package${installed === 1 ? "" : "s"} in ${elapsed}s`);
+        ui.success(`added ${c.bold(String(count))} package${count === 1 ? "" : "s"} in ${elapsed}s`);
     }
     else {
-        ui.info(`added ${installed} package${installed === 1 ? "" : "s"} in ${elapsed}s`);
+        ui.info(`added ${count} package${count === 1 ? "" : "s"} in ${elapsed}s`);
     }
     if (!options.skipAudit) {
         setStatus(ui, "checking vulnerabilities…");
         const hits = await auditPackages(lock.packages);
+        const pkg = await readPackageJson(cwd);
+        const deps = topLevelDeps(pkg);
         const fixes = hits.length
-            ? await proposeFixes(api, lock, hits, deps, true)
+            ? await proposeFixes(_api, lock, hits, deps, true)
             : [];
         ui.clearStatus();
         ui.info(formatAuditReport(hits, fixes));
     }
     return lock;
 }
+/** Adds packages then installs via the managed DPM runtime. */
 export async function addPackages(api, specs, cwd = process.cwd(), log = createUi()) {
     if (specs.length === 0)
         return installAll(api, cwd, log);
     const ui = asUi(log);
-    const pkg = await ensurePackageJson(cwd, ui);
-    const deps = pkg.dependencies || {};
+    await ensurePackageJson(cwd, ui);
+    const { env } = await prepareRuntimeInstall(cwd);
+    setStatus(ui, `add ${specs.join(", ")}`);
+    const code = await spawnRuntime({
+        cwd,
+        args: ["add", ...specs],
+        env,
+        brandOutput: true,
+    });
+    ui.clearStatus();
+    if (code !== 0)
+        throw new Error(`add failed (exit ${code})`);
     for (const spec of specs) {
-        const { name, range } = parsePackageSpec(spec);
-        setStatus(ui, `add ${c.bold(name)}`);
-        const savedRange = await resolveRange(api, name, range);
-        deps[name] = savedRange;
-        ui.info(`${c.green("+")} ${c.bold(name)}@${c.cyan(savedRange)}`);
+        const { name } = parsePackageSpec(spec);
+        ui.info(`${c.green("+")} ${c.bold(name)}`);
     }
-    pkg.dependencies = deps;
-    await writePackageJson(pkg, cwd);
-    return installAll(api, cwd, ui);
+    return syncLockFromNodeModules(cwd);
 }
 /**
- * Installs packages into the npm global prefix (bins linked by npm).
- * Downloads through the DPM registry so installs count as DPM downloads.
+ * Installs packages into the global prefix via the managed DPM runtime.
  * Used for CLI self-updates: `dpm i -g dpm` / `dpm i -g @drops-it/dpm`.
  */
-export async function installGlobalPackages(api, specs, log = createUi()) {
+export async function installGlobalPackages(_api, specs, log = createUi()) {
     if (specs.length === 0) {
         throw new Error("global install requires at least one package name");
     }
     const ui = asUi(log);
-    for (const spec of specs) {
-        let { name, range } = parsePackageSpec(spec);
-        // CLI lives on DPM as unscoped `dpm` — map the npm name away.
-        if (name === "@drops-it/dpm")
-            name = "dpm";
-        setStatus(ui, `resolve ${c.bold(name)}`);
-        const meta = await api.getPackage(name);
-        if (!meta)
-            throw new Error(`Package not found: ${name}`);
-        const versions = meta.versions.map((v) => v.version);
-        const version = pickVersion(versions, range, meta["dist-tags"] || {});
-        if (!version)
-            throw new Error(`No version of ${name} matches ${range}`);
-        const ver = meta.versions.find((v) => v.version === version);
-        // Prefer the DPM tarball URL so the registry records the download.
-        const tarballUrl = ver.dist.tarball.includes("/dpm/v1/packages/")
-            ? ver.dist.tarball
-            : `/dpm/v1/packages/${encodeURIComponent(name)}/-/${encodeURIComponent(name)}-${version}.tgz`;
-        setStatus(ui, `download ${c.bold(name)}@${c.green(version)}`);
-        const tarball = await api.downloadTarball(tarballUrl);
-        const tmp = path.join(tmpdir(), `dpm-global-${Date.now()}-${Math.random().toString(16).slice(2)}.tgz`);
-        await writeFile(tmp, tarball);
-        try {
-            setStatus(ui, `npm install -g ${c.bold(name)}@${c.green(version)}`);
-            await runNpm(["install", "-g", tmp]);
-        }
-        finally {
-            await rm(tmp, { force: true });
-        }
-        ui.clearStatus();
-        if (ui.success)
-            ui.success(`installed ${c.bold(name)}@${c.green(version)} globally`);
-        else
-            ui.info(`installed ${name}@${version} globally`);
-    }
-}
-async function npmGlobalPrefix() {
-    const { stdout } = await runNpm(["prefix", "-g"]);
-    return stdout.toString().trim();
+    const mapped = specs.map((spec) => {
+        const { name, range } = parsePackageSpec(spec);
+        const real = name === "@drops-it/dpm" ? "dpm" : name;
+        return range === "latest" ? real : `${real}@${range}`;
+    });
+    const config = await loadConfig();
+    await ensureInstallConfig(config, process.cwd());
+    const env = runtimeInstallEnv(config);
+    setStatus(ui, `install -g ${mapped.join(", ")}`);
+    const code = await spawnRuntime({
+        args: ["add", "-g", ...mapped],
+        env,
+        brandOutput: true,
+    });
+    ui.clearStatus();
+    if (code !== 0)
+        throw new Error(`global install failed (exit ${code})`);
+    if (ui.success)
+        ui.success(`installed ${mapped.join(", ")} globally`);
+    else
+        ui.info(`installed ${mapped.join(", ")} globally`);
 }
-async function tryNpmUninstallGlobal(name) {
-    try {
-        await runNpm(["uninstall", "-g", name]);
-    }
-    catch {
-        try {
-            await runNpm(["unlink", "-g", name]);
-        }
-        catch {
-            // Package may already be gone.
-        }
+const CLI_SELF_NAMES = ["@drops-it/dpm", "dpm"];
+async function runtimeGlobalPrefix() {
+    // Best-effort: common user global paths when removing the CLI.
+    if (process.platform === "win32") {
+        return path.join(homedir(), ".dpm", "global");
     }
+    return path.join(homedir(), ".dpm", "global");
 }
 /** Removes leftover Windows/Unix bin shims for a command name. */
 async function removeGlobalBinShims(binName, prefix) {
@@ -286,13 +244,13 @@ async function removeGlobalBinShims(binName, prefix) {
         path.join(prefix, binName),
         path.join(prefix, `${binName}.cmd`),
         path.join(prefix, `${binName}.ps1`),
+        path.join(prefix, "bin", binName),
         path.join(prefix, "node_modules", ".bin", binName),
         path.join(prefix, "node_modules", ".bin", `${binName}.cmd`),
         path.join(prefix, "node_modules", ".bin", `${binName}.ps1`),
     ];
     await Promise.all(candidates.map((p) => rm(p, { force: true })));
 }
-const CLI_SELF_NAMES = ["@drops-it/dpm", "dpm"];
 /**
  * Uninstalls global packages (and cleans dpm bin shims when removing the CLI).
  * `dpm rm -g` with no names removes the dpm CLI itself.
@@ -300,31 +258,29 @@ const CLI_SELF_NAMES = ["@drops-it/dpm", "dpm"];
 export async function removeGlobalPackages(specs, log = createUi()) {
     const ui = asUi(log);
     const targets = specs.length > 0
-        ? specs.map((s) => parsePackageSpec(s).name)
+        ? specs.map((s) => parsePackageSpec(s).name).map((n) => (n === "@drops-it/dpm" ? "dpm" : n))
         : [...CLI_SELF_NAMES];
-    const prefix = await npmGlobalPrefix();
-    const removingSelf = targets.some((n) => CLI_SELF_NAMES.includes(n));
+    const config = await loadConfig();
+    const env = runtimeInstallEnv(config);
+    const removingSelf = targets.some((n) => CLI_SELF_NAMES.includes(n) || n === "dpm");
     for (const name of targets) {
         setStatus(ui, `uninstall -g ${c.bold(name)}`);
-        await tryNpmUninstallGlobal(name);
-        // Scoped packages may leave the unscoped alias around.
-        if (name === "@drops-it/dpm")
-            await tryNpmUninstallGlobal("dpm");
-        if (name === "dpm")
-            await tryNpmUninstallGlobal("@drops-it/dpm");
+        await spawnRuntime({
+            args: ["remove", "-g", name],
+            env,
+            brandOutput: true,
+        });
     }
     if (removingSelf) {
+        const prefix = await runtimeGlobalPrefix();
         await removeGlobalBinShims("dpm", prefix);
-        // Also clear a linked/local leftover under the user npm folder on Windows.
         const roaming = path.join(homedir(), "AppData", "Roaming", "npm");
-        if (roaming.toLowerCase() !== prefix.toLowerCase()) {
-            await removeGlobalBinShims("dpm", roaming);
-        }
+        await removeGlobalBinShims("dpm", roaming);
         await rm(path.join(prefix, "node_modules", "dpm"), { recursive: true, force: true });
-        await rm(path.join(prefix, "node_modules", "@drops-it", "dpm"), {
+        await rm(path.join(homedir(), ".bun", "install", "global", "node_modules", "dpm"), {
             recursive: true,
             force: true,
-        });
+        }).catch(() => undefined);
     }
     ui.clearStatus();
     if (ui.success) {
@@ -340,26 +296,21 @@ export async function addPackage(api, name, range = "latest", cwd = process.cwd(
     const spec = range === "latest" ? name : `${name}@${range}`;
     return addPackages(api, [spec], cwd, log);
 }
+/** Removes a local dependency via the managed DPM runtime. */
 export async function removePackage(name, cwd = process.cwd(), log = createUi()) {
     const ui = asUi(log);
-    const pkg = await readPackageJson(cwd);
-    const deps = pkg.dependencies || {};
-    const dev = pkg.devDependencies || {};
-    if (!deps[name] && !dev[name]) {
-        ui.warn(`${name} is not in package.json`);
-    }
-    delete deps[name];
-    delete dev[name];
-    pkg.dependencies = deps;
-    pkg.devDependencies = dev;
-    await writePackageJson(pkg, cwd);
-    await rm(path.join(cwd, "node_modules", ...name.split("/")), {
-        recursive: true,
-        force: true,
+    const { env } = await prepareRuntimeInstall(cwd);
+    setStatus(ui, `remove ${c.bold(name)}`);
+    const code = await spawnRuntime({
+        cwd,
+        args: ["remove", name],
+        env,
+        brandOutput: true,
     });
-    const lock = await loadLockfile(cwd);
-    delete lock.packages[name];
-    await saveLockfile(lock, cwd);
+    ui.clearStatus();
+    if (code !== 0)
+        throw new Error(`remove failed (exit ${code})`);
+    await syncLockFromNodeModules(cwd);
     if (ui.success)
         ui.success(`removed ${c.bold(name)}`);
     else
@@ -384,7 +335,7 @@ export async function runAudit(api, cwd = process.cwd(), log = createUi()) {
     return { hits, fixes: fixes.filter((f) => !f.breaking) };
 }
 /**
- * Applies available advisory fixes (like `npm audit fix`), then reinstalls.
+ * Applies available advisory fixes, then reinstalls via the DPM runtime.
  */
 export async function auditFix(api, cwd = process.cwd(), log = createUi(), force = false) {
     const ui = asUi(log);
@@ -418,7 +369,6 @@ export async function auditFix(api, cwd = process.cwd(), log = createUi(), force
             devDependencies[fix.name] = `^${fix.to}`;
         }
         else {
-            // Persist transitive fixes so the next plain install keeps them.
             overrides[fix.name] = fix.to;
         }
     }
@@ -433,8 +383,26 @@ export async function auditFix(api, cwd = process.cwd(), log = createUi(), force
     });
     return { fixed: applicable, lock: next };
 }
+async function readLocalReadme(cwd) {
+    for (const name of ["README.md", "readme.md", "README", "readme.txt", "README.txt"]) {
+        try {
+            const text = await readFile(path.join(cwd, name), "utf8");
+            if (text.trim())
+                return text;
+        }
+        catch {
+            /* try next */
+        }
+    }
+    return "";
+}
+/** Packs the current package into a gzipped tarball for publish. */
 export async function packTarball(cwd = process.cwd()) {
     const manifest = await readPackageJson(cwd);
+    const readme = await readLocalReadme(cwd);
+    if (readme && !String(manifest.readme ?? "").trim()) {
+        manifest.readme = readme;
+    }
     const out = path.join(cwd, `.dpm-pack-${Date.now()}.tgz`);
     await tar.c({
         gzip: true,
@@ -444,7 +412,10 @@ export async function packTarball(cwd = process.cwd()) {
         filter: (p) => !p.includes("node_modules") &&
             !p.startsWith(".git") &&
             !p.endsWith(".tgz") &&
-            p !== "dpm-lock.yaml",
+            p !== "dpm-lock.yaml" &&
+            p !== "bun.lock" &&
+            p !== "bun.lockb" &&
+            p !== "bunfig.toml",
     }, ["."]);
     const buf = await readFile(out);
     await rm(out, { force: true });

package/dist/runtime.d.ts

@@ -0,0 +1,37 @@
+import type { DpmConfig } from "./config.js";
+/** Pinned managed runtime version (oven-sh/bun release tag without prefix). */
+export declare const RUNTIME_VERSION = "1.2.19";
+export declare function managedRuntimePath(): string;
+/**
+ * Ensures the managed DPM runtime binary exists at a stable path.
+ * Downloads a pinned release from GitHub when missing or version-mismatched.
+ */
+export declare function ensureRuntime(): Promise<string>;
+/**
+ * Resolves a runnable runtime path: managed binary, else PATH fallback branded as DPM.
+ */
+export declare function resolveRuntime(): Promise<string>;
+export type SpawnRuntimeOptions = {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    /** Extra args after the runtime binary (e.g. ["install"], ["run", "start"]). */
+    args: string[];
+    /** When true, rewrite stderr banners that say bun → dpm. */
+    brandOutput?: boolean;
+};
+/**
+ * Spawns the managed runtime with inherited stdio and returns the exit code.
+ */
+export declare function spawnRuntime(opts: SpawnRuntimeOptions): Promise<number>;
+/**
+ * Resolves the install registry URL.
+ * DPM hosts use the `/npm` facade; plain npmjs (or DPM_BOOTSTRAP=1) uses the URL as-is.
+ */
+export declare function resolveInstallRegistryUrl(registry: string): string;
+/**
+ * Writes project-local registry config so the runtime installer hits the DPM npm facade
+ * (or npmjs when bootstrapping / pointed at registry.npmjs.org).
+ */
+export declare function ensureInstallConfig(config: DpmConfig, cwd?: string): Promise<void>;
+/** Builds npm_config_* env for a one-shot install without relying only on files. */
+export declare function runtimeInstallEnv(config: DpmConfig): NodeJS.ProcessEnv;