vyft 0.1.0-alpha

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,195 @@
+# Vyft
+
+Deploy apps with TypeScript.
+
+## Install
+
+```bash
+npm install vyft
+```
+
+## Quick Start
+
+Create `vyft.config.ts`:
+
+```typescript
+import { interpolate } from 'vyft';
+import { swarm } from 'vyft/swarm';
+
+const { secret, volume, service, site } = swarm();
+
+export const dbPassword = secret('db-password');
+export const dbData = volume('db-data', { size: '20GB' });
+
+export const db = service('db', {
+  image: 'postgres:16',
+  env: {
+    POSTGRES_PASSWORD: dbPassword,
+    POSTGRES_DB: 'myapp'
+  },
+  volumes: [
+    { volume: dbData, mount: '/var/lib/postgresql/data' }
+  ]
+});
+
+export const api = service('api', {
+  route: 'api.example.com',
+  image: { context: './api' },
+  env: {
+    DATABASE_URL: interpolate`postgres://postgres:${dbPassword}@${db.host}:5432/myapp`
+  }
+});
+
+export const app = site('app', {
+  route: 'example.com',
+  spa: true,
+  build: { context: './frontend' }
+});
+```
+
+Deploy:
+
+```bash
+vyft deploy
+```
+
+Tear down:
+
+```bash
+vyft destroy
+```
+
+## Runtime
+
+Resources are created through a runtime. The `swarm` runtime manages containers, networking, and routing.
+
+```typescript
+import { swarm } from 'vyft/swarm';
+
+const { secret, volume, service, site } = swarm();
+```
+
+Volumes support size limits (requires xfs with project quotas on the host):
+
+```typescript
+const { volume } = swarm();
+
+export const data = volume('data', { size: '50GB' });
+```
+
+## Primitives
+
+### volume
+
+Persistent storage.
+
+```typescript
+volume('data');
+```
+
+### secret
+
+Auto-generated secure values. Mounted as files at `/run/secrets/<id>`.
+
+```typescript
+const apiKey = secret('api-key');
+const jwtSecret = secret('jwt-secret', { length: 64 });
+```
+
+Pass a secret directly as an env value to mount it. The `_FILE` suffix is added automatically:
+
+```typescript
+env: {
+  API_KEY: apiKey
+}
+// → sets API_KEY_FILE=/run/secrets/api-key
+```
+
+### interpolate
+
+Compose env values that contain secrets. Imported from `vyft`.
+
+```typescript
+import { interpolate } from 'vyft';
+
+env: {
+  DATABASE_URL: interpolate`postgres://user:${dbPassword}@${db.host}:5432/mydb`
+}
+// → sets DATABASE_URL_FILE=/run/secrets/<derived-secret>
+```
+
+The result is stored as a derived secret and mounted as a file.
+
+### service
+
+Run containers.
+
+```typescript
+const api = service('api', {
+  image: { context: './api' },  // Build from directory
+  // or: image: 'node:20',      // Use existing image
+  route: 'api.example.com',
+  port: 3000,
+  env: { NODE_ENV: 'production' },
+  command: ['node', 'server.js'],
+  volumes: [{ volume: data, mount: '/app/data' }],
+  replicas: 3,
+  healthCheck: {
+    command: ['curl', '-f', 'http://localhost:3000/health'],
+    interval: '30s',
+    timeout: '10s',
+    retries: 3
+  },
+  resources: {
+    memory: '512MB',
+    cpus: 0.5
+  },
+  restartPolicy: 'on-failure'
+});
+```
+
+Services expose output properties for referencing elsewhere:
+
+```typescript
+api.host  // internal hostname
+api.port  // internal port (default 3000)
+api.url   // full URL (https if routed, http otherwise)
+```
+
+### site
+
+Serve static sites with automatic builds.
+
+```typescript
+const app = site('app', {
+  route: 'example.com',
+  spa: true,
+  build: {
+    context: './frontend',
+    output: './dist',
+    command: 'npm run build'
+  }
+});
+
+app.url  // https://example.com
+```
+
+## Routing
+
+Routes go through a reverse proxy with automatic SSL.
+
+```typescript
+'example.com'           // Root domain
+'example.com/api/*'     // Path prefix
+'api.example.com'       // Subdomain
+'*.example.com'         // Wildcard subdomain
+```
+
+## Requirements
+
+- Node.js >= 22
+- Docker
+
+## License
+
+MIT

package/dist/build.d.ts

@@ -0,0 +1,11 @@
+import type { Logger } from "pino";
+export interface BuildResult {
+    outputPath: string;
+}
+type BuildOptions = {
+    output?: string;
+    command?: string;
+    env?: Record<string, string>;
+};
+export declare function buildStatic(context: string, options: BuildOptions, log?: Logger): Promise<BuildResult>;
+export {};

package/dist/build.js

@@ -0,0 +1,39 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { spinner } from "@clack/prompts";
+import { exec } from "./exec.js";
+function resolveBuildCommand(context, optionCommand) {
+    if (optionCommand)
+        return optionCommand;
+    const packageJsonPath = path.join(context, "package.json");
+    if (existsSync(packageJsonPath)) {
+        const hasYarn = existsSync(path.join(context, "yarn.lock"));
+        const hasPnpm = existsSync(path.join(context, "pnpm-lock.yaml"));
+        if (hasYarn)
+            return "yarn build";
+        if (hasPnpm)
+            return "pnpm build";
+        return "npm run build";
+    }
+    return undefined;
+}
+export async function buildStatic(context, options, log) {
+    const buildContext = path.resolve(context);
+    const outputDir = options.output ?? "./dist";
+    const outputPath = path.join(buildContext, outputDir);
+    const buildCommand = resolveBuildCommand(buildContext, options.command);
+    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");
+        const durationMs = Math.round(performance.now() - start);
+        log?.info({ command: buildCommand, context: buildContext, durationMs }, "static build completed");
+    }
+    if (!existsSync(outputPath)) {
+        throw new Error(`Output directory not found: ${outputPath}`);
+    }
+    return { outputPath };
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+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 { Command } from "commander";
+import { DockerClient } from "./docker.js";
+import { init } from "./init.js";
+import { logger } from "./logger.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,
+    volume: 2,
+    secret: 3,
+};
+async function findProjectName(configPath) {
+    let dir = path.dirname(configPath);
+    while (dir !== path.dirname(dir)) {
+        try {
+            const pkgPath = path.join(dir, "package.json");
+            const content = await readFile(pkgPath, "utf-8");
+            const pkg = JSON.parse(content);
+            if (pkg.name) {
+                return pkg.name;
+            }
+        }
+        catch {
+            // No package.json here, keep walking up
+        }
+        dir = path.dirname(dir);
+    }
+    throw new Error("Could not find package.json with a name field");
+}
+function isResource(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "type" in value &&
+        "id" in value &&
+        typeof value.type === "string" &&
+        typeof value.id === "string");
+}
+function hasRuntime(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        VYFT_RUNTIME in value);
+}
+function createRuntime(resources, project, sessionLogger) {
+    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);
+            default:
+                throw new Error(`Unknown runtime: ${meta.name}`);
+        }
+    }
+    return new DockerClient(project, sessionLogger);
+}
+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);
+    intro(`Deploying ${project}`);
+    const config = await import(configFile);
+    const resources = Object.values(config).filter(isResource);
+    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]);
+    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) {
+        const exists = await docker.exists(resource);
+        if (exists) {
+            log.success(resource.id);
+            skipped++;
+        }
+        else {
+            await docker.create(resource);
+            created++;
+        }
+    }
+    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);
+        }
+    }
+    const toRemove = currentResources.filter((r) => !desiredIds.has(r.id));
+    let removed = 0;
+    if (toRemove.length > 0) {
+        toRemove.sort((a, b) => DESTROY_ORDER[a.type] - DESTROY_ORDER[b.type]);
+        for (const { id, type } of toRemove) {
+            const resource = { id, type };
+            if (await docker.exists(resource)) {
+                await docker.remove(resource);
+                removed++;
+            }
+        }
+    }
+    const durationMs = Math.round(performance.now() - start);
+    sessionLog.info({ project, created, removed, skipped, durationMs }, "deploy completed");
+    outro("Deploy complete");
+}
+async function destroy(searchDir) {
+    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 currentResources = await docker.listManagedResources();
+    if (currentResources.length === 0) {
+        log.warn("No resources found");
+        outro();
+        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++;
+        }
+    }
+    const durationMs = Math.round(performance.now() - start);
+    sessionLog.info({ project, removed, durationMs }, "destroy completed");
+    outro("Destroy complete");
+}
+const program = new Command();
+program
+    .name("vyft")
+    .description("Deploy apps to Docker Swarm with TypeScript")
+    .version("0.1.0");
+program
+    .command("init")
+    .description("Create a new project")
+    .argument("[directory]", "directory to create the project in")
+    .action(async (directory) => {
+    await init(directory);
+});
+program
+    .command("deploy")
+    .description("Deploy resources from a config file")
+    .argument("[config-file]", "path to config file", "vyft.config.ts")
+    .option("--verbose", "show build 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 deploy(absolutePath, opts.verbose);
+    }
+    catch (err) {
+        logger.fatal({ err }, "deploy failed");
+        throw err;
+    }
+});
+program
+    .command("destroy")
+    .description("Destroy all deployed resources")
+    .argument("[config-file]", "path to config file (used to locate project)")
+    .action(async (configFile) => {
+    const absolutePath = configFile
+        ? path.resolve(process.cwd(), configFile)
+        : process.cwd();
+    try {
+        await destroy(absolutePath);
+    }
+    catch (err) {
+        logger.fatal({ err }, "destroy failed");
+        throw err;
+    }
+});
+await program.parseAsync();

package/dist/docker.d.ts

@@ -0,0 +1,48 @@
+import type { Logger } from "pino";
+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(project: string, resourceId: string, route: string, handler: Record<string, unknown>): Record<string, unknown>;
+export interface ManagedResource {
+    id: string;
+    type: ResourceType;
+    route?: string;
+    derived?: boolean;
+    parentService?: string;
+}
+export declare class DockerClient implements Runtime {
+    private docker;
+    private project;
+    private secretValues;
+    private log;
+    verbose: boolean;
+    constructor(project: string, parentLogger?: Logger);
+    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>;
+    remove(resource: Resource): Promise<void>;
+    private createVolume;
+    private volumeExists;
+    private removeVolume;
+    private createSecret;
+    private secretExists;
+    private removeSecret;
+    private storeSecretData;
+    private lookupSecretId;
+    private createDerivedSecret;
+    private resolveEnv;
+    private createService;
+    private serviceExists;
+    private removeService;
+    private createStatic;
+    private removeStatic;
+}