vyft 0.2.0-alpha → 0.3.0-alpha

package/README.md

@@ -14,28 +14,17 @@ This scaffolds a fullstack project with a Hono API, React SPA, and Postgres —
 
 ```typescript
 // vyft.config.ts
-import { interpolate } from 'vyft';
-import { swarm } from 'vyft/swarm';
+import { service, secret, postgres, site } from 'vyft';
 
-const { service, secret, volume, site } = swarm();
-
-export const dbPassword = secret('db-password', { length: 32 });
-export const dbData = volume('db-data', { size: '10GB' });
-
-export const db = service('db', {
-  image: 'postgres:17',
-  volumes: [{ volume: dbData, mount: '/var/lib/postgresql/data' }],
-  env: {
-    POSTGRES_PASSWORD: dbPassword,
-    POSTGRES_DB: 'myapp',
-  }
-});
+export const authSecret = secret('auth-secret', { length: 64 });
+export const db = postgres('db');
 
 export const api = service('api', {
   route: 'example.com/api/*',
   image: { dockerfile: './apps/api/Dockerfile' },
   env: {
-    DATABASE_URL: interpolate`postgres://postgres:${dbPassword}@${db.host}:5432/myapp`,
+    DATABASE_URL: db.url,
+    AUTH_SECRET: authSecret,
   }
 });
 

package/dist/cli.js

@@ -4,6 +4,8 @@ import { access, readFile } from "node:fs/promises";
 import path from "node:path";
 import { intro, log, outro } 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 { logger } from "./logger.js";
@@ -67,23 +69,47 @@ function collectResources(exports) {
     }
     return resources;
 }
+function topoSortServices(services) {
+    const byId = new Map(services.map((s) => [s.id, s]));
+    const visited = new Set();
+    const result = [];
+    function visit(svc) {
+        if (visited.has(svc.id))
+            return;
+        visited.add(svc.id);
+        for (const dep of svc.config.dependsOn ?? []) {
+            const depSvc = byId.get(dep.id);
+            if (depSvc)
+                visit(depSvc);
+        }
+        result.push(svc);
+    }
+    for (const svc of services)
+        visit(svc);
+    return result;
+}
 function hasRuntime(value) {
     return (typeof value === "object" &&
         value !== null &&
         VYFT_RUNTIME in value);
 }
+function getContextHost() {
+    const ctx = resolveContext(program.opts().context);
+    return ctx?.host;
+}
 function createRuntime(resources, project, sessionLogger) {
+    const host = getContextHost();
     const ref = resources.find((r) => hasRuntime(r));
     if (ref && hasRuntime(ref)) {
         const meta = ref[VYFT_RUNTIME];
         switch (meta.name) {
             case "swarm":
-                return new DockerClient(project, sessionLogger);
+                return new DockerClient(project, { host, parentLogger: sessionLogger });
             default:
                 throw new Error(`Unknown runtime: ${meta.name}`);
         }
     }
-    return new DockerClient(project, sessionLogger);
+    return new DockerClient(project, { host, parentLogger: sessionLogger });
 }
 async function deploy(configFile, verbose) {
     const sessionId = randomBytes(4).toString("hex");
@@ -101,13 +127,25 @@ async function deploy(configFile, verbose) {
     }
     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];
+    // Collect which service IDs have dependents waiting on them
+    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 resources) {
+    for (const resource of ordered) {
         const exists = await docker.exists(resource);
         if (exists && resource.type !== "service" && resource.type !== "site") {
             log.success(resource.id);
@@ -117,6 +155,10 @@ async function deploy(configFile, verbose) {
             await docker.create(resource);
             created++;
         }
+        // Wait for services that other services depend on
+        if (resource.type === "service" && depTargets.has(resource.id)) {
+            await docker.waitForHealthy(resource.id);
+        }
     }
     const desiredIds = new Set(resources.map((r) => r.id));
     // Keep derived secrets whose parent service is still desired
@@ -141,13 +183,16 @@ async function deploy(configFile, verbose) {
     sessionLog.info({ project, created, removed, skipped, durationMs }, "deploy completed");
     outro("Deploy complete");
 }
-async function destroy(searchDir) {
+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}`);
-    const docker = new DockerClient(project, sessionLog);
+    const docker = new DockerClient(project, {
+        host,
+        parentLogger: sessionLog,
+    });
     const currentResources = await docker.listManagedResources();
     if (currentResources.length === 0) {
         log.warn("No resources found");
@@ -173,7 +218,8 @@ const program = new Command();
 program
     .name("vyft")
     .description("Deploy apps to Docker Swarm with TypeScript")
-    .version("0.1.0");
+    .version("0.1.0")
+    .option("--context <name>", "override active context for this invocation");
 program
     .command("init")
     .description("Create a new project")
@@ -212,12 +258,51 @@ proxy
     .option("--tail <n>", "number of lines to show", "100")
     .action(async (opts) => {
     const project = await findProjectName(path.join(process.cwd(), "package.json"));
-    const docker = new DockerClient(project);
-    await docker.proxyLogs({
+    const docker = new DockerClient(project, { host: getContextHost() });
+    await docker.proxy.logs({
         follow: opts.follow,
         tail: parseInt(opts.tail, 10),
     });
 });
+program
+    .command("logs")
+    .description("View service logs")
+    .argument("[services...]", "service names to filter (short names without project prefix)")
+    .option("-f, --follow", "stream logs continuously", false)
+    .option("--tail <n>", "number of lines to show", "100")
+    .action(async (services, opts) => {
+    const project = await findProjectName(path.join(process.cwd(), "package.json"));
+    const docker = new DockerClient(project, { host: getContextHost() });
+    // Support comma-separated names: "api,web" -> ["api", "web"]
+    const parsed = services.flatMap((s) => s.split(","));
+    const logs = docker.serviceLogs({
+        follow: opts.follow,
+        tail: parseInt(opts.tail, 10),
+        services: parsed.length > 0 ? parsed : undefined,
+    });
+    const colors = [
+        pc.cyan,
+        pc.magenta,
+        pc.green,
+        pc.yellow,
+        pc.blue,
+        pc.red,
+    ];
+    const colorMap = new Map();
+    let colorIdx = 0;
+    for await (const entry of logs) {
+        if (!colorMap.has(entry.service)) {
+            colorMap.set(entry.service, colors[colorIdx++ % colors.length]);
+        }
+        const color = colorMap.get(entry.service);
+        const prefix = parsed.length === 1
+            ? ""
+            : `${color(pc.bold(entry.service))} ${pc.dim("|")} `;
+        const line = entry.text.endsWith("\n") ? entry.text : `${entry.text}\n`;
+        const dest = entry.stream === "stderr" ? process.stderr : process.stdout;
+        dest.write(`${prefix}${line}`);
+    }
+});
 program
     .command("destroy")
     .description("Destroy all deployed resources")
@@ -227,11 +312,87 @@ program
         ? path.resolve(process.cwd(), configFile)
         : process.cwd();
     try {
-        await destroy(absolutePath);
+        await destroy(absolutePath, getContextHost());
     }
     catch (err) {
         logger.fatal({ err }, "destroy failed");
         throw err;
     }
 });
+const context = program
+    .command("context")
+    .description("Manage deployment contexts");
+context
+    .command("create")
+    .description("Create a new context")
+    .argument("<name>", "context name")
+    .requiredOption("--host <endpoint>", "Docker endpoint (e.g. ssh://root@1.2.3.4)")
+    .option("--runtime <rt>", "runtime backend", "swarm")
+    .option("--description <text>", "optional description")
+    .action((name, opts) => {
+    saveContext({
+        name,
+        host: opts.host,
+        runtime: opts.runtime,
+        description: opts.description,
+    });
+    console.log(`Context "${name}" created`);
+});
+context
+    .command("ls")
+    .description("List all contexts")
+    .action(() => {
+    const contexts = listContexts();
+    if (contexts.length === 0) {
+        console.log("No contexts configured. Create one with: vyft context create <name> --host <endpoint>");
+        return;
+    }
+    const current = getCurrentContextName();
+    for (const ctx of contexts) {
+        const marker = ctx.name === current ? "* " : "  ";
+        const desc = ctx.description ? ` - ${ctx.description}` : "";
+        const host = ctx.host ? ` (${ctx.host})` : "";
+        console.log(`${marker}${ctx.name}${host}${desc}`);
+    }
+});
+context
+    .command("show")
+    .description("Print current context name")
+    .action(() => {
+    const name = getCurrentContextName();
+    if (!name) {
+        console.log("No context set");
+    }
+    else {
+        console.log(name);
+    }
+});
+context
+    .command("use")
+    .description("Set the active context")
+    .argument("<name>", "context name")
+    .action((name) => {
+    setCurrentContext(name);
+    console.log(`Switched to context "${name}"`);
+});
+context
+    .command("rm")
+    .description("Remove a context")
+    .argument("<name>", "context name")
+    .action((name) => {
+    removeContext(name);
+    console.log(`Context "${name}" removed`);
+});
+context
+    .command("inspect")
+    .description("Print context as JSON")
+    .argument("[name]", "context name (defaults to current)")
+    .action((name) => {
+    const ctx = resolveContext(name);
+    if (!ctx) {
+        console.log("No context set");
+        return;
+    }
+    console.log(JSON.stringify(ctx, null, 2));
+});
 await program.parseAsync();

package/dist/context.d.ts

@@ -0,0 +1,39 @@
+/** A named deployment target storing a host endpoint and runtime backend. */
+export interface VyftContext {
+    /** Unique context name (e.g. `"prod"`, `"staging"`). */
+    name: string;
+    /** Docker endpoint (e.g. `"ssh://root@1.2.3.4"`). `undefined` means local socket. */
+    host?: string;
+    /** Runtime backend. Currently only `"swarm"`. */
+    runtime: string;
+    /** Optional human-readable description. */
+    description?: string;
+}
+/** Returns the vyft config directory, creating it if necessary. Respects `$XDG_CONFIG_HOME`. */
+export declare function configDir(): string;
+/** Load a context by name. Returns `undefined` if no matching file exists. */
+export declare function getContext(name: string): VyftContext | undefined;
+/** List all explicitly created contexts. */
+export declare function listContexts(): VyftContext[];
+/**
+ * Persist a context to disk.
+ */
+export declare function saveContext(ctx: VyftContext): void;
+/**
+ * Delete a context from disk.
+ * @throws If the context is currently active or doesn't exist.
+ */
+export declare function removeContext(name: string): void;
+/** Read the active context name from `config.json`. Returns `undefined` when no context is set. */
+export declare function getCurrentContextName(): string | undefined;
+/**
+ * Set the active context.
+ * @throws If the named context doesn't exist.
+ */
+export declare function setCurrentContext(name: string): void;
+/**
+ * Resolve a context by name. If no override is given, uses the current active context.
+ * Returns `undefined` when no context is configured and no override is provided.
+ * @throws If a named context doesn't exist.
+ */
+export declare function resolveContext(override?: string): VyftContext | undefined;

package/dist/context.js

@@ -0,0 +1,101 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+/** Returns the vyft config directory, creating it if necessary. Respects `$XDG_CONFIG_HOME`. */
+export function configDir() {
+    const xdg = process.env.XDG_CONFIG_HOME;
+    const dir = xdg
+        ? path.join(xdg, "vyft")
+        : path.join(os.homedir(), ".config", "vyft");
+    mkdirSync(path.join(dir, "contexts"), { recursive: true });
+    return dir;
+}
+/** Load a context by name. Returns `undefined` if no matching file exists. */
+export function getContext(name) {
+    const file = path.join(configDir(), "contexts", `${name}.json`);
+    if (!existsSync(file))
+        return undefined;
+    return JSON.parse(readFileSync(file, "utf-8"));
+}
+/** List all explicitly created contexts. */
+export function listContexts() {
+    const dir = configDir();
+    const contextsDir = path.join(dir, "contexts");
+    const results = [];
+    if (!existsSync(contextsDir))
+        return results;
+    for (const file of readdirSync(contextsDir)) {
+        if (!file.endsWith(".json"))
+            continue;
+        try {
+            const ctx = JSON.parse(readFileSync(path.join(contextsDir, file), "utf-8"));
+            results.push(ctx);
+        }
+        catch {
+            // skip malformed files
+        }
+    }
+    return results;
+}
+/**
+ * Persist a context to disk.
+ */
+export function saveContext(ctx) {
+    const file = path.join(configDir(), "contexts", `${ctx.name}.json`);
+    writeFileSync(file, `${JSON.stringify(ctx, null, 2)}\n`);
+}
+/**
+ * Delete a context from disk.
+ * @throws If the context is currently active or doesn't exist.
+ */
+export function removeContext(name) {
+    const current = getCurrentContextName();
+    if (name === current) {
+        throw new Error(`Cannot remove "${name}" because it is the active context. Switch first with: vyft context use <other>`);
+    }
+    const file = path.join(configDir(), "contexts", `${name}.json`);
+    if (!existsSync(file)) {
+        throw new Error(`Context "${name}" does not exist`);
+    }
+    rmSync(file);
+}
+/** Read the active context name from `config.json`. Returns `undefined` when no context is set. */
+export function getCurrentContextName() {
+    const file = path.join(configDir(), "config.json");
+    if (!existsSync(file))
+        return undefined;
+    try {
+        const config = JSON.parse(readFileSync(file, "utf-8"));
+        return config.currentContext;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Set the active context.
+ * @throws If the named context doesn't exist.
+ */
+export function setCurrentContext(name) {
+    const ctx = getContext(name);
+    if (!ctx)
+        throw new Error(`Context "${name}" does not exist`);
+    const file = path.join(configDir(), "config.json");
+    const config = { currentContext: name };
+    writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`);
+}
+/**
+ * Resolve a context by name. If no override is given, uses the current active context.
+ * Returns `undefined` when no context is configured and no override is provided.
+ * @throws If a named context doesn't exist.
+ */
+export function resolveContext(override) {
+    const name = override ?? getCurrentContextName();
+    if (!name)
+        return undefined;
+    const ctx = getContext(name);
+    if (!ctx) {
+        throw new Error(`Context "${name}" not found`);
+    }
+    return ctx;
+}

package/dist/docker.d.ts

@@ -1,11 +1,11 @@
 import type { Logger } from "pino";
+import type { ReverseProxy } from "./proxy.js";
 import type { Resource, ResourceType } from "./resource.js";
 import type { Runtime } from "./runtime.js";
 export declare function parseRoute(route: string): {
     host: string;
     path?: string;
 };
-export declare function buildCaddyRoute(resourceId: string, route: string, handler: Record<string, unknown>): Record<string, unknown>;
 export interface ManagedResource {
     id: string;
     type: ResourceType;
@@ -20,15 +20,14 @@ export declare class DockerClient implements Runtime {
     private project;
     private secretValues;
     private log;
+    proxy: ReverseProxy;
     verbose: boolean;
-    constructor(project: string, parentLogger?: Logger);
+    constructor(project: string, opts?: {
+        host?: string;
+        parentLogger?: Logger;
+    });
     private ensureNetwork;
     ensureInfrastructure(): Promise<void>;
-    private findProxyContainer;
-    private caddyApiRequest;
-    private seedCaddyConfig;
-    private addRoute;
-    private removeRoute;
     listManagedResources(): Promise<ManagedResource[]>;
     create(resource: Resource): Promise<void>;
     exists(resource: Resource): Promise<boolean>;
@@ -45,13 +44,19 @@ export declare class DockerClient implements Runtime {
     private resolveEnv;
     private createService;
     private serviceExists;
+    waitForHealthy(id: string, timeoutMs?: number): Promise<void>;
     private removeService;
     private pullImage;
     private createStatic;
     private removeStatic;
-    proxyLogs(options: {
+    serviceLogs(options: {
         follow?: boolean;
         tail?: number;
-    }): Promise<void>;
+        services?: string[];
+    }): AsyncGenerator<{
+        service: string;
+        stream: "stdout" | "stderr";
+        text: string;
+    }>;
     removeProjectNetwork(): Promise<void>;
 }