vyft 0.2.0-alpha → 0.3.0-alpha

package/dist/docker.js

@@ -1,4 +1,3 @@
-import { execSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import path from "node:path";
 import { PassThrough } from "node:stream";
@@ -8,18 +7,7 @@ import tar from "tar-fs";
 import { buildStatic } from "./build.js";
 import { logger as defaultLogger } from "./logger.js";
 import { isInterpolation, isReference } from "./resource.js";
-const PROXY_SERVICE_NAME = "vyft-proxy";
-function resolveDockerHost() {
-    if (process.env.DOCKER_HOST)
-        return undefined;
-    try {
-        const host = execSync("docker context inspect --format '{{.Endpoints.docker.Host}}'", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
-        if (host && host !== `unix:///var/run/docker.sock`)
-            return host;
-    }
-    catch { }
-    return undefined;
-}
+import { CaddyProxy } from "./swarm/proxy.js";
 function secretMount(id, name) {
     return {
         SecretID: id,
@@ -67,18 +55,6 @@ export function parseRoute(route) {
         path: route.slice(slashIndex),
     };
 }
-export function buildCaddyRoute(resourceId, route, handler) {
-    const { host, path } = parseRoute(route);
-    const match = { host: [host] };
-    if (path)
-        match.path = [path];
-    return {
-        "@id": `vyft-${resourceId}`,
-        match: [match],
-        terminal: true,
-        handle: [handler],
-    };
-}
 export class DockerClient {
     docker;
     localDocker;
@@ -86,21 +62,23 @@ export class DockerClient {
     project;
     secretValues = new Map();
     log;
+    proxy;
     verbose = false;
-    constructor(project, parentLogger) {
+    constructor(project, opts) {
         this.localDocker = new Docker({ socketPath: "/var/run/docker.sock" });
-        const contextHost = resolveDockerHost();
-        if (contextHost)
-            process.env.DOCKER_HOST = contextHost;
+        const host = opts?.host;
+        if (host)
+            process.env.DOCKER_HOST = host;
         this.docker = new Docker();
-        this.isRemote = !!(contextHost || process.env.DOCKER_HOST);
+        this.isRemote = !!host;
         this.project = project;
-        this.log = (parentLogger ?? defaultLogger).child({
+        this.log = (opts?.parentLogger ?? defaultLogger).child({
             component: "docker",
             project,
         });
-        if (contextHost)
-            this.log.debug({ host: contextHost }, "using docker context endpoint");
+        this.proxy = new CaddyProxy(this.docker, this.log);
+        if (host)
+            this.log.debug({ host }, "using remote endpoint");
     }
     async ensureNetwork(name, labels = {}) {
         const networks = await this.docker.listNetworks({
@@ -125,247 +103,9 @@ export class DockerClient {
             "vyft.managed": "true",
             "vyft.project": this.project,
         });
-        this.log.debug("checking proxy existence");
-        const exists = await this.serviceExists(PROXY_SERVICE_NAME);
-        if (exists) {
-            this.log.debug("proxy already exists, verifying config structure");
-            try {
-                const raw = await this.caddyApiRequest("GET", "/config/");
-                const config = JSON.parse(raw);
-                if (!config?.apps?.http?.servers?.main) {
-                    this.log.debug("proxy config missing servers.main, re-seeding");
-                    await this.seedCaddyConfig();
-                }
-            }
-            catch {
-                this.log.debug("proxy config check failed, re-seeding");
-                await this.seedCaddyConfig();
-            }
-            return;
-        }
-        // Create shared proxy network
-        await this.ensureNetwork("vyft-network", { "vyft.infrastructure": "true" });
-        this.log.debug("creating proxy service");
-        await this.docker.createService({
-            Name: PROXY_SERVICE_NAME,
-            Labels: { "vyft.infrastructure": "true" },
-            TaskTemplate: {
-                ContainerSpec: {
-                    Image: "caddy:latest",
-                    Command: ["caddy", "run", "--resume"],
-                    Mounts: [
-                        {
-                            Type: "volume",
-                            Source: "vyft-proxy-config",
-                            Target: "/config",
-                        },
-                        {
-                            Type: "volume",
-                            Source: "vyft-proxy-data",
-                            Target: "/data",
-                        },
-                    ],
-                    Labels: { "vyft.infrastructure": "true" },
-                },
-                Networks: [{ Target: "vyft-network" }],
-            },
-            EndpointSpec: {
-                Ports: [
-                    {
-                        Protocol: "tcp",
-                        TargetPort: 80,
-                        PublishedPort: 80,
-                        PublishMode: "ingress",
-                    },
-                    {
-                        Protocol: "tcp",
-                        TargetPort: 443,
-                        PublishedPort: 443,
-                        PublishMode: "ingress",
-                    },
-                ],
-            },
-            Mode: { Replicated: { Replicas: 1 } },
-        });
-        log.step("Created vyft-proxy");
-        await this.seedCaddyConfig();
+        await this.proxy.ensure();
         const durationMs = Math.round(performance.now() - start);
-        this.log.info({ proxyCreated: true, durationMs }, "infrastructure ready");
-    }
-    async findProxyContainer() {
-        const containers = await this.docker.listContainers({
-            filters: JSON.stringify({
-                label: [`com.docker.swarm.service.name=${PROXY_SERVICE_NAME}`],
-            }),
-        });
-        if (containers.length === 0) {
-            throw new Error("vyft-proxy container not found");
-        }
-        return this.docker.getContainer(containers[0].Id);
-    }
-    async caddyApiRequest(method, path, body) {
-        const start = performance.now();
-        this.log.debug({ method, path }, "caddy request started");
-        const container = await this.findProxyContainer();
-        let cmd;
-        if (method === "POST") {
-            const bodyStr = body ? JSON.stringify(body) : "";
-            cmd = [
-                "wget",
-                "-q",
-                "-O",
-                "-",
-                "--timeout=10",
-                "--header=Content-Type: application/json",
-                `--post-data=${bodyStr}`,
-                `http://127.0.0.1:2019${path}`,
-            ];
-        }
-        else if (method === "DELETE") {
-            cmd = [
-                "curl",
-                "-s",
-                "--connect-timeout",
-                "5",
-                "--max-time",
-                "10",
-                "-X",
-                "DELETE",
-                `http://127.0.0.1:2019${path}`,
-            ];
-        }
-        else {
-            cmd = [
-                "wget",
-                "-q",
-                "-O",
-                "-",
-                "--timeout=10",
-                `http://127.0.0.1:2019${path}`,
-            ];
-        }
-        this.log.trace({ cmd }, "caddy exec command");
-        const exec = await container.exec({
-            Cmd: cmd,
-            AttachStdout: true,
-            AttachStderr: true,
-        });
-        const stream = await exec.start({});
-        return new Promise((resolve, reject) => {
-            const stdout = [];
-            const stderr = [];
-            const stdoutStream = new PassThrough();
-            const stderrStream = new PassThrough();
-            stdoutStream.on("data", (chunk) => stdout.push(chunk));
-            stderrStream.on("data", (chunk) => stderr.push(chunk));
-            this.docker.modem.demuxStream(stream, stdoutStream, stderrStream);
-            stream.on("end", () => {
-                const output = Buffer.concat(stdout).toString();
-                const errOutput = Buffer.concat(stderr).toString();
-                const durationMs = Math.round(performance.now() - start);
-                this.log.trace({ stdoutBytes: output.length, stderrBytes: errOutput.length }, "caddy exec output");
-                if (errOutput) {
-                    this.log.debug({ method, path, durationMs, stderr: errOutput }, "caddy request failed");
-                    reject(new Error(`Caddy API ${method} ${path} failed: ${errOutput}`));
-                }
-                else {
-                    this.log.debug({ method, path, durationMs }, "caddy request completed");
-                    resolve(output);
-                }
-            });
-        });
-    }
-    async seedCaddyConfig() {
-        const maxWait = 30000;
-        const interval = 2000;
-        let waited = 0;
-        this.log.debug("waiting for proxy container");
-        while (waited < maxWait) {
-            try {
-                await this.findProxyContainer();
-                break;
-            }
-            catch (err) {
-                this.log.debug({ err, waited, maxWait }, "proxy container not ready");
-                await new Promise((r) => setTimeout(r, interval));
-                waited += interval;
-            }
-        }
-        const baseConfig = {
-            logging: {
-                logs: {
-                    default: {
-                        level: "INFO",
-                    },
-                },
-            },
-            apps: {
-                http: {
-                    servers: {
-                        main: {
-                            listen: [":443", ":80"],
-                            routes: [],
-                            logs: {},
-                        },
-                    },
-                },
-            },
-        };
-        const maxAttempts = 5;
-        for (let attempt = 0; attempt < maxAttempts; attempt++) {
-            try {
-                this.log.debug({ attempt: attempt + 1, max: maxAttempts }, "seeding caddy config");
-                await this.caddyApiRequest("POST", "/load", baseConfig);
-                this.log.debug("caddy config seeded");
-                return;
-            }
-            catch (err) {
-                this.log.debug({ err, attempt: attempt + 1, max: maxAttempts }, "seed attempt failed");
-                if (attempt >= Math.floor(maxAttempts * 0.8)) {
-                    this.log.warn({ attempt: attempt + 1, max: maxAttempts }, "seed retry nearing limit");
-                }
-                await new Promise((r) => setTimeout(r, 2000));
-            }
-        }
-        this.log.error("caddy config seed exhausted retries");
-        throw new Error("Failed to seed Caddy config after retries");
-    }
-    async addRoute(resourceId, route, handler) {
-        this.log.debug({ resourceId, route }, "adding route");
-        const caddyRoute = buildCaddyRoute(resourceId, route, handler);
-        // Delete existing route for idempotency
-        try {
-            await this.caddyApiRequest("DELETE", `/id/vyft-${resourceId}`);
-        }
-        catch (err) {
-            this.log.debug({ err, resourceId }, "idempotent route delete failed");
-        }
-        const maxAttempts = 5;
-        for (let attempt = 0; attempt < maxAttempts; attempt++) {
-            try {
-                await this.caddyApiRequest("POST", "/config/apps/http/servers/main/routes", caddyRoute);
-                this.log.debug({ resourceId, route }, "route added");
-                return;
-            }
-            catch (err) {
-                this.log.debug({ err, resourceId, attempt: attempt + 1, max: maxAttempts }, "route add attempt failed");
-                if (attempt === maxAttempts - 1) {
-                    this.log.error({ resourceId, route }, "route add exhausted retries");
-                    throw new Error(`Failed to add route for ${resourceId}`);
-                }
-                await new Promise((r) => setTimeout(r, 2000));
-            }
-        }
-    }
-    async removeRoute(resourceId) {
-        this.log.debug({ resourceId }, "removing route");
-        try {
-            await this.caddyApiRequest("DELETE", `/id/vyft-${resourceId}`);
-            this.log.debug({ resourceId }, "route removed");
-        }
-        catch (err) {
-            this.log.debug({ err, resourceId }, "route removal failed (may not exist)");
-        }
+        this.log.info({ durationMs }, "infrastructure ready");
     }
     async listManagedResources() {
         const resources = [];
@@ -781,9 +521,9 @@ export class DockerClient {
         }
         if (config.route) {
             const port = config.port || 3000;
-            await this.addRoute(service.id, config.route, {
-                handler: "reverse_proxy",
-                upstreams: [{ dial: `${service.id}:${port}` }],
+            await this.proxy.addRoute(service.id, config.route, {
+                host: service.id,
+                port,
             });
         }
         const durationMs = Math.round(performance.now() - start);
@@ -805,10 +545,27 @@ export class DockerClient {
             return false;
         }
     }
+    async waitForHealthy(id, timeoutMs = 120000) {
+        const start = performance.now();
+        const interval = 2000;
+        this.log.debug({ resourceId: id }, "waiting for service to be healthy");
+        while (performance.now() - start < timeoutMs) {
+            const tasks = await this.docker.listTasks({
+                filters: { service: [id], "desired-state": ["running"] },
+            });
+            const healthy = tasks.some((t) => t.Status.State === "running");
+            if (healthy) {
+                this.log.debug({ resourceId: id }, "service is healthy");
+                return;
+            }
+            await new Promise((r) => setTimeout(r, interval));
+        }
+        throw new Error(`Service ${id} did not become healthy within ${timeoutMs}ms`);
+    }
     async removeService(id) {
         const start = performance.now();
         this.log.debug({ resourceId: id }, "removing service");
-        await this.removeRoute(id);
+        await this.proxy.removeRoute(id);
         await this.docker.getService(id).remove();
         const maxWait = 60000;
         const interval = 2000;
@@ -901,13 +658,13 @@ export class DockerClient {
             "vyft.managed": "true",
             "vyft.project": this.project,
         };
-        const command = static_.config.spa
-            ? [
+        const command = static_.config.spa === false
+            ? ["caddy", "file-server", "--root", "/srv", "--listen", ":80"]
+            : [
                 "sh",
                 "-c",
                 "printf ':80 {\\nroot * /srv\\ntry_files {path} /index.html\\nfile_server\\n}\\n' > /etc/caddy/Caddyfile && caddy run --config /etc/caddy/Caddyfile --adapter caddyfile",
-            ]
-            : ["caddy", "file-server", "--root", "/srv", "--listen", ":80"];
+            ];
         const serviceSpec = {
             Name: static_.id,
             Labels: serviceLabels,
@@ -945,9 +702,9 @@ export class DockerClient {
             this.log.debug({ resourceId: static_.id }, "creating caddy service for static site");
             await this.docker.createService(serviceSpec);
         }
-        await this.addRoute(static_.id, static_.config.route, {
-            handler: "reverse_proxy",
-            upstreams: [{ dial: `${static_.id}:80` }],
+        await this.proxy.addRoute(static_.id, static_.config.route, {
+            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");
@@ -956,7 +713,7 @@ export class DockerClient {
     async removeStatic(id) {
         const start = performance.now();
         this.log.debug({ resourceId: id }, "removing static site");
-        await this.removeRoute(id);
+        await this.proxy.removeRoute(id);
         await this.docker.getService(id).remove();
         const maxWait = 30000;
         const interval = 2000;
@@ -989,10 +746,81 @@ export class DockerClient {
         this.log.info({ resourceId: id, durationMs }, "site removed");
         log.step(`Removed ${id}`);
     }
-    async proxyLogs(options) {
-        const container = await this.findProxyContainer();
+    async *serviceLogs(options) {
+        const allServices = await this.docker.listServices({
+            filters: JSON.stringify({
+                label: ["vyft.managed=true", `vyft.project=${this.project}`],
+            }),
+        });
+        const prefix = `${this.project}-`;
+        let matched = allServices;
+        if (options.services && options.services.length > 0) {
+            const filter = new Set(options.services);
+            matched = allServices.filter((svc) => {
+                const name = svc.Spec?.Name || "";
+                const short = name.startsWith(prefix)
+                    ? name.slice(prefix.length)
+                    : name;
+                return filter.has(short) || filter.has(name);
+            });
+        }
+        if (matched.length === 0) {
+            log.warn("No matching services found");
+            return;
+        }
         const tail = options.tail ?? 100;
-        if (options.follow) {
+        // Collect all containers with their short service name
+        const targets = [];
+        for (const svc of matched) {
+            const name = svc.Spec?.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 });
+            }
+        }
+        if (!options.follow) {
+            for (const { container, short } of targets) {
+                const buf = await container.logs({
+                    stdout: true,
+                    stderr: true,
+                    follow: false,
+                    tail,
+                    timestamps: true,
+                });
+                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 {
+                        service: short,
+                        stream: type === 2 ? "stderr" : "stdout",
+                        text,
+                    };
+                    offset += size;
+                }
+            }
+            return;
+        }
+        // Follow mode: merge all container streams concurrently
+        const buffer = [];
+        let notify = null;
+        let active = targets.length;
+        const push = (entry) => {
+            buffer.push(entry);
+            if (notify) {
+                const n = notify;
+                notify = null;
+                n();
+            }
+        };
+        for (const { container, short } of targets) {
             const stream = await container.logs({
                 stdout: true,
                 stderr: true,
@@ -1000,38 +828,38 @@ export class DockerClient {
                 tail,
                 timestamps: true,
             });
-            const stdoutStream = new PassThrough();
-            const stderrStream = new PassThrough();
-            stdoutStream.pipe(process.stdout);
-            stderrStream.pipe(process.stderr);
-            this.docker.modem.demuxStream(stream, stdoutStream, stderrStream);
-            await new Promise((resolve) => {
-                stream.on("end", resolve);
-            });
-        }
-        else {
-            const buf = await container.logs({
-                stdout: true,
-                stderr: true,
-                follow: false,
-                tail,
-                timestamps: true,
+            const stdoutPT = new PassThrough();
+            const stderrPT = new PassThrough();
+            stdoutPT.on("data", (chunk) => {
+                for (const line of chunk.toString().split("\n")) {
+                    if (line)
+                        push({ service: short, stream: "stdout", text: line });
+                }
             });
-            // Demux the multiplexed buffer: each frame has an 8-byte header
-            // [stream_type(1), padding(3), size(4)] followed by the payload.
-            let offset = 0;
-            while (offset + 8 <= buf.length) {
-                const type = buf[offset];
-                const size = buf.readUInt32BE(offset + 4);
-                offset += 8;
-                const payload = buf.subarray(offset, offset + size);
-                if (type === 2) {
-                    process.stderr.write(payload);
+            stderrPT.on("data", (chunk) => {
+                for (const line of chunk.toString().split("\n")) {
+                    if (line)
+                        push({ service: short, stream: "stderr", text: line });
                 }
-                else {
-                    process.stdout.write(payload);
+            });
+            this.docker.modem.demuxStream(stream, stdoutPT, stderrPT);
+            stream.on("end", () => {
+                active--;
+                if (notify && active === 0) {
+                    const n = notify;
+                    notify = null;
+                    n();
                 }
-                offset += size;
+            });
+        }
+        while (active > 0 || buffer.length > 0) {
+            if (buffer.length === 0) {
+                await new Promise((r) => {
+                    notify = r;
+                });
+            }
+            while (buffer.length > 0) {
+                yield buffer.shift();
             }
         }
     }

package/dist/index.d.ts

@@ -2,5 +2,7 @@ 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 type { RuntimeMeta, RuntimeRef } from "./symbols.js";
 export { 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,6 @@
 export { interpolate } from "./interpolate.js";
 export { isInterpolation, isReference, isSecret, validateId, validateRoute, } from "./resource.js";
 export { 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/proxy.d.ts

@@ -0,0 +1,16 @@
+export interface ReverseProxy {
+    /** Ensure the proxy service is running and configured. */
+    ensure(): Promise<void>;
+    /** Register or update a route for a resource. */
+    addRoute(resourceId: string, route: string, target: {
+        host: string;
+        port: number;
+    }): Promise<void>;
+    /** Remove a route for a resource. No-op if it doesn't exist. */
+    removeRoute(resourceId: string): Promise<void>;
+    /** Stream proxy access logs. */
+    logs(options: {
+        follow?: boolean;
+        tail?: number;
+    }): Promise<void>;
+}