vyft 0.3.0-alpha → 0.4.0-alpha

package/dist/build.d.ts

@@ -6,6 +6,7 @@ type BuildOptions = {
     output?: string;
     command?: string;
     env?: Record<string, string>;
+    silent?: boolean;
 };
 export declare function buildStatic(context: string, options: BuildOptions, log?: Logger): Promise<BuildResult>;
 export {};

package/dist/build.js

@@ -25,10 +25,15 @@ export async function buildStatic(context, options, log) {
     if (buildCommand) {
         const start = performance.now();
         log?.info({ command: buildCommand, context: buildContext }, "static build started");
-        const s = spinner();
-        s.start(`Building static site (${buildCommand})`);
-        await exec(buildCommand, buildContext, options.env, log);
-        s.stop("Build complete");
+        if (!options.silent) {
+            const s = spinner();
+            s.start(`Building static site (${buildCommand})`);
+            await exec(buildCommand, buildContext, options.env, log);
+            s.stop("Build complete");
+        }
+        else {
+            await exec(buildCommand, buildContext, options.env, log, true);
+        }
         const durationMs = Math.round(performance.now() - start);
         log?.info({ command: buildCommand, context: buildContext, durationMs }, "static build completed");
     }

package/dist/cli.js

@@ -2,20 +2,17 @@
 import { randomBytes } from "node:crypto";
 import { access, readFile } from "node:fs/promises";
 import path from "node:path";
-import { intro, log, outro } from "@clack/prompts";
+import { log, spinner } from "@clack/prompts";
 import { Command } from "commander";
 import pc from "picocolors";
 import { getCurrentContextName, listContexts, removeContext, resolveContext, saveContext, setCurrentContext, } from "./context.js";
 import { DockerClient } from "./docker.js";
 import { init } from "./init.js";
+import { DevRunner, detectPackageManager, LocalRuntime, resolveDevEnv, } from "./local/index.js";
 import { logger } from "./logger.js";
+import { isInterpolation, isReference } from "./resource.js";
+import { isManaged } from "./services/index.js";
 import { VYFT_RUNTIME } from "./symbols.js";
-const DEPLOY_ORDER = {
-    secret: 0,
-    volume: 1,
-    service: 2,
-    site: 3,
-};
 const DESTROY_ORDER = {
     site: 0,
     service: 1,
@@ -111,57 +108,246 @@ function createRuntime(resources, project, sessionLogger) {
     }
     return new DockerClient(project, { host, parentLogger: sessionLogger });
 }
+function stripPrefix(id, project) {
+    const prefix = `${project}-`;
+    return id.startsWith(prefix) ? id.slice(prefix.length) : id;
+}
+/** Limits concurrent async work to avoid exhausting SSH channels. */
+function createSemaphore(limit) {
+    let active = 0;
+    const queue = [];
+    return {
+        async acquire() {
+            if (active < limit) {
+                active++;
+                return;
+            }
+            await new Promise((r) => queue.push(r));
+        },
+        release() {
+            const next = queue.shift();
+            if (next) {
+                next();
+            }
+            else {
+                active--;
+            }
+        },
+    };
+}
+const MAX_CONCURRENCY = 6;
+async function executeGraph(tasks, onStart, onComplete) {
+    const taskMap = new Map(tasks.map((t) => [t.id, t]));
+    const promises = new Map();
+    const sem = createSemaphore(MAX_CONCURRENCY);
+    function resolve(id) {
+        if (promises.has(id))
+            return promises.get(id);
+        const task = taskMap.get(id);
+        const p = (async () => {
+            await Promise.all(task.deps.map((d) => resolve(d)));
+            await sem.acquire();
+            try {
+                onStart(task.id);
+                const result = await task.run();
+                onComplete(task.id, result);
+            }
+            finally {
+                sem.release();
+            }
+        })();
+        promises.set(id, p);
+        return p;
+    }
+    await Promise.all(tasks.map((t) => resolve(t.id)));
+}
+function getServiceDeps(svc, resources) {
+    const deps = [];
+    const resourceIds = new Set(resources.map((r) => r.id));
+    for (const dep of svc.config.dependsOn ?? [])
+        deps.push(dep.id);
+    if (typeof svc.config.image === "object")
+        deps.push(`build:${svc.id}`);
+    for (const { volume } of svc.config.volumes ?? []) {
+        if (resourceIds.has(volume.id))
+            deps.push(volume.id);
+    }
+    if (svc.config.env) {
+        for (const value of Object.values(svc.config.env)) {
+            if (isReference(value)) {
+                if (resourceIds.has(value.id))
+                    deps.push(value.id);
+            }
+            else if (isInterpolation(value)) {
+                for (const v of value.values) {
+                    if (isReference(v) && resourceIds.has(v.id))
+                        deps.push(v.id);
+                }
+            }
+        }
+    }
+    return deps;
+}
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    return `${(ms / 1000).toFixed(1)}s`;
+}
 async function deploy(configFile, verbose) {
     const sessionId = randomBytes(4).toString("hex");
     const sessionLog = logger.child({ sessionId, command: "deploy" });
     const start = performance.now();
     const project = await findProjectName(configFile);
     process.env.VYFT_PROJECT = project;
-    intro(`Deploying ${project}`);
+    log.step(`Deploying ${pc.bold(project)}`);
     const config = await import(configFile);
     const resources = collectResources(config);
     if (resources.length === 0) {
         log.warn("No resources found");
-        outro();
         return;
     }
     sessionLog.info({ project, resourceCount: resources.length }, "deploy started");
-    resources.sort((a, b) => DEPLOY_ORDER[a.type] - DEPLOY_ORDER[b.type]);
-    // Topologically sort services so dependencies deploy first
-    const services = resources.filter((r) => r.type === "service");
-    const nonServices = resources.filter((r) => r.type !== "service");
-    const sorted = topoSortServices(services);
-    const ordered = [...nonServices, ...sorted];
+    const docker = createRuntime(resources, project, sessionLog);
+    docker.verbose = verbose;
+    await docker.ensureInfrastructure();
+    const currentResources = await docker.listManagedResources();
+    const silent = !verbose;
     // Collect which service IDs have dependents waiting on them
+    const services = resources.filter((r) => r.type === "service");
     const depTargets = new Set();
     for (const svc of services) {
         for (const dep of svc.config.dependsOn ?? []) {
             depTargets.add(dep.id);
         }
     }
-    const docker = createRuntime(resources, project, sessionLog);
-    docker.verbose = verbose;
-    await docker.ensureInfrastructure();
-    const currentResources = await docker.listManagedResources();
-    let created = 0;
-    let skipped = 0;
-    for (const resource of ordered) {
-        const exists = await docker.exists(resource);
-        if (exists && resource.type !== "service" && resource.type !== "site") {
-            log.success(resource.id);
-            skipped++;
+    // Build DAG tasks
+    const tasks = [];
+    // Secrets & volumes: no deps, check existence first
+    for (const r of resources) {
+        if (r.type === "secret" || r.type === "volume") {
+            tasks.push({
+                id: r.id,
+                deps: [],
+                run: async () => {
+                    const name = stripPrefix(r.id, project);
+                    if (await docker.exists(r)) {
+                        return { name, action: "updated", unchanged: true, duration: 0 };
+                    }
+                    const result = await docker.create(r);
+                    return { name, ...result, unchanged: false };
+                },
+            });
         }
-        else {
-            await docker.create(resource);
-            created++;
+    }
+    // Image builds: no deps
+    for (const svc of services) {
+        if (typeof svc.config.image === "object") {
+            tasks.push({
+                id: `build:${svc.id}`,
+                deps: [],
+                run: async () => {
+                    const name = stripPrefix(svc.id, project);
+                    const buildStart = performance.now();
+                    await docker.buildImage(svc);
+                    const duration = Math.round(performance.now() - buildStart);
+                    return { name, action: "created", unchanged: false, duration };
+                },
+            });
         }
-        // Wait for services that other services depend on
-        if (resource.type === "service" && depTargets.has(resource.id)) {
-            await docker.waitForHealthy(resource.id);
+    }
+    // Services: depend on their secrets, volumes, image builds, and dependsOn
+    for (const svc of services) {
+        const deps = getServiceDeps(svc, resources);
+        tasks.push({
+            id: svc.id,
+            deps,
+            run: async () => {
+                const name = stripPrefix(svc.id, project);
+                const result = await docker.create(svc);
+                if (depTargets.has(svc.id)) {
+                    await docker.waitForHealthy(svc.id);
+                }
+                return { name, ...result, unchanged: false };
+            },
+        });
+    }
+    // Sites: no deps (buildStatic runs internally)
+    for (const r of resources) {
+        if (r.type === "site") {
+            tasks.push({
+                id: r.id,
+                deps: [],
+                run: async () => {
+                    const name = stripPrefix(r.id, project);
+                    const result = await docker.create(r, { silent });
+                    return { name, ...result, unchanged: false };
+                },
+            });
         }
     }
+    // Execute the graph
+    const results = [];
+    const inProgress = new Set();
+    if (verbose) {
+        // Verbose: print each item as it completes
+        await executeGraph(tasks, () => { }, (id, result) => {
+            results.push(result);
+            if (id.startsWith("build:")) {
+                log.success(`${pc.bold(result.name)}  ${pc.dim("built")}  ${pc.dim(formatDuration(result.duration))}`);
+            }
+            else if (result.unchanged) {
+                log.step(`${pc.bold(result.name)}  ${pc.dim("exists")}`);
+            }
+            else {
+                const route = result.route
+                    ? `  ${pc.dim("\u2192")}  ${result.route}`
+                    : "";
+                log.success(`${pc.bold(result.name)}  ${pc.dim(result.action)}${route}`);
+            }
+        });
+    }
+    else {
+        // Normal mode: single spinner, update message with in-progress tasks
+        const s = spinner();
+        function updateSpinner() {
+            const active = [...inProgress].map((id) => id.startsWith("build:")
+                ? `Building ${stripPrefix(id.slice(6), project)}`
+                : `deploying ${stripPrefix(id, project)}`);
+            if (active.length === 0)
+                return;
+            const first = active[0];
+            const rest = active.length > 1 ? ` · ${active.slice(1).join(", ")}` : "";
+            s.message(`${first}${rest}`);
+        }
+        s.start("Deploying");
+        await executeGraph(tasks, (id) => {
+            // Skip build tasks from spinner display (they show as "Building X")
+            inProgress.add(id);
+            updateSpinner();
+        }, (id, result) => {
+            results.push(result);
+            inProgress.delete(id);
+            updateSpinner();
+        });
+        s.stop("Deployed");
+    }
+    // Summary
+    const unchanged = results.filter((r) => r.unchanged);
+    const changed = results.filter((r) => !r.unchanged && !r.name.startsWith("build:"));
+    if (unchanged.length > 0) {
+        log.message(`${unchanged.length} resource${unchanged.length === 1 ? "" : "s"} unchanged`);
+    }
+    if (!verbose && changed.length > 0) {
+        const nameWidth = Math.max(...changed.map((r) => r.name.length));
+        const actionWidth = Math.max(...changed.map((r) => r.action.length));
+        const lines = changed.map((r) => {
+            const route = r.route ? `  ${pc.dim("\u2192")}  ${r.route}` : "";
+            return `${pc.bold(r.name.padEnd(nameWidth))}  ${pc.dim(r.action.padEnd(actionWidth))}${route}`;
+        });
+        log.message(lines.join("\n"));
+    }
+    // Removal phase
     const desiredIds = new Set(resources.map((r) => r.id));
-    // Keep derived secrets whose parent service is still desired
     for (const r of currentResources) {
         if (r.derived && r.parentService && desiredIds.has(r.parentService)) {
             desiredIds.add(r.id);
@@ -175,20 +361,221 @@ async function deploy(configFile, verbose) {
             const resource = { id, type };
             if (await docker.exists(resource)) {
                 await docker.remove(resource);
+                const name = stripPrefix(id, project);
+                if (verbose) {
+                    log.step(`${pc.bold(name)}  ${pc.dim("removed")}`);
+                }
                 removed++;
             }
         }
+        if (!verbose && removed > 0) {
+            log.message(`${removed} resource${removed === 1 ? "" : "s"} removed`);
+        }
     }
     const durationMs = Math.round(performance.now() - start);
-    sessionLog.info({ project, created, removed, skipped, durationMs }, "deploy completed");
-    outro("Deploy complete");
+    const created = changed.length;
+    sessionLog.info({ project, created, removed, skipped: unchanged.length, durationMs }, "deploy completed");
+    docker.destroy();
+    log.step(pc.dim(formatDuration(durationMs)));
+}
+async function dev(configFile, verbose) {
+    const sessionId = randomBytes(4).toString("hex");
+    const sessionLog = logger.child({ sessionId, command: "dev" });
+    const project = await findProjectName(configFile);
+    process.env.VYFT_PROJECT = project;
+    const projectRoot = path.dirname(configFile);
+    const config = await import(configFile);
+    const resources = collectResources(config);
+    if (resources.length === 0) {
+        log.warn("No resources found");
+        return;
+    }
+    log.step("vyft dev");
+    // Partition resources
+    const managedSecrets = [];
+    const managedVolumes = [];
+    const managedServices = [];
+    const userServices = [];
+    for (const r of resources) {
+        if (r.type === "secret" && isManaged(r)) {
+            managedSecrets.push(r);
+        }
+        else if (r.type === "volume" && isManaged(r)) {
+            managedVolumes.push(r);
+        }
+        else if (r.type === "service" && isManaged(r)) {
+            managedServices.push(r);
+        }
+        else if (r.type === "service" && !isManaged(r)) {
+            userServices.push(r);
+        }
+        else if (r.type === "site" && verbose) {
+            log.info(`Skipping site ${r.id} (not supported in dev mode)`);
+        }
+    }
+    // Color palette for log prefixes
+    const colors = [pc.cyan, pc.magenta, pc.green, pc.yellow, pc.blue, pc.red];
+    const colorMap = new Map();
+    let colorIdx = 0;
+    function getColor(name) {
+        if (!colorMap.has(name)) {
+            colorMap.set(name, colors[colorIdx++ % colors.length]);
+        }
+        return colorMap.get(name);
+    }
+    const singleProcess = userServices.length === 1 && !verbose;
+    function writeLog(name, stream, text) {
+        if (singleProcess) {
+            const line = text.endsWith("\n") ? text : `${text}\n`;
+            const dest = stream === "stderr" ? process.stderr : process.stdout;
+            dest.write(line);
+            return;
+        }
+        const short = stripPrefix(name, project);
+        const color = getColor(short);
+        const prefix = `${color(pc.bold(short))} ${pc.dim("|")} `;
+        const line = text.endsWith("\n") ? text : `${text}\n`;
+        const dest = stream === "stderr" ? process.stderr : process.stdout;
+        dest.write(`${prefix}${line}`);
+    }
+    const runtime = new LocalRuntime(project, { parentLogger: sessionLog });
+    const devRunner = new DevRunner({ onLog: writeLog });
+    // Graceful shutdown
+    let stopping = false;
+    async function shutdown() {
+        if (stopping)
+            return;
+        stopping = true;
+        process.stdout.write("\n");
+        const s = spinner();
+        s.start("Shutting down");
+        devRunner.stop();
+        await runtime.stop();
+        s.stop("Stopped");
+        process.exit(0);
+    }
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    // Topo-sort managed services
+    const sortedManaged = topoSortServices(managedServices);
+    const depTargets = new Set();
+    for (const svc of managedServices) {
+        for (const dep of svc.config.dependsOn ?? []) {
+            depTargets.add(dep.id);
+        }
+    }
+    const servicePorts = new Map();
+    const hostRemap = new Map();
+    // Start spinner (normal mode only)
+    const s = verbose ? null : spinner();
+    s?.start("Starting services");
+    // 1. Create infrastructure
+    await runtime.ensureInfrastructure();
+    // 2. Create secrets (in-memory)
+    for (const secret of managedSecrets) {
+        runtime.createSecret(secret);
+        if (verbose)
+            log.step(`Generated ${stripPrefix(secret.id, project)}`);
+    }
+    // 3. Create volumes
+    for (const vol of managedVolumes) {
+        await runtime.createVolume(vol);
+        if (verbose)
+            log.step(`Volume ${stripPrefix(vol.id, project)}`);
+    }
+    // 4. Create managed services
+    for (const svc of sortedManaged) {
+        const port = await runtime.createService(svc);
+        servicePorts.set(svc.id, port);
+        hostRemap.set(svc.host, "localhost");
+        if (verbose)
+            log.step(`Started ${stripPrefix(svc.id, project)} on localhost:${port}`);
+        if (depTargets.has(svc.id)) {
+            await runtime.waitForHealthy(svc.id);
+        }
+    }
+    // Wait for remaining health checks
+    for (const svc of sortedManaged) {
+        if (!depTargets.has(svc.id)) {
+            await runtime.waitForHealthy(svc.id);
+        }
+    }
+    s?.stop("Services ready");
+    // 5. Build dev processes for user services
+    const pm = detectPackageManager(projectRoot);
+    const secretValues = new Map();
+    for (const secret of managedSecrets) {
+        const val = runtime.getSecretValue(secret.id);
+        if (val)
+            secretValues.set(secret.id, val);
+    }
+    const devProcesses = userServices.map((svc) => {
+        const devConfig = svc.config.dev;
+        const command = devConfig?.command ?? `${pm} run dev`;
+        const cwd = devConfig?.cwd
+            ? path.resolve(projectRoot, devConfig.cwd)
+            : projectRoot;
+        const env = svc.config.env
+            ? resolveDevEnv(svc.config.env, secretValues, hostRemap)
+            : {};
+        return { service: svc, command, cwd, env };
+    });
+    if (devProcesses.length === 0 && sortedManaged.length === 0) {
+        log.warn("Nothing to run");
+        return;
+    }
+    // Print summary table
+    const allNames = [
+        ...sortedManaged.map((svc) => stripPrefix(svc.id, project)),
+        ...devProcesses.map((dp) => stripPrefix(dp.service.id, project)),
+    ];
+    const nameWidth = allNames.length > 0 ? Math.max(...allNames.map((n) => n.length)) : 0;
+    const tableLines = [];
+    if (sortedManaged.length > 0) {
+        const imageWidth = Math.max(...sortedManaged.map((svc) => (typeof svc.config.image === "string" ? svc.config.image : "custom")
+            .length));
+        for (const svc of sortedManaged) {
+            const short = stripPrefix(svc.id, project);
+            const image = typeof svc.config.image === "string" ? svc.config.image : "custom";
+            const port = servicePorts.get(svc.id) ?? svc.port;
+            tableLines.push(`${pc.bold(short.padEnd(nameWidth))}  ${pc.dim(image.padEnd(imageWidth))}  ${pc.cyan(`localhost:${port}`)}`);
+        }
+    }
+    if (devProcesses.length > 0) {
+        if (tableLines.length > 0)
+            tableLines.push("");
+        for (const dp of devProcesses) {
+            const short = stripPrefix(dp.service.id, project);
+            tableLines.push(`${pc.bold(short.padEnd(nameWidth))}  ${pc.dim(dp.command)}`);
+        }
+    }
+    if (tableLines.length > 0) {
+        log.message(tableLines.join("\n"));
+    }
+    log.message(pc.dim("Ctrl+C to stop"));
+    // 6. Start dev processes
+    if (devProcesses.length > 0) {
+        devRunner.start(devProcesses);
+    }
+    // 7. Stream container logs (verbose only)
+    if (verbose) {
+        for (const svc of sortedManaged) {
+            (async () => {
+                for await (const entry of runtime.containerLogs(svc.id)) {
+                    writeLog(svc.id, entry.stream, entry.text);
+                }
+            })();
+        }
+    }
+    // Keep alive until signal
+    await new Promise(() => { });
 }
 async function destroy(searchDir, host) {
     const sessionId = randomBytes(4).toString("hex");
     const sessionLog = logger.child({ sessionId, command: "destroy" });
     const start = performance.now();
     const project = await findProjectName(path.join(searchDir, "dummy"));
-    intro(`Destroying ${project}`);
+    log.step(`Destroying ${pc.bold(project)}`);
     const docker = new DockerClient(project, {
         host,
         parentLogger: sessionLog,
@@ -196,23 +583,57 @@ async function destroy(searchDir, host) {
     const currentResources = await docker.listManagedResources();
     if (currentResources.length === 0) {
         log.warn("No resources found");
-        outro();
+        docker.destroy();
         return;
     }
     sessionLog.info({ project, resourceCount: currentResources.length }, "destroy started");
-    const sorted = [...currentResources].sort((a, b) => DESTROY_ORDER[a.type] - DESTROY_ORDER[b.type]);
-    let removed = 0;
-    for (const { id, type } of sorted) {
-        const resource = { id, type };
-        if (await docker.exists(resource)) {
-            await docker.remove(resource);
-            removed++;
-        }
+    // Group by type: services/sites first (parallel), then volumes/secrets (parallel)
+    const servicesSites = currentResources.filter((r) => r.type === "service" || r.type === "site");
+    const volumesSecrets = currentResources.filter((r) => r.type === "volume" || r.type === "secret");
+    const removed = [];
+    const sem = createSemaphore(MAX_CONCURRENCY);
+    async function removeGroup(group, onRemoved) {
+        await Promise.all(group.map(async ({ id, type }) => {
+            await sem.acquire();
+            try {
+                const resource = { id, type };
+                if (await docker.exists(resource)) {
+                    await docker.remove(resource);
+                    const name = stripPrefix(id, project);
+                    removed.push(name);
+                    onRemoved(name);
+                }
+            }
+            finally {
+                sem.release();
+            }
+        }));
+    }
+    const s = spinner();
+    s.start("Destroying");
+    // Phase 1: Remove services and sites in parallel
+    if (servicesSites.length > 0) {
+        await removeGroup(servicesSites, (name) => {
+            s.message(`removing ${name}`);
+        });
+    }
+    // Phase 2: Remove volumes and secrets in parallel
+    if (volumesSecrets.length > 0) {
+        await removeGroup(volumesSecrets, (name) => {
+            s.message(`removing ${name}`);
+        });
     }
     await docker.removeProjectNetwork();
+    s.stop("Destroyed");
+    if (removed.length > 0) {
+        const nameWidth = Math.max(...removed.map((n) => n.length));
+        const lines = removed.map((name) => `${pc.bold(name.padEnd(nameWidth))}  ${pc.dim("removed")}`);
+        log.message(lines.join("\n"));
+    }
     const durationMs = Math.round(performance.now() - start);
-    sessionLog.info({ project, removed, durationMs }, "destroy completed");
-    outro("Destroy complete");
+    sessionLog.info({ project, removed: removed.length, durationMs }, "destroy completed");
+    docker.destroy();
+    log.step(pc.dim(formatDuration(durationMs)));
 }
 const program = new Command();
 program
@@ -250,6 +671,29 @@ program
         throw err;
     }
 });
+program
+    .command("dev")
+    .description("Start local development environment")
+    .argument("[config-file]", "path to config file", "vyft.config.ts")
+    .option("--verbose", "show detailed output", false)
+    .action(async (configFile, opts) => {
+    const absolutePath = path.resolve(process.cwd(), configFile);
+    if (configFile === "vyft.config.ts") {
+        try {
+            await access(absolutePath);
+        }
+        catch {
+            program.error("No config file specified and vyft.config.ts not found");
+        }
+    }
+    try {
+        await dev(absolutePath, opts.verbose);
+    }
+    catch (err) {
+        logger.fatal({ err }, "dev failed");
+        throw err;
+    }
+});
 const proxy = program.command("proxy").description("Manage the proxy");
 proxy
     .command("logs")