vyft 0.1.0-alpha

package/dist/exec.d.ts

@@ -0,0 +1,2 @@
+import type { Logger } from "pino";
+export declare function exec(command: string, cwd: string, env?: Record<string, string>, log?: Logger): Promise<void>;

package/dist/exec.js

@@ -0,0 +1,28 @@
+import { spawn } from "node:child_process";
+export async function exec(command, cwd, env, log) {
+    const start = performance.now();
+    log?.debug({ command, cwd }, "process spawning");
+    return new Promise((resolve, reject) => {
+        const proc = spawn(command, {
+            cwd,
+            stdio: "inherit",
+            shell: true,
+            env: env ? { ...process.env, ...env } : undefined,
+        });
+        proc.on("close", (code) => {
+            const durationMs = Math.round(performance.now() - start);
+            if (code !== 0) {
+                log?.debug({ command, cwd, exitCode: code, durationMs }, "process exited with error");
+                reject(new Error(`Command failed with exit code ${code}`));
+            }
+            else {
+                log?.debug({ command, cwd, exitCode: 0, durationMs }, "process exited");
+                resolve();
+            }
+        });
+        proc.on("error", (err) => {
+            log?.debug({ err, command, cwd }, "process spawn failed");
+            reject(err);
+        });
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+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 { RuntimeMeta, RuntimeRef } from "./symbols.js";
+export { VYFT_RUNTIME } from "./symbols.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { interpolate } from "./interpolate.js";
+export { isInterpolation, isReference, isSecret, validateId, validateRoute, } from "./resource.js";
+export { VYFT_RUNTIME } from "./symbols.js";

package/dist/init.d.ts

@@ -0,0 +1 @@
+export declare function init(directory?: string): Promise<void>;

package/dist/init.js

@@ -0,0 +1,100 @@
+import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { confirm, intro, isCancel, log, outro, text } from "@clack/prompts";
+const TEMPLATES_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../templates/fullstack");
+async function walkDir(dir) {
+    const files = [];
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await walkDir(full)));
+        }
+        else {
+            files.push(full);
+        }
+    }
+    return files;
+}
+async function dirExists(dir) {
+    try {
+        const s = await stat(dir);
+        return s.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function dirIsNonEmpty(dir) {
+    try {
+        const entries = await readdir(dir);
+        return entries.length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+export async function init(directory) {
+    intro("Create a new project");
+    const name = await text({
+        message: "Project name",
+        placeholder: "my-app",
+        defaultValue: directory || "my-app",
+        validate(value) {
+            if (!value)
+                return "Project name is required";
+            if (!/^[a-z0-9-]+$/.test(value))
+                return "Use lowercase letters, numbers, and hyphens only";
+        },
+    });
+    if (isCancel(name))
+        return;
+    const domain = await text({
+        message: "Domain",
+        placeholder: "example.com",
+        validate(value) {
+            if (!value)
+                return "Domain is required";
+            if (!/^[a-z0-9.-]+\.[a-z]{2,}$/.test(value))
+                return "Enter a valid domain (e.g. example.com)";
+        },
+    });
+    if (isCancel(domain))
+        return;
+    const targetDir = path.resolve(process.cwd(), directory || name);
+    if ((await dirExists(targetDir)) && (await dirIsNonEmpty(targetDir))) {
+        const ok = await confirm({
+            message: `Directory ${path.basename(targetDir)} is not empty. Continue?`,
+        });
+        if (isCancel(ok) || !ok)
+            return;
+    }
+    const templateFiles = await walkDir(TEMPLATES_DIR);
+    const replacements = {
+        "{{name}}": name,
+        "{{domain}}": domain,
+    };
+    for (const templateFile of templateFiles) {
+        let relativePath = path.relative(TEMPLATES_DIR, templateFile);
+        if (relativePath === "gitignore")
+            relativePath = ".gitignore";
+        if (relativePath === "dockerignore")
+            relativePath = ".dockerignore";
+        const destPath = path.join(targetDir, relativePath);
+        await mkdir(path.dirname(destPath), { recursive: true });
+        let content = await readFile(templateFile, "utf-8");
+        for (const [placeholder, value] of Object.entries(replacements)) {
+            content = content.replaceAll(placeholder, value);
+        }
+        await writeFile(destPath, content);
+        log.step(relativePath);
+    }
+    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");
+    console.log();
+}

package/dist/interpolate.d.ts

@@ -0,0 +1,2 @@
+import type { Interpolation, Reference } from "./resource.js";
+export declare function interpolate(strings: TemplateStringsArray, ...values: Array<Reference | string>): Interpolation;

package/dist/interpolate.js

@@ -0,0 +1,8 @@
+import { isReference } from "./resource.js";
+export function interpolate(strings, ...values) {
+    const hasRef = values.some(isReference);
+    if (!hasRef) {
+        throw new Error("interpolate() requires at least one Reference — use a plain string instead");
+    }
+    return { type: "interpolation", strings, values };
+}

package/dist/logger.d.ts

@@ -0,0 +1,2 @@
+import pino from "pino";
+export declare const logger: pino.Logger<never, boolean>;

package/dist/logger.js

@@ -0,0 +1,10 @@
+import pino from "pino";
+function resolveLevel() {
+    const val = process.env.LOG_LEVEL;
+    if (!val)
+        return "silent";
+    return val;
+}
+export const logger = pino({
+    level: resolveLevel(),
+});

package/dist/resource.d.ts

@@ -0,0 +1,78 @@
+import type { RuntimeRef } from "./symbols.js";
+export type ResourceType = "volume" | "secret" | "service" | "site";
+export type VolumeConfig = {};
+export interface SecretConfig {
+    length?: number;
+}
+export interface HealthCheckConfig {
+    command: string[];
+    interval?: string;
+    timeout?: string;
+    retries?: number;
+    startPeriod?: string;
+}
+export interface ResourceLimits {
+    memory?: string;
+    cpus?: number;
+}
+export interface Volume extends RuntimeRef {
+    type: "volume";
+    id: string;
+    config: VolumeConfig;
+}
+export interface Secret extends RuntimeRef {
+    type: "secret";
+    id: string;
+    config: SecretConfig;
+}
+export interface Service extends RuntimeRef {
+    type: "service";
+    id: string;
+    config: ServiceConfig;
+    host: string;
+    port: number;
+    url: string;
+}
+export interface Site extends RuntimeRef {
+    type: "site";
+    id: string;
+    config: SiteConfig;
+    url: string;
+}
+export type Resource = Volume | Secret | Service | Site;
+export type Reference = Secret;
+export interface Interpolation {
+    type: "interpolation";
+    strings: TemplateStringsArray;
+    values: Array<Reference | string>;
+}
+export type EnvValue = string | Reference | Interpolation;
+export declare function isReference(value: unknown): value is Reference;
+export declare function isSecret(value: unknown): value is Secret;
+export declare function isInterpolation(value: unknown): value is Interpolation;
+export interface ServiceConfig {
+    image: string | {
+        context?: string;
+        dockerfile?: string;
+    };
+    route?: string;
+    port?: number;
+    env?: Record<string, EnvValue>;
+    command?: string[];
+    volumes?: Array<{
+        volume: Volume;
+        mount: string;
+    }>;
+}
+export interface SiteConfig {
+    route: string;
+    spa?: boolean;
+    build: {
+        cwd: string;
+        output?: string;
+        command?: string;
+        env?: Record<string, string>;
+    };
+}
+export declare function validateId(id: string): void;
+export declare function validateRoute(route: string): void;

package/dist/resource.js

@@ -0,0 +1,35 @@
+export function isReference(value) {
+    return isSecret(value);
+}
+export function isSecret(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        value.type === "secret");
+}
+export function isInterpolation(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        value.type === "interpolation");
+}
+// Validation
+const ID_PATTERN = /^[a-z][a-z0-9-]*[a-z0-9]$|^[a-z]$/;
+const ROUTE_PATTERN = /^(\*\.)?[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*(\/.+)?$/;
+export function validateId(id) {
+    if (!id || id.length < 1) {
+        throw new Error("Resource ID cannot be empty");
+    }
+    if (id.length > 63) {
+        throw new Error("Resource ID cannot exceed 63 characters");
+    }
+    if (!ID_PATTERN.test(id)) {
+        throw new Error(`Invalid resource ID "${id}": must start with a letter, contain only lowercase letters, numbers, and hyphens, and end with a letter or number`);
+    }
+}
+export function validateRoute(route) {
+    if (!route) {
+        throw new Error("Route cannot be empty");
+    }
+    if (!ROUTE_PATTERN.test(route)) {
+        throw new Error(`Invalid route "${route}": must be a valid domain with optional path`);
+    }
+}

package/dist/runtime.d.ts

@@ -0,0 +1,6 @@
+import type { Resource } from "./resource.js";
+export interface Runtime {
+    create(resource: Resource): Promise<void>;
+    exists(resource: Resource): Promise<boolean>;
+    remove(resource: Resource): Promise<void>;
+}

package/dist/swarm/factories.d.ts

@@ -0,0 +1,8 @@
+import type { Secret, SecretConfig, Service, Site, SiteConfig, Volume } from "../resource.js";
+import type { StorageDriver, SwarmConfig, SwarmServiceConfig, SwarmVolumeConfig } from "./types.js";
+export declare function createFactories<D extends StorageDriver = "local">(swarmConfig: SwarmConfig<D>): {
+    volume(id: string, config?: SwarmVolumeConfig<D>): Volume;
+    service(id: string, config: SwarmServiceConfig): Service;
+    secret(id: string, config?: SecretConfig): Secret;
+    site(id: string, config: SiteConfig): Site;
+};

package/dist/swarm/factories.js

@@ -0,0 +1,50 @@
+import { validateId, validateRoute } from "../resource.js";
+import { VYFT_RUNTIME } from "../symbols.js";
+function attachRuntime(obj, config) {
+    return Object.assign(obj, {
+        [VYFT_RUNTIME]: { name: "swarm", config },
+    });
+}
+export function createFactories(swarmConfig) {
+    return {
+        volume(id, config = {}) {
+            validateId(id);
+            return attachRuntime({ type: "volume", id, config }, swarmConfig);
+        },
+        service(id, config) {
+            validateId(id);
+            if (config.route) {
+                validateRoute(config.route);
+            }
+            const port = config.port || 3000;
+            return attachRuntime({
+                type: "service",
+                id,
+                config,
+                host: id,
+                port,
+                url: config.route
+                    ? `https://${config.route}`
+                    : `http://${id}:${port}`,
+            }, swarmConfig);
+        },
+        secret(id, config = {}) {
+            validateId(id);
+            return attachRuntime({
+                type: "secret",
+                id,
+                config,
+            }, swarmConfig);
+        },
+        site(id, config) {
+            validateId(id);
+            validateRoute(config.route);
+            return attachRuntime({
+                type: "site",
+                id,
+                config,
+                url: `https://${config.route}`,
+            }, swarmConfig);
+        },
+    };
+}

package/dist/swarm/index.d.ts

@@ -0,0 +1,10 @@
+export { createFactories } from "./factories.js";
+export type { DriverVolumeOptions, StorageDriver, SwarmConfig, SwarmServiceConfig, SwarmVolumeConfig, } from "./types.js";
+import type { Secret, SecretConfig, Service, Site, SiteConfig, Volume } from "../resource.js";
+import type { StorageDriver, SwarmConfig, SwarmServiceConfig, SwarmVolumeConfig } from "./types.js";
+export declare function swarm<D extends StorageDriver = "local">(config?: SwarmConfig<D>): {
+    volume: (id: string, config?: SwarmVolumeConfig<D>) => Volume;
+    service: (id: string, config: SwarmServiceConfig) => Service;
+    secret: (id: string, config?: SecretConfig) => Secret;
+    site: (id: string, config: SiteConfig) => Site;
+};

package/dist/swarm/index.js

@@ -0,0 +1,5 @@
+export { createFactories } from "./factories.js";
+import { createFactories } from "./factories.js";
+export function swarm(config) {
+    return createFactories(config ?? {});
+}

package/dist/swarm/types.d.ts

@@ -0,0 +1,25 @@
+import type { HealthCheckConfig, ResourceLimits, ServiceConfig, VolumeConfig } from "../resource.js";
+export interface DriverVolumeOptions {
+    local: {
+        size?: string;
+    };
+    overlay2: {};
+    btrfs: {
+        size?: string;
+    };
+    zfs: {
+        size?: string;
+        compression?: string;
+    };
+}
+export type StorageDriver = keyof DriverVolumeOptions;
+export interface SwarmConfig<D extends StorageDriver = "local"> {
+    storageDriver?: D;
+}
+export type SwarmVolumeConfig<D extends StorageDriver = "local"> = VolumeConfig & DriverVolumeOptions[D];
+export interface SwarmServiceConfig extends ServiceConfig {
+    replicas?: number;
+    healthCheck?: HealthCheckConfig;
+    resources?: ResourceLimits;
+    restartPolicy?: "none" | "on-failure" | "any";
+}

package/dist/symbols.d.ts

@@ -0,0 +1,8 @@
+export declare const VYFT_RUNTIME: unique symbol;
+export interface RuntimeMeta {
+    name: string;
+    config: Record<string, unknown>;
+}
+export interface RuntimeRef {
+    readonly [VYFT_RUNTIME]: RuntimeMeta;
+}

package/dist/symbols.js

@@ -0,0 +1 @@
+export const VYFT_RUNTIME = Symbol.for("vyft.runtime");

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "vyft",
+  "version": "0.1.0-alpha",
+  "description": "Deploy apps to Docker Swarm with TypeScript",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "vyft": "./dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./swarm": {
+      "types": "./dist/swarm/index.d.ts",
+      "import": "./dist/swarm/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "templates"
+  ],
+  "keywords": [
+    "docker",
+    "swarm",
+    "deploy",
+    "infrastructure",
+    "devops",
+    "typescript"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vyftlabs/vyft.git"
+  },
+  "bugs": {
+    "url": "https://github.com/vyftlabs/vyft/issues"
+  },
+  "homepage": "https://github.com/vyftlabs/vyft#readme",
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.4",
+    "@types/dockerode": "^4.0.1",
+    "@types/node": "^25.3.1",
+    "@types/tar-fs": "^2.0.4",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.0.1",
+    "commander": "^14.0.3",
+    "dockerode": "^4.0.9",
+    "pino": "^10.3.1",
+    "tar-fs": "^3.1.1"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsc",
+    "lint": "biome check src/",
+    "format:check": "biome format src/",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}

package/templates/fullstack/apps/api/Dockerfile

@@ -0,0 +1,21 @@
+FROM node:22-slim AS base
+RUN corepack enable
+
+FROM base AS deps
+WORKDIR /app
+COPY pnpm-lock.yaml pnpm-workspace.yaml package.json ./
+COPY apps/api/package.json ./apps/api/
+RUN pnpm install --frozen-lockfile
+
+FROM deps AS build
+COPY apps/api/ ./apps/api/
+RUN pnpm --filter {{name}}-api build
+
+FROM build AS deploy
+RUN pnpm --filter {{name}}-api --prod deploy --legacy /prod/api
+
+FROM base
+WORKDIR /app
+COPY --from=deploy /prod/api .
+EXPOSE 3000
+CMD ["node", "dist/index.js"]

package/templates/fullstack/apps/api/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "{{name}}-api",
+  "private": true,
+  "type": "module",
+  "files": ["dist"],
+  "scripts": {
+    "dev": "tsx watch --env-file=../../.env src/index.ts",
+    "build": "tsc"
+  },
+  "dependencies": {
+    "@hono/node-server": "^1.14.1",
+    "@hono/trpc-server": "^0.3.4",
+    "@trpc/server": "^11.1.2",
+    "better-auth": "^1.2.8",
+    "drizzle-orm": "^0.44.2",
+    "hono": "^4.7.10",
+    "postgres": "^3.4.7",
+    "zod": "^3.25.17"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.0",
+    "drizzle-kit": "^0.31.1",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3"
+  }
+}

package/templates/fullstack/apps/api/src/auth.ts

@@ -0,0 +1,21 @@
+import { readFileSync } from 'node:fs';
+import { betterAuth } from 'better-auth';
+import { drizzleAdapter } from 'better-auth/adapters/drizzle';
+import { db } from './db.js';
+
+function env(key: string): string {
+  const fileKey = `${key}_FILE`;
+  const filePath = process.env[fileKey];
+  if (filePath) return readFileSync(filePath, 'utf-8').trim();
+  const value = process.env[key];
+  if (value) return value;
+  throw new Error(`Missing env var: ${key} or ${fileKey}`);
+}
+
+export const auth = betterAuth({
+  database: drizzleAdapter(db, { provider: 'pg' }),
+  secret: env('AUTH_SECRET'),
+  basePath: '/api/auth',
+  baseURL: process.env.BETTER_AUTH_URL || 'http://localhost:3000',
+  emailAndPassword: { enabled: true },
+});

package/templates/fullstack/apps/api/src/db.ts

@@ -0,0 +1,16 @@
+import { readFileSync } from 'node:fs';
+import { drizzle } from 'drizzle-orm/postgres-js';
+import postgres from 'postgres';
+import * as schema from './schema.js';
+
+function env(key: string): string {
+  const fileKey = `${key}_FILE`;
+  const filePath = process.env[fileKey];
+  if (filePath) return readFileSync(filePath, 'utf-8').trim();
+  const value = process.env[key];
+  if (value) return value;
+  throw new Error(`Missing env var: ${key} or ${fileKey}`);
+}
+
+const client = postgres(env('DATABASE_URL'));
+export const db = drizzle(client, { schema });

package/templates/fullstack/apps/api/src/index.ts

@@ -0,0 +1,17 @@
+import { serve } from '@hono/node-server';
+import { trpcServer } from '@hono/trpc-server';
+import { Hono } from 'hono';
+import { auth } from './auth.js';
+import { appRouter } from './router.js';
+
+const app = new Hono().basePath('/api');
+
+app.on(['GET', 'POST'], '/auth/**', (c) => auth.handler(c.req.raw));
+
+app.use('/trpc/*', trpcServer({ router: appRouter }));
+
+app.get('/health', (c) => c.json({ ok: true }));
+
+serve({ fetch: app.fetch, port: 3000 }, (info) => {
+  console.log(`Server running on http://localhost:${info.port}`);
+});

package/templates/fullstack/apps/api/src/router.ts

@@ -0,0 +1,11 @@
+import { initTRPC } from '@trpc/server';
+
+const t = initTRPC.create();
+
+export const appRouter = t.router({
+  hello: t.procedure.query(() => {
+    return { message: 'Hello from tRPC!' };
+  }),
+});
+
+export type AppRouter = typeof appRouter;

package/templates/fullstack/apps/api/src/schema.ts

@@ -0,0 +1,11 @@
+import { pgTable, text, timestamp } from 'drizzle-orm/pg-core';
+
+export const users = pgTable('users', {
+  id: text('id').primaryKey(),
+  name: text('name').notNull(),
+  email: text('email').notNull().unique(),
+  emailVerified: timestamp('email_verified'),
+  image: text('image'),
+  createdAt: timestamp('created_at').defaultNow().notNull(),
+  updatedAt: timestamp('updated_at').defaultNow().notNull(),
+});

package/templates/fullstack/apps/api/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}

package/templates/fullstack/apps/web/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>{{name}}</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>