vyft 0.3.0-alpha → 0.4.0-alpha

package/dist/docker.d.ts

@@ -1,7 +1,7 @@
 import type { Logger } from "pino";
 import type { ReverseProxy } from "./proxy.js";
-import type { Resource, ResourceType } from "./resource.js";
-import type { Runtime } from "./runtime.js";
+import type { Resource, ResourceType, Service } from "./resource.js";
+import type { CreateResult, Runtime } from "./runtime.js";
 export declare function parseRoute(route: string): {
     host: string;
     path?: string;
@@ -17,8 +17,10 @@ export declare class DockerClient implements Runtime {
     private docker;
     private localDocker;
     private isRemote;
+    private sshClient;
     private project;
     private secretValues;
+    private builtImages;
     private log;
     proxy: ReverseProxy;
     verbose: boolean;
@@ -26,10 +28,14 @@ export declare class DockerClient implements Runtime {
         host?: string;
         parentLogger?: Logger;
     });
+    /** Close the SSH connection (if any), allowing the process to exit. */
+    destroy(): void;
     private ensureNetwork;
     ensureInfrastructure(): Promise<void>;
     listManagedResources(): Promise<ManagedResource[]>;
-    create(resource: Resource): Promise<void>;
+    create(resource: Resource, options?: {
+        silent?: boolean;
+    }): Promise<CreateResult>;
     exists(resource: Resource): Promise<boolean>;
     remove(resource: Resource): Promise<void>;
     private createVolume;
@@ -42,6 +48,7 @@ export declare class DockerClient implements Runtime {
     private lookupSecretId;
     private createDerivedSecret;
     private resolveEnv;
+    buildImage(service: Service): Promise<string | null>;
     private createService;
     private serviceExists;
     waitForHealthy(id: string, timeoutMs?: number): Promise<void>;

package/dist/docker.js

@@ -1,8 +1,9 @@
 import { randomBytes } from "node:crypto";
+import http from "node:http";
 import path from "node:path";
 import { PassThrough } from "node:stream";
-import { log } from "@clack/prompts";
 import Docker from "dockerode";
+import { Client as SshClient } from "ssh2";
 import tar from "tar-fs";
 import { buildStatic } from "./build.js";
 import { logger as defaultLogger } from "./logger.js";
@@ -55,21 +56,74 @@ export function parseRoute(route) {
         path: route.slice(slashIndex),
     };
 }
+/**
+ * Create a Docker client that reuses a single SSH connection instead of
+ * opening a new one for every API call (the docker-modem default).
+ */
+function createSshDocker(sshUrl) {
+    const parsed = new URL(sshUrl);
+    const conn = new SshClient();
+    let connected = false;
+    const ready = new Promise((resolve, reject) => {
+        conn.once("ready", () => {
+            connected = true;
+            resolve();
+        });
+        conn.once("error", reject);
+        conn.connect({
+            host: parsed.hostname,
+            port: parsed.port ? parseInt(parsed.port, 10) : 22,
+            username: parsed.username || undefined,
+            agent: process.env.SSH_AUTH_SOCK,
+        });
+    });
+    const agent = new http.Agent({ keepAlive: false });
+    // biome-ignore lint/suspicious/noExplicitAny: monkey-patching internal Agent method for SSH tunneling
+    agent.createConnection = (_opts, fn) => {
+        const exec = () => conn.exec("docker system dial-stdio", (err, stream) => {
+            if (err)
+                return fn(err);
+            fn(null, stream);
+        });
+        if (connected)
+            exec();
+        else
+            ready.then(exec).catch((err) => fn(err));
+    };
+    return {
+        docker: new Docker({
+            protocol: "http",
+            host: parsed.hostname,
+            agent,
+            // biome-ignore lint/suspicious/noExplicitAny: dockerode typing doesn't expose agent option
+        }),
+        sshClient: conn,
+    };
+}
 export class DockerClient {
     docker;
     localDocker;
     isRemote;
+    sshClient = null;
     project;
     secretValues = new Map();
+    builtImages = new Map();
     log;
     proxy;
     verbose = false;
     constructor(project, opts) {
         this.localDocker = new Docker({ socketPath: "/var/run/docker.sock" });
         const host = opts?.host;
-        if (host)
-            process.env.DOCKER_HOST = host;
-        this.docker = new Docker();
+        if (host?.startsWith("ssh://")) {
+            const { docker, sshClient } = createSshDocker(host);
+            this.docker = docker;
+            this.sshClient = sshClient;
+        }
+        else {
+            if (host)
+                process.env.DOCKER_HOST = host;
+            this.docker = new Docker();
+        }
         this.isRemote = !!host;
         this.project = project;
         this.log = (opts?.parentLogger ?? defaultLogger).child({
@@ -80,6 +134,11 @@ export class DockerClient {
         if (host)
             this.log.debug({ host }, "using remote endpoint");
     }
+    /** Close the SSH connection (if any), allowing the process to exit. */
+    destroy() {
+        this.sshClient?.end();
+        this.sshClient = null;
+    }
     async ensureNetwork(name, labels = {}) {
         const networks = await this.docker.listNetworks({
             filters: JSON.stringify({ name: [name] }),
@@ -153,7 +212,7 @@ export class DockerClient {
         }
         return resources;
     }
-    async create(resource) {
+    async create(resource, options) {
         switch (resource.type) {
             case "volume":
                 return this.createVolume(resource);
@@ -162,7 +221,7 @@ export class DockerClient {
             case "service":
                 return this.createService(resource);
             case "site":
-                return this.createStatic(resource);
+                return this.createStatic(resource, options?.silent);
         }
     }
     async exists(resource) {
@@ -205,9 +264,9 @@ export class DockerClient {
             Name: volume.id,
             Labels: labels,
         });
-        const durationMs = Math.round(performance.now() - start);
-        this.log.debug({ volumeName: volume.id, durationMs }, "volume created");
-        log.step(`Created ${volume.id}`);
+        const duration = Math.round(performance.now() - start);
+        this.log.debug({ volumeName: volume.id, durationMs: duration }, "volume created");
+        return { action: "created", duration };
     }
     async volumeExists(id) {
         const start = performance.now();
@@ -229,7 +288,6 @@ export class DockerClient {
         await this.docker.getVolume(id).remove();
         const durationMs = Math.round(performance.now() - start);
         this.log.debug({ volumeName: id, durationMs }, "volume removed");
-        log.step(`Removed ${id}`);
     }
     async createSecret(secret) {
         const start = performance.now();
@@ -240,9 +298,9 @@ export class DockerClient {
         await this.storeSecretData(secret.id, value, {
             "vyft.length": length.toString(),
         });
-        const durationMs = Math.round(performance.now() - start);
-        this.log.debug({ secretName: secret.id, length, durationMs }, "secret created");
-        log.step(`Created ${secret.id}`);
+        const duration = Math.round(performance.now() - start);
+        this.log.debug({ secretName: secret.id, length, durationMs: duration }, "secret created");
+        return { action: "created", duration };
     }
     async secretExists(id) {
         const start = performance.now();
@@ -264,7 +322,6 @@ export class DockerClient {
         await this.docker.getSecret(id).remove();
         const durationMs = Math.round(performance.now() - start);
         this.log.debug({ secretName: id, durationMs }, "secret removed");
-        log.step(`Removed ${id}`);
     }
     async storeSecretData(name, value, labels = {}) {
         this.log.debug({ secretName: name }, "storing secret data");
@@ -291,7 +348,6 @@ export class DockerClient {
             "vyft.derived": "true",
             "vyft.parent-service": parentService,
         });
-        log.step(`Created ${name}`);
     }
     async resolveEnv(serviceId, env) {
         const envList = [];
@@ -349,60 +405,70 @@ export class DockerClient {
         this.log.debug({ serviceId, envCount: envList.length, secretMountCount: secrets.length }, "env resolved");
         return { envList, secrets };
     }
+    async buildImage(service) {
+        const config = service.config;
+        if (typeof config.image !== "object")
+            return null;
+        const { context = ".", dockerfile = "Dockerfile" } = config.image;
+        const buildTag = `${service.id}:latest`;
+        this.log.debug({ resourceId: service.id, context, dockerfile }, "image build started");
+        const buildStart = performance.now();
+        const tarStream = tar.pack(path.resolve(context));
+        const stream = await this.localDocker.buildImage(tarStream, {
+            t: buildTag,
+            dockerfile,
+        });
+        await new Promise((resolve, reject) => {
+            this.localDocker.modem.followProgress(stream, (err) => (err ? reject(err) : resolve()), (event) => {
+                if (event.error)
+                    this.log.error({ error: event.error }, "build error");
+                else if (this.verbose && event.stream)
+                    process.stdout.write(event.stream);
+                this.log.trace({ event }, "build progress");
+            });
+        });
+        const buildDurationMs = Math.round(performance.now() - buildStart);
+        this.log.debug({
+            resourceId: service.id,
+            image: buildTag,
+            durationMs: buildDurationMs,
+        }, "image build completed");
+        const images = await this.localDocker.listImages({
+            filters: JSON.stringify({ reference: [buildTag] }),
+        });
+        if (images.length === 0) {
+            throw new Error(`Image ${buildTag} was not built successfully`);
+        }
+        // Tag with content hash so the orchestrator detects the new image
+        const shortHash = images[0].Id.replace("sha256:", "").slice(0, 12);
+        const imageName = `${service.id}:${shortHash}`;
+        await this.localDocker.getImage(buildTag).tag({
+            repo: service.id,
+            tag: shortHash,
+        });
+        if (this.isRemote) {
+            this.log.debug({ image: imageName }, "transferring image to remote");
+            const transferStart = performance.now();
+            const imageStream = await this.localDocker.getImage(imageName).get();
+            await this.docker.loadImage(imageStream);
+            const transferDurationMs = Math.round(performance.now() - transferStart);
+            this.log.debug({ image: imageName, durationMs: transferDurationMs }, "image transferred to remote");
+        }
+        this.builtImages.set(service.id, imageName);
+        return imageName;
+    }
     async createService(service) {
         const start = performance.now();
-        await this.ensureNetwork(`${this.project}-internal`, {
-            "com.docker.stack.namespace": this.project,
-            "vyft.managed": "true",
-            "vyft.project": this.project,
-        });
         const config = service.config;
         let imageName;
         if (typeof config.image === "object") {
-            const { context = ".", dockerfile = "Dockerfile" } = config.image;
-            const buildTag = `${service.id}:latest`;
-            this.log.debug({ resourceId: service.id, context, dockerfile }, "image build started");
-            const buildStart = performance.now();
-            const tarStream = tar.pack(path.resolve(context));
-            const stream = await this.localDocker.buildImage(tarStream, {
-                t: buildTag,
-                dockerfile,
-            });
-            await new Promise((resolve, reject) => {
-                this.localDocker.modem.followProgress(stream, (err) => (err ? reject(err) : resolve()), (event) => {
-                    if (event.error)
-                        log.error(event.error);
-                    else if (this.verbose && event.stream)
-                        process.stdout.write(event.stream);
-                    this.log.trace({ event }, "build progress");
-                });
-            });
-            const buildDurationMs = Math.round(performance.now() - buildStart);
-            this.log.debug({
-                resourceId: service.id,
-                image: buildTag,
-                durationMs: buildDurationMs,
-            }, "image build completed");
-            const images = await this.localDocker.listImages({
-                filters: JSON.stringify({ reference: [buildTag] }),
-            });
-            if (images.length === 0) {
-                throw new Error(`Image ${buildTag} was not built successfully`);
+            const prebuilt = this.builtImages.get(service.id);
+            if (prebuilt) {
+                imageName = prebuilt;
             }
-            // Tag with content hash so the orchestrator detects the new image
-            const shortHash = images[0].Id.replace("sha256:", "").slice(0, 12);
-            imageName = `${service.id}:${shortHash}`;
-            await this.localDocker.getImage(buildTag).tag({
-                repo: service.id,
-                tag: shortHash,
-            });
-            if (this.isRemote) {
-                this.log.debug({ image: imageName }, "transferring image to remote");
-                const transferStart = performance.now();
-                const imageStream = await this.localDocker.getImage(imageName).get();
-                await this.docker.loadImage(imageStream);
-                const transferDurationMs = Math.round(performance.now() - transferStart);
-                this.log.debug({ image: imageName, durationMs: transferDurationMs }, "image transferred to remote");
+            else {
+                await this.buildImage(service);
+                imageName = this.builtImages.get(service.id);
             }
         }
         else {
@@ -526,14 +592,18 @@ export class DockerClient {
                 port,
             });
         }
-        const durationMs = Math.round(performance.now() - start);
+        const duration = Math.round(performance.now() - start);
         this.log.info({
             resourceId: service.id,
             image: imageName,
             hasRoute: !!config.route,
-            durationMs,
+            durationMs: duration,
         }, existing ? "service updated" : "service created");
-        log.step(`${existing ? "Updated" : "Created"} ${service.id}`);
+        return {
+            action: existing ? "updated" : "created",
+            route: config.route,
+            duration,
+        };
     }
     async serviceExists(id) {
         try {
@@ -588,7 +658,6 @@ export class DockerClient {
         }
         const durationMs = Math.round(performance.now() - start);
         this.log.info({ resourceId: id, durationMs }, "service removed");
-        log.step(`Removed ${id}`);
     }
     async pullImage(image) {
         this.log.debug({ image }, "pulling image");
@@ -598,19 +667,15 @@ export class DockerClient {
         });
         this.log.debug({ image }, "image pulled");
     }
-    async createStatic(static_) {
+    async createStatic(static_, silent) {
         const start = performance.now();
-        await this.ensureNetwork(`${this.project}-internal`, {
-            "com.docker.stack.namespace": this.project,
-            "vyft.managed": "true",
-            "vyft.project": this.project,
-        });
         this.log.debug({ resourceId: static_.id, route: static_.config.route }, "creating static site");
         this.log.debug({ resourceId: static_.id }, "static build starting");
         const { outputPath } = await buildStatic(static_.config.build.cwd, {
             output: static_.config.build.output,
             command: static_.config.build.command,
             env: static_.config.build.env,
+            silent,
         }, this.log);
         const volumeName = `${static_.id}-files`;
         if (!(await this.volumeExists(volumeName))) {
@@ -706,9 +771,17 @@ export class DockerClient {
             host: static_.id,
             port: 80,
         });
-        const durationMs = Math.round(performance.now() - start);
-        this.log.info({ resourceId: static_.id, route: static_.config.route, durationMs }, existing ? "site updated" : "site created");
-        log.step(`${existing ? "Updated" : "Created"} ${static_.id}`);
+        const duration = Math.round(performance.now() - start);
+        this.log.info({
+            resourceId: static_.id,
+            route: static_.config.route,
+            durationMs: duration,
+        }, existing ? "site updated" : "site created");
+        return {
+            action: existing ? "updated" : "created",
+            route: static_.config.route,
+            duration,
+        };
     }
     async removeStatic(id) {
         const start = performance.now();
@@ -744,7 +817,6 @@ export class DockerClient {
         }
         const durationMs = Math.round(performance.now() - start);
         this.log.info({ resourceId: id, durationMs }, "site removed");
-        log.step(`Removed ${id}`);
     }
     async *serviceLogs(options) {
         const allServices = await this.docker.listServices({
@@ -765,26 +837,29 @@ export class DockerClient {
             });
         }
         if (matched.length === 0) {
-            log.warn("No matching services found");
+            this.log.warn("no matching services found");
             return;
         }
         const tail = options.tail ?? 100;
-        // Collect all containers with their short service name
-        const targets = [];
-        for (const svc of matched) {
+        // Collect all containers with their short service name (parallel)
+        const targets = (await Promise.all(matched.map(async (svc) => {
             const name = svc.Spec?.Name || "";
-            const short = name.startsWith(prefix) ? name.slice(prefix.length) : name;
+            const short = name.startsWith(prefix)
+                ? name.slice(prefix.length)
+                : name;
             const containers = await this.docker.listContainers({
                 filters: JSON.stringify({
                     label: [`com.docker.swarm.service.name=${name}`],
                 }),
             });
-            for (const cInfo of containers) {
-                targets.push({ container: this.docker.getContainer(cInfo.Id), short });
-            }
-        }
+            return containers.map((cInfo) => ({
+                container: this.docker.getContainer(cInfo.Id),
+                short,
+            }));
+        }))).flat();
         if (!options.follow) {
-            for (const { container, short } of targets) {
+            // Fetch all logs in parallel
+            const results = await Promise.all(targets.map(async ({ container, short }) => {
                 const buf = await container.logs({
                     stdout: true,
                     stderr: true,
@@ -792,19 +867,26 @@ export class DockerClient {
                     tail,
                     timestamps: true,
                 });
+                const entries = [];
                 let offset = 0;
                 while (offset + 8 <= buf.length) {
                     const type = buf[offset];
                     const size = buf.readUInt32BE(offset + 4);
                     offset += 8;
                     const text = buf.subarray(offset, offset + size).toString();
-                    yield {
+                    entries.push({
                         service: short,
                         stream: type === 2 ? "stderr" : "stdout",
                         text,
-                    };
+                    });
                     offset += size;
                 }
+                return entries;
+            }));
+            for (const entries of results) {
+                for (const entry of entries) {
+                    yield entry;
+                }
             }
             return;
         }
@@ -820,7 +902,7 @@ export class DockerClient {
                 n();
             }
         };
-        for (const { container, short } of targets) {
+        await Promise.all(targets.map(async ({ container, short }) => {
             const stream = await container.logs({
                 stdout: true,
                 stderr: true,
@@ -851,7 +933,7 @@ export class DockerClient {
                     n();
                 }
             });
-        }
+        }));
         while (active > 0 || buffer.length > 0) {
             if (buffer.length === 0) {
                 await new Promise((r) => {

package/dist/exec.d.ts

@@ -1,2 +1,2 @@
 import type { Logger } from "pino";
-export declare function exec(command: string, cwd: string, env?: Record<string, string>, log?: Logger): Promise<void>;
+export declare function exec(command: string, cwd: string, env?: Record<string, string>, log?: Logger, silent?: boolean): Promise<void>;

package/dist/exec.js

@@ -1,11 +1,11 @@
 import { spawn } from "node:child_process";
-export async function exec(command, cwd, env, log) {
+export async function exec(command, cwd, env, log, silent) {
     const start = performance.now();
     log?.debug({ command, cwd }, "process spawning");
     return new Promise((resolve, reject) => {
         const proc = spawn(command, {
             cwd,
-            stdio: "inherit",
+            stdio: silent ? "pipe" : "inherit",
             shell: true,
             env: env ? { ...process.env, ...env } : undefined,
         });

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export type { EnvValue, HealthCheckConfig, Interpolation, Reference, Resource, R
 export { isInterpolation, isReference, isSecret, validateId, validateRoute, } from "./resource.js";
 export type { Runtime } from "./runtime.js";
 export type { BackupConfig, Bucket, Minio, MinioConfig, Mongo, MongoConfig, Mysql, MysqlConfig, Nats, NatsConfig, Postgres, PostgresConfig, Rabbitmq, RabbitmqConfig, Redis, RedisConfig, Storage, StorageConfig, } from "./services/index.js";
+export { isManaged } from "./services/index.js";
 export type { RuntimeMeta, RuntimeRef } from "./symbols.js";
-export { VYFT_RUNTIME } from "./symbols.js";
+export { VYFT_MANAGED, VYFT_RUNTIME } from "./symbols.js";
 export declare const service: (id: string, config: import("./swarm/types.js").SwarmServiceConfig) => import("./resource.js").Service, secret: (id: string, config?: import("./resource.js").SecretConfig) => import("./resource.js").Secret, volume: (id: string, config?: import("./resource.js").VolumeConfig) => import("./resource.js").Volume, site: (id: string, config: import("./resource.js").SiteConfig) => import("./resource.js").Site, postgres: (id: string, config?: import("./index.js").PostgresConfig) => import("./index.js").Postgres, mysql: (id: string, config?: import("./index.js").MysqlConfig) => import("./index.js").Mysql, redis: (id: string, config?: import("./index.js").RedisConfig) => import("./index.js").Redis, rabbitmq: (id: string, config?: import("./index.js").RabbitmqConfig) => import("./index.js").Rabbitmq, nats: (id: string, config?: import("./index.js").NatsConfig) => import("./index.js").Nats, mongo: (id: string, config?: import("./index.js").MongoConfig) => import("./index.js").Mongo, minio: (id: string, config?: import("./index.js").MinioConfig) => import("./index.js").Minio, storage: (id: string, config?: import("./index.js").StorageConfig) => import("./index.js").Storage;

package/dist/index.js

@@ -1,6 +1,7 @@
 export { interpolate } from "./interpolate.js";
 export { isInterpolation, isReference, isSecret, validateId, validateRoute, } from "./resource.js";
-export { VYFT_RUNTIME } from "./symbols.js";
+export { isManaged } from "./services/index.js";
+export { VYFT_MANAGED, VYFT_RUNTIME } from "./symbols.js";
 import { createFactories } from "./swarm/factories.js";
 const factories = createFactories({});
 export const { service, secret, volume, site, postgres, mysql, redis, rabbitmq, nats, mongo, minio, storage, } = factories;

package/dist/local/dev.d.ts

@@ -0,0 +1,31 @@
+import type { EnvValue, Service } from "../resource.js";
+export interface DevProcess {
+    service: Service;
+    command: string;
+    cwd: string;
+    env: Record<string, string>;
+}
+type LogHandler = (service: string, stream: "stdout" | "stderr", text: string) => void;
+/**
+ * Manages user service child processes for local development.
+ */
+export declare class DevRunner {
+    private processes;
+    private onLog;
+    constructor(opts?: {
+        onLog?: LogHandler;
+    });
+    start(devProcesses: DevProcess[]): void;
+    stop(): void;
+}
+/**
+ * Resolve env vars for a dev process.
+ *
+ * - Secrets → generated plaintext value
+ * - Interpolations → fully resolved, with known service hosts remapped to localhost
+ * - Plain strings → as-is, with known service hosts remapped to localhost
+ */
+export declare function resolveDevEnv(env: Record<string, EnvValue>, secretValues: Map<string, string>, hostRemap: Map<string, string>): Record<string, string>;
+/** Detect the project's package manager from lock files. */
+export declare function detectPackageManager(projectRoot: string): string;
+export {};

package/dist/local/dev.js

@@ -0,0 +1,109 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { isInterpolation, isReference } from "../resource.js";
+/**
+ * Manages user service child processes for local development.
+ */
+export class DevRunner {
+    processes = [];
+    onLog;
+    constructor(opts) {
+        this.onLog = opts?.onLog;
+    }
+    start(devProcesses) {
+        for (const dp of devProcesses) {
+            const child = spawn(dp.command, {
+                cwd: dp.cwd,
+                env: { ...process.env, ...dp.env },
+                shell: true,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            const name = dp.service.id;
+            child.stdout?.on("data", (chunk) => {
+                for (const line of chunk.toString().split("\n")) {
+                    if (line)
+                        this.onLog?.(name, "stdout", line);
+                }
+            });
+            child.stderr?.on("data", (chunk) => {
+                for (const line of chunk.toString().split("\n")) {
+                    if (line)
+                        this.onLog?.(name, "stderr", line);
+                }
+            });
+            child.on("exit", (code) => {
+                this.onLog?.(name, "stderr", `process exited with code ${code}`);
+            });
+            this.processes.push(child);
+        }
+    }
+    stop() {
+        for (const child of this.processes) {
+            child.kill("SIGTERM");
+        }
+        this.processes = [];
+    }
+}
+/**
+ * Resolve env vars for a dev process.
+ *
+ * - Secrets → generated plaintext value
+ * - Interpolations → fully resolved, with known service hosts remapped to localhost
+ * - Plain strings → as-is, with known service hosts remapped to localhost
+ */
+export function resolveDevEnv(env, secretValues, hostRemap) {
+    const result = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (typeof value === "string") {
+            result[key] = remapHosts(value, hostRemap);
+        }
+        else if (isReference(value)) {
+            const secretValue = secretValues.get(value.id);
+            if (!secretValue) {
+                throw new Error(`Secret ${value.id} not yet generated`);
+            }
+            result[key] = secretValue;
+        }
+        else if (isInterpolation(value)) {
+            const parts = [];
+            for (let i = 0; i < value.strings.length; i++) {
+                parts.push(value.strings[i]);
+                if (i < value.values.length) {
+                    const v = value.values[i];
+                    if (isReference(v)) {
+                        const secretValue = secretValues.get(v.id);
+                        if (!secretValue) {
+                            throw new Error(`Secret ${v.id} not yet generated`);
+                        }
+                        parts.push(secretValue);
+                    }
+                    else {
+                        parts.push(remapHosts(v, hostRemap));
+                    }
+                }
+            }
+            result[key] = parts.join("");
+        }
+    }
+    return result;
+}
+function remapHosts(value, hostRemap) {
+    let result = value;
+    for (const [from, to] of hostRemap) {
+        result = result.replaceAll(from, to);
+    }
+    return result;
+}
+/** Detect the project's package manager from lock files. */
+export function detectPackageManager(projectRoot) {
+    if (existsSync(path.join(projectRoot, "bun.lock")))
+        return "bun";
+    if (existsSync(path.join(projectRoot, "bun.lockb")))
+        return "bun";
+    if (existsSync(path.join(projectRoot, "pnpm-lock.yaml")))
+        return "pnpm";
+    if (existsSync(path.join(projectRoot, "yarn.lock")))
+        return "yarn";
+    return "npm";
+}