@lishugupta652/dokploy 0.1.3

package/dist/config.js

@@ -0,0 +1,288 @@
+import { access, readFile } from "node:fs/promises";
+import path from "node:path";
+import { parse } from "yaml";
+import { z, ZodError } from "zod";
+const nonEmptyString = z.string().trim().min(1);
+const maybeString = z.string().trim().min(1).nullable().optional();
+const envValueSchema = z
+    .union([z.string(), z.number(), z.boolean()])
+    .transform((value) => String(value));
+const envRecordSchema = z.record(envValueSchema);
+const keyValueSchema = z.union([envRecordSchema, z.string()]);
+const domainSchema = z.object({
+    host: nonEmptyString,
+    path: z.string().min(1).nullable().optional().default("/"),
+    port: z.number().int().min(1).max(65535).nullable().optional(),
+    https: z.boolean().optional().default(true),
+    certificate: z
+        .enum(["letsencrypt", "none", "custom"])
+        .optional()
+        .default("letsencrypt"),
+    customCertResolver: maybeString,
+    serviceName: maybeString,
+    internalPath: maybeString,
+    stripPath: z.boolean().optional().default(false),
+});
+const githubSourceSchema = z.object({
+    id: nonEmptyString,
+    owner: nonEmptyString,
+    repository: nonEmptyString,
+    branch: nonEmptyString.optional().default("main"),
+    buildPath: nonEmptyString.optional().default("/"),
+    triggerType: z.enum(["push", "tag"]).optional().default("push"),
+    enableSubmodules: z.boolean().optional().default(false),
+    watchPaths: z.array(nonEmptyString).nullable().optional(),
+});
+const gitSourceSchema = z.object({
+    url: nonEmptyString,
+    branch: nonEmptyString.optional().default("main"),
+    buildPath: nonEmptyString.optional().default("/"),
+    sshKeyId: maybeString,
+    enableSubmodules: z.boolean().optional().default(false),
+    watchPaths: z.array(nonEmptyString).nullable().optional(),
+});
+const dockerSourceSchema = z.object({
+    image: nonEmptyString,
+    username: maybeString,
+    password: maybeString,
+    registryUrl: maybeString,
+});
+const buildSchema = z
+    .object({
+    type: z
+        .enum([
+        "dockerfile",
+        "heroku_buildpacks",
+        "paketo_buildpacks",
+        "nixpacks",
+        "static",
+        "railpack",
+    ])
+        .optional()
+        .default("dockerfile"),
+    dockerfile: z.string().nullable().optional(),
+    contextPath: z.string().nullable().optional().default("."),
+    buildStage: z.string().nullable().optional(),
+    herokuVersion: z.string().nullable().optional(),
+    railpackVersion: z.string().nullable().optional(),
+    publishDirectory: z.string().nullable().optional(),
+    isStaticSpa: z.boolean().nullable().optional(),
+})
+    .optional()
+    .default({});
+const applicationSchema = z
+    .object({
+    name: nonEmptyString,
+    appName: nonEmptyString.optional(),
+    description: z.string().nullable().optional(),
+    source: z.enum(["github", "git", "docker"]).optional().default("github"),
+    github: githubSourceSchema.optional(),
+    git: gitSourceSchema.optional(),
+    docker: dockerSourceSchema.optional(),
+    build: buildSchema,
+    env: envRecordSchema.optional().default({}),
+    buildArgs: keyValueSchema.nullable().optional(),
+    buildSecrets: keyValueSchema.nullable().optional(),
+    createEnvFile: z.boolean().optional().default(false),
+    domains: z.array(domainSchema).optional().default([]),
+    deploy: z.boolean().optional().default(true),
+    serverId: maybeString,
+})
+    .superRefine((app, ctx) => {
+    if (app.source === "github" && !app.github) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["github"],
+            message: "github config is required when source is github",
+        });
+    }
+    if (app.source === "git" && !app.git) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["git"],
+            message: "git config is required when source is git",
+        });
+    }
+    if (app.source === "docker" && !app.docker) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["docker"],
+            message: "docker config is required when source is docker",
+        });
+    }
+});
+const composeGitSchema = z.object({
+    url: nonEmptyString.optional(),
+    id: nonEmptyString.optional(),
+    owner: nonEmptyString.optional(),
+    repository: nonEmptyString.optional(),
+    branch: nonEmptyString.optional().default("main"),
+    composePath: nonEmptyString.optional().default("./docker-compose.yml"),
+    sshKeyId: maybeString,
+    triggerType: z.enum(["push", "tag"]).nullable().optional(),
+    enableSubmodules: z.boolean().optional().default(false),
+    watchPaths: z.array(nonEmptyString).nullable().optional(),
+});
+const composeSchema = z
+    .object({
+    name: nonEmptyString,
+    appName: nonEmptyString.optional(),
+    description: z.string().nullable().optional(),
+    source: z
+        .enum(["raw", "git", "github", "gitlab", "bitbucket", "gitea"])
+        .optional()
+        .default("raw"),
+    content: z.string().optional(),
+    composeFile: z.string().optional(),
+    composeType: z.enum(["docker-compose", "stack"]).optional().default("docker-compose"),
+    git: composeGitSchema.optional(),
+    env: envRecordSchema.optional().default({}),
+    domains: z.array(domainSchema).optional().default([]),
+    deploy: z.boolean().optional().default(true),
+    serverId: maybeString,
+})
+    .superRefine((compose, ctx) => {
+    if (compose.source === "raw" && !compose.content && !compose.composeFile) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["content"],
+            message: "content or composeFile is required when compose source is raw",
+        });
+    }
+    if (compose.source !== "raw" && !compose.git) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["git"],
+            message: "git config is required for git-backed compose sources",
+        });
+    }
+});
+const databaseSchema = z.object({
+    name: nonEmptyString,
+    appName: nonEmptyString.optional(),
+    type: z.enum(["postgres", "mysql", "mariadb", "mongo", "redis"]),
+    version: nonEmptyString.optional(),
+    image: nonEmptyString.optional(),
+    description: z.string().nullable().optional(),
+    databaseName: nonEmptyString.optional(),
+    databaseUser: nonEmptyString.optional(),
+    user: nonEmptyString.optional(),
+    databasePassword: nonEmptyString.optional(),
+    password: nonEmptyString.optional(),
+    databaseRootPassword: nonEmptyString.optional(),
+    rootPassword: nonEmptyString.optional(),
+    replicaSets: z.boolean().nullable().optional(),
+    env: envRecordSchema.optional().default({}),
+    deploy: z.boolean().optional().default(true),
+    serverId: maybeString,
+});
+const backupDestinationSchema = z.object({
+    name: nonEmptyString,
+    provider: z.string().nullable().optional().default("s3"),
+    accessKey: nonEmptyString,
+    bucket: nonEmptyString,
+    region: nonEmptyString,
+    endpoint: nonEmptyString,
+    secretAccessKey: nonEmptyString,
+    serverId: maybeString,
+});
+const scheduledBackupSchema = z.object({
+    name: nonEmptyString,
+    destination: nonEmptyString,
+    schedule: nonEmptyString,
+    enabled: z.boolean().nullable().optional().default(true),
+    prefix: nonEmptyString,
+    keepLatestCount: z.number().int().positive().nullable().optional(),
+    target: nonEmptyString,
+    database: nonEmptyString.optional(),
+    databaseType: z.enum(["postgres", "mariadb", "mysql", "mongo", "web-server"]),
+    backupType: z.enum(["database", "compose"]).optional().default("database"),
+    serviceName: z.string().nullable().optional(),
+    metadata: z.unknown().nullable().optional(),
+});
+const volumeBackupSchema = z.object({
+    name: nonEmptyString,
+    destination: nonEmptyString,
+    volumeName: nonEmptyString,
+    prefix: nonEmptyString,
+    cronExpression: nonEmptyString,
+    target: nonEmptyString,
+    serviceType: z.enum([
+        "application",
+        "postgres",
+        "mysql",
+        "mariadb",
+        "mongo",
+        "redis",
+        "compose",
+    ]),
+    appName: nonEmptyString.optional(),
+    serviceName: z.string().nullable().optional(),
+    turnOff: z.boolean().optional().default(false),
+    keepLatestCount: z.number().int().positive().nullable().optional(),
+    enabled: z.boolean().nullable().optional().default(true),
+});
+const configSchema = z.object({
+    host: z.string().url().optional(),
+    stateFile: z.string().optional(),
+    project: z.object({
+        name: nonEmptyString,
+        description: z.string().nullable().optional(),
+        env: envRecordSchema.optional().default({}),
+    }),
+    environment: z
+        .object({
+        name: nonEmptyString,
+        description: z.string().optional().default(""),
+        env: envRecordSchema.optional().default({}),
+    })
+        .optional(),
+    applications: z.array(applicationSchema).optional().default([]),
+    compose: z.array(composeSchema).optional().default([]),
+    databases: z.array(databaseSchema).optional().default([]),
+    backupDestinations: z.array(backupDestinationSchema).optional().default([]),
+    backups: z.array(scheduledBackupSchema).optional().default([]),
+    volumeBackups: z.array(volumeBackupSchema).optional().default([]),
+});
+export async function loadConfig(configPath) {
+    const resolvedPath = await resolveConfigPath(configPath);
+    const raw = await readFile(resolvedPath, "utf8");
+    const parsed = parse(raw);
+    try {
+        return {
+            config: configSchema.parse(parsed),
+            configPath: resolvedPath,
+        };
+    }
+    catch (error) {
+        if (error instanceof ZodError) {
+            throw new Error(formatZodError(error));
+        }
+        throw error;
+    }
+}
+async function resolveConfigPath(configPath) {
+    const candidates = configPath ? [configPath] : ["dokploy.yaml", "dokploy.yml"];
+    for (const candidate of candidates) {
+        const resolved = path.resolve(candidate);
+        try {
+            await access(resolved);
+            return resolved;
+        }
+        catch {
+            continue;
+        }
+    }
+    throw new Error(configPath
+        ? `Config file not found: ${configPath}`
+        : "Config file not found. Expected dokploy.yaml or dokploy.yml, or pass -f <path>.");
+}
+function formatZodError(error) {
+    const details = error.issues
+        .map((issue) => {
+        const location = issue.path.length ? issue.path.join(".") : "config";
+        return `- ${location}: ${issue.message}`;
+    })
+        .join("\n");
+    return `Invalid Dokploy config:\n${details}`;
+}

package/dist/index.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { DokployApiError } from "./client.js";
+import { applyCommand } from "./commands/apply.js";
+import { deployCommand } from "./commands/deploy.js";
+import { destroyCommand } from "./commands/destroy.js";
+import { initCommand } from "./commands/init.js";
+import { projectsCommand } from "./commands/projects.js";
+import { statusCommand } from "./commands/status.js";
+import { readPackageVersion } from "./version.js";
+const program = new Command();
+program
+    .name("dokploy")
+    .description("Apply a YAML Dokploy deployment config through the Dokploy API.")
+    .version(readPackageVersion());
+program
+    .command("projects")
+    .description("Show all Dokploy projects from project.all.")
+    .option("--host <url>", "Dokploy API host, for example https://dokploy.example.com/api")
+    .option("-f, --config <path>", "optional config file path to read host from")
+    .option("--summary", "print a concise project list instead of full JSON")
+    .option("--json", "print raw JSON without UI formatting")
+    .action((options) => run(() => projectsCommand(options)));
+program
+    .command("apply")
+    .description("Create or update resources from the config.")
+    .option("-f, --config <path>", "config file path")
+    .option("--state <path>", "state file path")
+    .option("--dry-run", "show intended changes without writing resources")
+    .action((options) => run(() => applyCommand(options)));
+program
+    .command("deploy")
+    .description("Redeploy an application or compose stack from state.")
+    .argument("<name>", "application or compose name")
+    .option("-f, --config <path>", "config file path")
+    .option("--state <path>", "state file path")
+    .option("--dry-run", "show intended changes without writing resources")
+    .action((name, options) => run(() => deployCommand(name, options)));
+program
+    .command("status")
+    .description("Show remote status for resources tracked in state.")
+    .option("-f, --config <path>", "config file path")
+    .option("--state <path>", "state file path")
+    .action((options) => run(() => statusCommand(options)));
+program
+    .command("destroy")
+    .description("Delete resources tracked in state. Pass a name to delete one resource.")
+    .argument("[name]", "resource name")
+    .option("-f, --config <path>", "config file path")
+    .option("--state <path>", "state file path")
+    .option("--dry-run", "show intended deletes without deleting resources")
+    .option("--delete-volumes", "delete compose volumes when deleting compose stacks")
+    .action((name, options) => run(() => destroyCommand(name, options)));
+program
+    .command("init")
+    .description("Generate a starter dokploy.yaml config.")
+    .option("-o, --output <path>", "output config path")
+    .option("--force", "overwrite an existing file")
+    .action((options) => run(() => initCommand(options)));
+await program.parseAsync();
+async function run(action) {
+    try {
+        await action();
+    }
+    catch (error) {
+        if (error instanceof DokployApiError) {
+            console.error(error.message);
+            if (process.env.DEBUG) {
+                console.error(error.responseBody);
+            }
+            process.exitCode = 1;
+            return;
+        }
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    }
+}

package/dist/output.js

@@ -0,0 +1,113 @@
+import chalk from "chalk";
+export class Logger {
+    dryRun;
+    constructor(dryRun = false) {
+        this.dryRun = dryRun;
+    }
+    info(message) {
+        console.log(message);
+    }
+    muted(message) {
+        console.log(chalk.gray(message));
+    }
+    header(title, subtitle) {
+        console.log("");
+        console.log(chalk.bold.cyan(title));
+        console.log(chalk.gray("=".repeat(Math.max(title.length, 8))));
+        if (subtitle) {
+            console.log(chalk.gray(subtitle));
+        }
+    }
+    section(title) {
+        console.log("");
+        console.log(chalk.bold(title));
+        console.log(chalk.gray("-".repeat(Math.max(title.length, 8))));
+    }
+    step(message) {
+        console.log(`${chalk.cyan(">")} ${chalk.bold(message)}`);
+    }
+    success(message) {
+        console.log(`${chalk.green("OK")} ${message}`);
+    }
+    warn(message) {
+        console.warn(`${chalk.yellow("WARN")} ${message}`);
+    }
+    error(message) {
+        console.error(`${chalk.red("ERR")} ${message}`);
+    }
+    action(action, message) {
+        const prefix = this.dryRun ? `${chalk.yellow("DRY")} ` : "";
+        const color = colorForAction(action);
+        console.log(`${prefix}${color(padAction(action))} ${message}`);
+    }
+    keyValue(label, value) {
+        console.log(`${chalk.gray(`${label}:`)} ${formatValue(value)}`);
+    }
+    json(value) {
+        console.log(colorJson(value));
+    }
+    table(rows, columns) {
+        if (rows.length === 0) {
+            this.muted("No rows.");
+            return;
+        }
+        const widths = columns.map((column) => {
+            const cells = rows.map((row) => String(row[column.key] ?? ""));
+            return Math.max(column.label.length, ...cells.map((cell) => stripAnsi(cell).length));
+        });
+        const header = columns
+            .map((column, index) => chalk.bold.cyan(column.label.padEnd(widths[index] ?? 0)))
+            .join(chalk.gray("  "));
+        console.log(header);
+        console.log(chalk.gray(widths.map((width) => "-".repeat(width)).join("  ")));
+        for (const row of rows) {
+            const line = columns
+                .map((column, index) => String(row[column.key] ?? "").padEnd(widths[index] ?? 0))
+                .join("  ");
+            console.log(line);
+        }
+    }
+    blank() {
+        console.log("");
+    }
+}
+function colorForAction(action) {
+    if (action.includes("create"))
+        return chalk.green;
+    if (action.includes("update") || action === "configured")
+        return chalk.blue;
+    if (action.includes("delete"))
+        return chalk.red;
+    if (action.includes("deploy"))
+        return chalk.magenta;
+    if (action.includes("use") || action === "using")
+        return chalk.cyan;
+    return chalk.bold;
+}
+function padAction(action) {
+    return action.toUpperCase().padEnd(12);
+}
+function formatValue(value) {
+    if (value === undefined || value === null || value === "")
+        return chalk.gray("-");
+    if (typeof value === "number")
+        return chalk.yellow(String(value));
+    if (typeof value === "boolean")
+        return value ? chalk.green("true") : chalk.red("false");
+    return String(value);
+}
+function colorJson(value) {
+    return JSON.stringify(value, null, 2).replace(/("(?:\\u[\da-fA-F]{4}|\\[^u]|[^\\"])*"(\s*:)?|\btrue\b|\bfalse\b|\bnull\b|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)/g, (token) => {
+        if (token.startsWith("\"")) {
+            return token.endsWith(":") ? chalk.cyan(token) : chalk.green(token);
+        }
+        if (token === "true" || token === "false")
+            return chalk.magenta(token);
+        if (token === "null")
+            return chalk.gray(token);
+        return chalk.yellow(token);
+    });
+}
+function stripAnsi(value) {
+    return value.replace(/\u001b\[[0-9;]*m/g, "");
+}

package/dist/resources/application.js

@@ -0,0 +1,173 @@
+import { cleanPayload, findByName, formatEnv, getEntityId, getOneById, isDryRunId, slugifyAppName, } from "./common.js";
+import { destroyDomainIds, ensureDomains } from "./domain.js";
+export async function ensureApplication(app, environment, context) {
+    const existing = await findApplication(app.name, environment.id, context);
+    const ref = existing
+        ? await updateApplication(app, existing, context)
+        : await createApplication(app, environment, context);
+    await configureApplication(app, ref, context);
+    const domainIds = await ensureDomains(app.domains, { type: "application", id: ref.id }, context);
+    if (app.deploy) {
+        if (context.dryRun || isDryRunId(ref.id)) {
+            context.log.action("would deploy", `application ${app.name}`);
+        }
+        else {
+            await context.client.post("application.deploy", {
+                applicationId: ref.id,
+                title: `Deploy ${app.name}`,
+                description: "Triggered by dokploy",
+            });
+            context.log.action("deployed", `application ${app.name}`);
+        }
+    }
+    const stateRef = {
+        ...ref,
+        domains: domainIds,
+        deployed: app.deploy,
+    };
+    context.state.applications[app.name] = stateRef;
+    return stateRef;
+}
+export async function findApplication(name, environmentId, context) {
+    const stateRef = context.state.applications[name];
+    const fromState = await getOneById(context.client, "application.one", "applicationId", stateRef?.id);
+    if (fromState)
+        return fromState;
+    if (!environmentId || isDryRunId(environmentId))
+        return undefined;
+    return findByName(context.client, "application.search", name, {
+        environmentId,
+    });
+}
+async function createApplication(app, environment, context) {
+    if (context.dryRun || isDryRunId(environment.id)) {
+        context.log.action("would create", `application ${app.name}`);
+        return { id: `dry-run:application:${app.name}`, name: app.name };
+    }
+    const created = await context.client.post("application.create", cleanPayload({
+        name: app.name,
+        appName: app.appName ?? slugifyAppName(app.name),
+        description: app.description ?? null,
+        environmentId: environment.id,
+        serverId: app.serverId ?? null,
+    }));
+    const id = getEntityId(created && typeof created === "object" ? created : undefined, "applicationId") ??
+        getEntityId(await findApplication(app.name, environment.id, context), "applicationId");
+    if (!id)
+        throw new Error(`Created application ${app.name}, but could not resolve its id.`);
+    context.log.action("created", `application ${app.name}`);
+    return { id, name: app.name };
+}
+async function updateApplication(app, existing, context) {
+    const id = getEntityId(existing, "applicationId");
+    if (!id)
+        throw new Error(`Application ${app.name} exists but no id was returned.`);
+    if (context.dryRun) {
+        context.log.action("would update", `application ${app.name}`);
+    }
+    else {
+        await context.client.post("application.update", cleanPayload({
+            applicationId: id,
+            name: app.name,
+            appName: app.appName ?? slugifyAppName(app.name),
+            description: app.description ?? null,
+        }));
+        context.log.action("updated", `application ${app.name}`);
+    }
+    return { id, name: app.name };
+}
+async function configureApplication(app, ref, context) {
+    if (context.dryRun || isDryRunId(ref.id)) {
+        context.log.action("would configure", `application ${app.name}`);
+        return;
+    }
+    if (app.source === "github") {
+        const github = app.github;
+        if (!github)
+            throw new Error(`Application ${app.name} is missing github config.`);
+        await context.client.post("application.saveGithubProvider", {
+            applicationId: ref.id,
+            repository: github.repository,
+            branch: github.branch,
+            owner: github.owner,
+            buildPath: github.buildPath,
+            githubId: github.id,
+            triggerType: github.triggerType,
+            enableSubmodules: github.enableSubmodules,
+            watchPaths: github.watchPaths ?? null,
+        });
+    }
+    if (app.source === "git") {
+        const git = app.git;
+        if (!git)
+            throw new Error(`Application ${app.name} is missing git config.`);
+        await context.client.post("application.saveGitProvider", {
+            applicationId: ref.id,
+            customGitUrl: git.url,
+            customGitBranch: git.branch,
+            customGitBuildPath: git.buildPath,
+            customGitSSHKeyId: git.sshKeyId ?? null,
+            enableSubmodules: git.enableSubmodules,
+            watchPaths: git.watchPaths ?? null,
+        });
+    }
+    if (app.source === "docker") {
+        const docker = app.docker;
+        if (!docker)
+            throw new Error(`Application ${app.name} is missing docker config.`);
+        await context.client.post("application.saveDockerProvider", {
+            applicationId: ref.id,
+            dockerImage: docker.image,
+            username: docker.username ?? null,
+            password: docker.password ?? null,
+            registryUrl: docker.registryUrl ?? null,
+        });
+    }
+    else {
+        await context.client.post("application.saveBuildType", {
+            applicationId: ref.id,
+            buildType: app.build.type,
+            dockerfile: app.build.dockerfile ?? null,
+            dockerContextPath: app.build.contextPath ?? null,
+            dockerBuildStage: app.build.buildStage ?? null,
+            herokuVersion: app.build.herokuVersion ?? null,
+            railpackVersion: app.build.railpackVersion ?? null,
+            publishDirectory: app.build.publishDirectory ?? null,
+            isStaticSpa: app.build.isStaticSpa ?? null,
+        });
+    }
+    await context.client.post("application.saveEnvironment", {
+        applicationId: ref.id,
+        env: formatEnv(app.env) ?? "",
+        buildArgs: formatEnv(app.buildArgs) ?? "",
+        buildSecrets: formatEnv(app.buildSecrets) ?? "",
+        createEnvFile: app.createEnvFile,
+    });
+    context.log.action("configured", `application ${app.name}`);
+}
+export async function redeployApplication(ref, context) {
+    if (context.dryRun) {
+        context.log.action("would redeploy", `application ${ref.name}`);
+        return;
+    }
+    await context.client.post("application.redeploy", {
+        applicationId: ref.id,
+        title: `Redeploy ${ref.name}`,
+        description: "Triggered by dokploy",
+    });
+    context.log.action("redeployed", `application ${ref.name}`);
+}
+export async function destroyApplication(name, context) {
+    const ref = context.state.applications[name];
+    if (!ref)
+        return;
+    await destroyDomainIds(ref.domains, context);
+    if (context.dryRun) {
+        context.log.action("would delete", `application ${name}`);
+    }
+    else {
+        await context.client.post("application.delete", { applicationId: ref.id });
+        context.log.action("deleted", `application ${name}`);
+    }
+    delete context.state.applications[name];
+}