@lishugupta652/dokploy 0.1.3

package/.githooks/pre-commit

@@ -0,0 +1,10 @@
+#!/bin/sh
+set -e
+
+PACKAGE_DIR="dokploy-deploy-automation"
+if [ ! -f "$PACKAGE_DIR/scripts/bump-version-on-commit.mjs" ]; then
+  PACKAGE_DIR="."
+fi
+
+node "$PACKAGE_DIR/scripts/bump-version-on-commit.mjs"
+git add "$PACKAGE_DIR/package.json" "$PACKAGE_DIR/package-lock.json"

package/README.md

@@ -0,0 +1,77 @@
+# Dokploy
+
+YAML-driven CLI for applying Dokploy projects through the Dokploy API.
+
+## Install
+
+```bash
+npm install
+npm run build
+```
+
+Run locally during development:
+
+```bash
+npm run dev -- apply -f examples/simple-app.yaml --dry-run
+```
+
+After build, the CLI binary is `dokploy`.
+
+For global install after publishing:
+
+```bash
+npm install -g @lishugupta652/dokploy
+dokploy --help
+```
+
+## Environment
+
+```bash
+export DOKPLOY_API_KEY=your-api-key
+export DOKPLOY_HOST=https://your-dokploy.example.com/api
+```
+
+`DOKPLOY_HOST` is optional when `host` is set in the YAML file. API keys are never read from config.
+
+## Commands
+
+```bash
+dokploy projects --host https://your-dokploy.example.com/api
+dokploy projects --summary --host https://your-dokploy.example.com/api
+dokploy projects --json --host https://your-dokploy.example.com/api
+dokploy apply -f dokploy.yaml
+dokploy apply -f dokploy.yaml --dry-run
+dokploy deploy frontend -f dokploy.yaml
+dokploy status -f dokploy.yaml
+dokploy destroy frontend -f dokploy.yaml
+dokploy destroy -f dokploy.yaml
+dokploy init
+```
+
+State is written next to the config as `dokploy-state.json` unless `stateFile` or `--state` is provided.
+
+## Publishing
+
+The npm package name is `@lishugupta652/dokploy`; the command is `dokploy`.
+
+```bash
+npm publish --access public
+```
+
+`prepublishOnly` runs the TypeScript check and build before publishing.
+
+## Commit Version Hook
+
+Install the repo hook once:
+
+```bash
+npm run hooks:install
+```
+
+The pre-commit hook bumps the package patch version and stages `package.json` plus `package-lock.json`. Set `SKIP_DOKPLOY_VERSION_BUMP=1` to skip it for a commit.
+
+## Notes
+
+- `apply` is idempotent by name within the selected environment where Dokploy exposes search endpoints.
+- Applications are configured in Dokploy's required order: create, source provider, build type, environment, domains, deploy.
+- Database creation requires a password because the Dokploy API requires one on create.

package/dist/client.js

@@ -0,0 +1,106 @@
+export class DokployApiError extends Error {
+    status;
+    endpoint;
+    responseBody;
+    constructor(message, status, endpoint, responseBody) {
+        super(message);
+        this.status = status;
+        this.endpoint = endpoint;
+        this.responseBody = responseBody;
+        this.name = "DokployApiError";
+    }
+}
+export class DokployClient {
+    baseUrl;
+    apiKey;
+    constructor(options) {
+        this.baseUrl = options.host.replace(/\/+$/, "");
+        this.apiKey = options.apiKey;
+    }
+    async get(endpoint, query) {
+        return this.request("GET", endpoint, undefined, query);
+    }
+    async post(endpoint, body) {
+        return this.request("POST", endpoint, body);
+    }
+    async request(method, endpoint, body, query) {
+        const normalizedEndpoint = endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+        const url = new URL(`${this.baseUrl}${normalizedEndpoint}`);
+        if (query) {
+            for (const [key, value] of Object.entries(query)) {
+                if (value !== undefined && value !== null) {
+                    url.searchParams.set(key, String(value));
+                }
+            }
+        }
+        const headers = {
+            "x-api-key": this.apiKey,
+            accept: "application/json",
+        };
+        const init = {
+            method,
+            headers,
+        };
+        if (method === "POST") {
+            headers["content-type"] = "application/json";
+            init.body = JSON.stringify(body ?? {});
+        }
+        const response = await fetch(url, init);
+        const text = await response.text();
+        if (!response.ok) {
+            throw new DokployApiError(this.formatErrorMessage(response.status, normalizedEndpoint, text), response.status, normalizedEndpoint, text);
+        }
+        if (!text.trim()) {
+            return undefined;
+        }
+        const parsed = JSON.parse(text);
+        return this.unwrapResponse(parsed);
+    }
+    unwrapResponse(value) {
+        if (!isRecord(value))
+            return value;
+        const result = value.result;
+        if (isRecord(result)) {
+            const data = result.data;
+            if (isRecord(data) && "json" in data)
+                return data.json;
+            if (data !== undefined)
+                return data;
+        }
+        const data = value.data;
+        if (isRecord(data) && "json" in data)
+            return data.json;
+        if ("json" in value)
+            return value.json;
+        return value;
+    }
+    formatErrorMessage(status, endpoint, body) {
+        const detail = extractErrorDetail(body);
+        const hint = status === 401 || status === 403
+            ? " Check DOKPLOY_API_KEY and the API key permissions."
+            : "";
+        return `Dokploy API ${endpoint} failed with HTTP ${status}${detail ? `: ${detail}` : ""}.${hint}`;
+    }
+}
+function extractErrorDetail(body) {
+    if (!body.trim())
+        return undefined;
+    try {
+        const parsed = JSON.parse(body);
+        if (isRecord(parsed)) {
+            const message = parsed.message;
+            if (typeof message === "string")
+                return message;
+            const error = parsed.error;
+            if (isRecord(error) && typeof error.message === "string")
+                return error.message;
+        }
+    }
+    catch {
+        return body.slice(0, 400);
+    }
+    return body.slice(0, 400);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/commands/apply.js

@@ -0,0 +1,38 @@
+import { createRuntime } from "../runtime.js";
+import { writeState } from "../state.js";
+import { ensureBackupDestination, ensureScheduledBackup, ensureVolumeBackup } from "../resources/backup.js";
+import { ensureApplication } from "../resources/application.js";
+import { ensureCompose } from "../resources/compose.js";
+import { ensureDatabase } from "../resources/database.js";
+import { ensureEnvironment } from "../resources/environment.js";
+import { ensureProject } from "../resources/project.js";
+export async function applyCommand(options) {
+    const runtime = await createRuntime(options);
+    runtime.log.step("Applying Dokploy config");
+    const project = await ensureProject(runtime.config.project, runtime);
+    const environment = await ensureEnvironment(runtime.config.environment, project, runtime);
+    for (const database of runtime.config.databases) {
+        await ensureDatabase(database, environment, runtime);
+    }
+    for (const app of runtime.config.applications) {
+        await ensureApplication(app, environment, runtime);
+    }
+    for (const compose of runtime.config.compose) {
+        await ensureCompose(compose, environment, runtime);
+    }
+    for (const destination of runtime.config.backupDestinations) {
+        await ensureBackupDestination(destination, runtime);
+    }
+    for (const backup of runtime.config.backups) {
+        await ensureScheduledBackup(backup, runtime);
+    }
+    for (const backup of runtime.config.volumeBackups) {
+        await ensureVolumeBackup(backup, runtime);
+    }
+    if (runtime.dryRun) {
+        runtime.log.warn(`Dry run only. State was not written to ${runtime.statePath}.`);
+        return;
+    }
+    await writeState(runtime.statePath, runtime.state);
+    runtime.log.success(`State written to ${runtime.statePath}`);
+}

package/dist/commands/deploy.js

@@ -0,0 +1,17 @@
+import { createRuntime } from "../runtime.js";
+import { redeployApplication } from "../resources/application.js";
+import { redeployCompose } from "../resources/compose.js";
+export async function deployCommand(name, options) {
+    const runtime = await createRuntime(options);
+    const app = runtime.state.applications[name];
+    if (app) {
+        await redeployApplication(app, runtime);
+        return;
+    }
+    const compose = runtime.state.compose[name];
+    if (compose) {
+        await redeployCompose(compose, runtime);
+        return;
+    }
+    throw new Error(`No application or compose named ${name} found in ${runtime.statePath}. Run apply first.`);
+}

package/dist/commands/destroy.js

@@ -0,0 +1,73 @@
+import { destroyApplication } from "../resources/application.js";
+import { destroyBackupDestination, destroyScheduledBackup, destroyVolumeBackup, } from "../resources/backup.js";
+import { destroyCompose } from "../resources/compose.js";
+import { destroyDatabase } from "../resources/database.js";
+import { destroyEnvironment } from "../resources/environment.js";
+import { destroyProject } from "../resources/project.js";
+import { createRuntime } from "../runtime.js";
+import { writeState } from "../state.js";
+export async function destroyCommand(target, options) {
+    const runtime = await createRuntime(options);
+    const deleteVolumes = Boolean(options.deleteVolumes);
+    if (target) {
+        await destroyOne(target, runtime, deleteVolumes);
+    }
+    else {
+        await destroyAll(runtime, deleteVolumes);
+    }
+    if (runtime.dryRun) {
+        runtime.log.warn(`Dry run only. State was not written to ${runtime.statePath}.`);
+        return;
+    }
+    await writeState(runtime.statePath, runtime.state);
+    runtime.log.success(`State written to ${runtime.statePath}`);
+}
+async function destroyOne(target, runtime, deleteVolumes) {
+    if (runtime.state.volumeBackups[target]) {
+        await destroyVolumeBackup(target, runtime);
+        return;
+    }
+    if (runtime.state.backups[target]) {
+        await destroyScheduledBackup(target, runtime);
+        return;
+    }
+    if (runtime.state.applications[target]) {
+        await destroyApplication(target, runtime);
+        return;
+    }
+    if (runtime.state.compose[target]) {
+        await destroyCompose(target, runtime, deleteVolumes);
+        return;
+    }
+    if (runtime.state.databases[target]) {
+        await destroyDatabase(target, runtime);
+        return;
+    }
+    if (runtime.state.backupDestinations[target]) {
+        await destroyBackupDestination(target, runtime);
+        return;
+    }
+    throw new Error(`No managed resource named ${target} found in ${runtime.statePath}.`);
+}
+async function destroyAll(runtime, deleteVolumes) {
+    for (const name of Object.keys(runtime.state.volumeBackups).reverse()) {
+        await destroyVolumeBackup(name, runtime);
+    }
+    for (const name of Object.keys(runtime.state.backups).reverse()) {
+        await destroyScheduledBackup(name, runtime);
+    }
+    for (const name of Object.keys(runtime.state.compose).reverse()) {
+        await destroyCompose(name, runtime, deleteVolumes);
+    }
+    for (const name of Object.keys(runtime.state.applications).reverse()) {
+        await destroyApplication(name, runtime);
+    }
+    for (const name of Object.keys(runtime.state.databases).reverse()) {
+        await destroyDatabase(name, runtime);
+    }
+    for (const name of Object.keys(runtime.state.backupDestinations).reverse()) {
+        await destroyBackupDestination(name, runtime);
+    }
+    await destroyEnvironment(runtime);
+    await destroyProject(runtime);
+}

package/dist/commands/init.js

@@ -0,0 +1,51 @@
+import { access, writeFile } from "node:fs/promises";
+import path from "node:path";
+export async function initCommand(options) {
+    const output = path.resolve(options.output ?? "dokploy.yaml");
+    if (!options.force && (await exists(output))) {
+        throw new Error(`${output} already exists. Pass --force to overwrite it.`);
+    }
+    await writeFile(output, starterConfig, "utf8");
+    console.log(`Wrote ${output}`);
+}
+async function exists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const starterConfig = `host: https://your-dokploy.example.com/api
+
+project:
+  name: My App
+  description: Deployed via dokploy
+
+environment:
+  name: production
+
+applications:
+  - name: frontend
+    source: github
+    github:
+      id: your-github-provider-id
+      owner: your-org
+      repository: your-repo
+      branch: main
+      buildPath: /
+    build:
+      type: dockerfile
+      dockerfile: Dockerfile
+      contextPath: .
+    env:
+      NODE_ENV: production
+    domains:
+      - host: app.example.com
+        port: 80
+        path: /
+        https: true
+        certificate: letsencrypt
+    deploy: true
+`;

package/dist/commands/projects.js

@@ -0,0 +1,57 @@
+import chalk from "chalk";
+import { asArray } from "../resources/common.js";
+import { createClientRuntime } from "../runtime.js";
+export async function projectsCommand(options) {
+    const runtime = await createClientRuntime(options);
+    const projects = await runtime.client.get("project.all");
+    if (options.json) {
+        console.log(JSON.stringify(projects, null, 2));
+        return;
+    }
+    runtime.log.header("Dokploy Projects", runtime.host);
+    const projectList = asArray(projects);
+    if (projectList.length === 0) {
+        runtime.log.warn("No projects returned by project.all.");
+        runtime.log.section("Raw Response");
+        runtime.log.json(projects);
+        return;
+    }
+    runtime.log.table(projectList.map((project) => ({
+        name: stringField(project, "name") ?? "unnamed",
+        id: chalk.gray(stringField(project, "projectId") ?? stringField(project, "id") ?? "unknown-id"),
+        environments: countNested(project, ["environments", "environment"]),
+        applications: countNested(project, ["applications", "application"]),
+        compose: countNested(project, ["compose", "composes"]),
+        databases: countNested(project, ["databases", "postgres", "mysql", "mariadb", "mongo", "redis"]),
+        description: stringField(project, "description") ?? "",
+    })), [
+        { key: "name", label: "Project" },
+        { key: "id", label: "ID" },
+        { key: "environments", label: "Env" },
+        { key: "applications", label: "Apps" },
+        { key: "compose", label: "Compose" },
+        { key: "databases", label: "DB" },
+        { key: "description", label: "Description" },
+    ]);
+    if (!options.summary) {
+        runtime.log.section("Full Response");
+        runtime.log.json(projects);
+    }
+}
+function stringField(project, key) {
+    const value = project[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function countNested(project, keys) {
+    let total = 0;
+    for (const key of keys) {
+        const value = project[key];
+        if (Array.isArray(value)) {
+            total += value.length;
+        }
+        else if (value && typeof value === "object") {
+            total += 1;
+        }
+    }
+    return total === 0 ? chalk.gray("-") : chalk.yellow(String(total));
+}

package/dist/commands/status.js

@@ -0,0 +1,84 @@
+import chalk from "chalk";
+import { DokployApiError } from "../client.js";
+import { getOneById } from "../resources/common.js";
+import { createRuntime } from "../runtime.js";
+export async function statusCommand(options) {
+    const runtime = await createRuntime(options);
+    const rows = [];
+    runtime.log.header("Dokploy Status", runtime.statePath);
+    if (runtime.state.project) {
+        rows.push(await getStatus(runtime.state.project, "project", "project.one", "projectId", runtime));
+    }
+    if (runtime.state.environment) {
+        rows.push(await getStatus(runtime.state.environment, "environment", "environment.one", "environmentId", runtime));
+    }
+    for (const ref of Object.values(runtime.state.databases)) {
+        const idField = `${ref.type}Id`;
+        rows.push(await getStatus(ref, `${ref.type} database`, `${ref.type}.one`, idField, runtime));
+    }
+    for (const ref of Object.values(runtime.state.applications)) {
+        rows.push(await getStatus(ref, "application", "application.one", "applicationId", runtime));
+    }
+    for (const ref of Object.values(runtime.state.compose)) {
+        rows.push(await getStatus(ref, "compose", "compose.one", "composeId", runtime));
+    }
+    for (const ref of Object.values(runtime.state.backupDestinations)) {
+        rows.push(await getStatus(ref, "backup destination", "destination.one", "destinationId", runtime));
+    }
+    for (const ref of Object.values(runtime.state.backups)) {
+        rows.push(await getStatus(ref, "backup", "backup.one", "backupId", runtime));
+    }
+    for (const ref of Object.values(runtime.state.volumeBackups)) {
+        rows.push(await getStatus(ref, "volume backup", "volumeBackups.one", "volumeBackupId", runtime));
+    }
+    runtime.log.table(rows, [
+        { key: "type", label: "Type" },
+        { key: "name", label: "Name" },
+        { key: "status", label: "Status" },
+        { key: "id", label: "ID" },
+    ]);
+}
+async function getStatus(ref, label, endpoint, idField, runtime) {
+    try {
+        const remote = await getOneById(runtime.client, endpoint, idField, ref.id);
+        if (!remote) {
+            return statusRow(ref, label, "missing");
+        }
+        const status = pickStatus(remote);
+        return statusRow(ref, label, status ?? "exists");
+    }
+    catch (error) {
+        if (error instanceof DokployApiError && error.status === 404) {
+            return statusRow(ref, label, "missing");
+        }
+        throw error;
+    }
+}
+function pickStatus(remote) {
+    for (const key of ["applicationStatus", "composeStatus", "status"]) {
+        const value = remote[key];
+        if (typeof value === "string" && value.length > 0)
+            return value;
+    }
+    return undefined;
+}
+function statusRow(ref, type, status) {
+    return {
+        type,
+        name: ref.name,
+        status: colorStatus(status),
+        id: chalk.gray(ref.id),
+    };
+}
+function colorStatus(status) {
+    if (status === "exists" || status === "done" || status === "running") {
+        return chalk.green(status);
+    }
+    if (status === "missing" || status === "error") {
+        return chalk.red(status);
+    }
+    if (status === "idle") {
+        return chalk.cyan(status);
+    }
+    return status;
+}