vyft 0.2.0-alpha → 0.4.0-alpha

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

@@ -2,5 +2,8 @@ export { interpolate } from "./interpolate.js";
 export type { EnvValue, HealthCheckConfig, Interpolation, Reference, Resource, ResourceLimits, ResourceType, Secret, SecretConfig, Service, ServiceConfig, Site, SiteConfig, Volume, VolumeConfig, } from "./resource.js";
 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,3 +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/init.js

@@ -1,3 +1,4 @@
+import { execSync } from "node:child_process";
 import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -90,11 +91,27 @@ export async function init(directory) {
         await writeFile(destPath, content);
         log.step(relativePath);
     }
+    const ua = process.env.npm_config_user_agent ?? "";
+    const pm = ua.startsWith("pnpm")
+        ? "pnpm"
+        : ua.startsWith("bun")
+            ? "bun"
+            : "npm";
+    const install = await confirm({
+        message: `Install dependencies with ${pm}?`,
+    });
+    if (isCancel(install))
+        return;
+    if (install) {
+        log.step(`Running ${pm} install...`);
+        execSync(`${pm} install`, { cwd: targetDir, stdio: "inherit" });
+    }
     outro("Project created");
     console.log();
     console.log("Next steps:");
     console.log(`  cd ${path.relative(process.cwd(), targetDir)}`);
-    console.log("  pnpm install");
-    console.log("  pnpm dev");
+    if (!install)
+        console.log(`  ${pm} install`);
+    console.log(`  ${pm} dev`);
     console.log();
 }

package/dist/interpolate.d.ts

@@ -1,2 +1,13 @@
 import type { Interpolation, Reference } from "./resource.js";
+/**
+ * Tagged template literal for building strings that contain {@link Reference} values
+ * (e.g. secrets) which are resolved at deploy time.
+ *
+ * @example
+ * ```ts
+ * const connStr = interpolate`postgres://user:${dbPassword}@${db.host}:5432/app`;
+ * ```
+ *
+ * @throws If none of the interpolated values are a {@link Reference}.
+ */
 export declare function interpolate(strings: TemplateStringsArray, ...values: Array<Reference | string>): Interpolation;

package/dist/interpolate.js

@@ -1,4 +1,15 @@
 import { isReference } from "./resource.js";
+/**
+ * Tagged template literal for building strings that contain {@link Reference} values
+ * (e.g. secrets) which are resolved at deploy time.
+ *
+ * @example
+ * ```ts
+ * const connStr = interpolate`postgres://user:${dbPassword}@${db.host}:5432/app`;
+ * ```
+ *
+ * @throws If none of the interpolated values are a {@link Reference}.
+ */
 export function interpolate(strings, ...values) {
     const hasRef = values.some(isReference);
     if (!hasRef) {

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";
+}

package/dist/local/index.d.ts

@@ -0,0 +1,2 @@
+export { DevRunner, detectPackageManager, resolveDevEnv } from "./dev.js";
+export { LocalRuntime } from "./runtime.js";

package/dist/local/index.js

@@ -0,0 +1,2 @@
+export { DevRunner, detectPackageManager, resolveDevEnv } from "./dev.js";
+export { LocalRuntime } from "./runtime.js";

package/dist/local/runtime.d.ts

@@ -0,0 +1,61 @@
+import type { Logger } from "pino";
+import type { EnvValue, Secret, Service, Volume } from "../resource.js";
+/**
+ * Docker runtime for local development.
+ *
+ * Runs managed infrastructure (databases, caches, etc.) as plain Docker
+ * containers with ports published to localhost. Secrets are generated
+ * in-memory and injected as environment variables.
+ */
+export declare class LocalRuntime {
+    private docker;
+    private project;
+    private log;
+    private secretValues;
+    private containers;
+    private networkName;
+    constructor(project: string, opts?: {
+        parentLogger?: Logger;
+    });
+    /** Create bridge network for inter-container DNS. */
+    ensureInfrastructure(): Promise<void>;
+    /** Generate a random secret value and store it in memory. */
+    createSecret(secret: Secret): void;
+    /** Get the generated value for a secret. */
+    getSecretValue(id: string): string | undefined;
+    /** Create a Docker volume for persistent data. */
+    createVolume(volume: Volume): Promise<void>;
+    /**
+     * Resolve env vars for a managed service container.
+     *
+     * Secrets become plain `KEY=<value>` env vars.
+     * Interpolations are fully resolved with generated secret values.
+     */
+    resolveEnv(env: Record<string, EnvValue>): string[];
+    /**
+     * Build an entrypoint wrapper that writes secret values to /run/secrets/
+     * before exec'ing the original entrypoint.
+     *
+     * This is needed because some factory images (e.g. redis) read passwords
+     * from `/run/secrets/*-password` via shell glob.
+     */
+    private buildSecretInit;
+    /** Pull, create, and start a container for a managed service. */
+    createService(service: Service): Promise<number>;
+    /** Wait for a container to pass its health check. */
+    waitForHealthy(id: string, timeoutMs?: number): Promise<void>;
+    /** Stream logs from a container. */
+    containerLogs(id: string): AsyncGenerator<{
+        stream: "stdout" | "stderr";
+        text: string;
+    }>;
+    /** Stop and remove all managed containers (keep volumes). */
+    stop(): Promise<void>;
+    /** List running dev containers for this project. */
+    listContainers(): Promise<Array<{
+        id: string;
+        name: string;
+        containerId: string;
+    }>>;
+    private removeContainer;
+}