@lishugupta652/dokploy 0.1.5 → 0.1.6

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 0.1.6 - 2026-04-13
+
+_Initial changelog generated from repository history._
+
+### Fixes
+
+- scripts (691cf33)
+- scripts (2930c10)
+
+### Other Changes
+
+- test (9ab9e57)
+- add script for deployment (c511505)
+- first commit (3f5e457)
+
 ## 0.1.5 - 2026-04-13
 
 _Initial changelog generated from repository history._
@@ -10,6 +25,7 @@ _Initial changelog generated from repository history._
 
 ### Other Changes
 
+- test (9ab9e57)
 - add script for deployment (c511505)
 - first commit (3f5e457)
 

package/README.md

@@ -1,30 +1,44 @@
-# Dokploy
+# Dokploy CLI
 
-YAML-driven CLI for applying Dokploy projects through the Dokploy API.
+YAML-driven CLI for managing Dokploy projects through the Dokploy API.
 
-## Install
+Use it locally or in CI to inspect projects, create/update applications, attach domains, deploy compose stacks, provision databases, and trigger redeploys without relying on the Terraform provider.
 
-```bash
-npm install
-npm run build
-```
+## Features
 
-Run locally during development:
+- Inspect all Dokploy projects with `project.all`.
+- Apply a declarative YAML config.
+- Manage projects, environments, applications, compose stacks, databases, domains, backups, and volume backups.
+- Trigger app or compose redeploys.
+- Keep a small local `dokploy-state.json` file for resource IDs.
+- Use colored terminal output with a raw JSON option for scripts.
+- Accept either a Dokploy root URL or `/api` URL.
 
-```bash
-npm run dev -- apply -f examples/simple-app.yaml --dry-run
-```
+## Requirements
 
-After build, the CLI binary is `dokploy`.
+- Node.js 18 or newer
+- A running Dokploy instance
+- A Dokploy API key
 
-For global install after publishing:
+The API key is read only from `DOKPLOY_API_KEY`. Do not put it in YAML config.
+
+## Install
+
+Global install:
 
 ```bash
 npm install -g @lishugupta652/dokploy
 dokploy --help
 ```
 
-For a local install, run the binary through npm:
+One-off use with npm:
+
+```bash
+npx @lishugupta652/dokploy --help
+npx @lishugupta652/dokploy projects --host https://your-dokploy.example.com
+```
+
+Local project install:
 
 ```bash
 npm install @lishugupta652/dokploy
@@ -32,59 +46,248 @@ npx dokploy --help
 npm exec dokploy -- --help
 ```
 
-## Environment
+## Authentication
 
 ```bash
 export DOKPLOY_API_KEY=your-api-key
-export DOKPLOY_HOST=https://your-dokploy.example.com/api
+export DOKPLOY_HOST=https://your-dokploy.example.com
+```
+
+`DOKPLOY_HOST` is optional when `host` is set in `dokploy.yaml`.
+
+Both forms work:
+
+```bash
+https://your-dokploy.example.com
+https://your-dokploy.example.com/api
+```
+
+The CLI normalizes root hosts to `/api`.
+
+## Quick Start
+
+1. Check your API connection:
+
+```bash
+dokploy projects --host https://your-dokploy.example.com --summary
+```
+
+2. Create a starter config:
+
+```bash
+dokploy init
 ```
 
-`DOKPLOY_HOST` is optional when `host` is set in the YAML file. API keys are never read from config. The CLI accepts either `https://your-dokploy.example.com` or `https://your-dokploy.example.com/api` and normalizes root hosts to `/api`.
+3. Edit `dokploy.yaml`.
+
+4. Preview the changes:
+
+```bash
+dokploy apply -f dokploy.yaml --dry-run
+```
+
+5. Apply the config:
+
+```bash
+dokploy apply -f dokploy.yaml
+```
+
+6. Check status:
+
+```bash
+dokploy status -f dokploy.yaml
+```
 
 ## 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 projects --host https://your-dokploy.example.com
+dokploy projects --summary --host https://your-dokploy.example.com
+dokploy projects --json --host https://your-dokploy.example.com
+
+dokploy init
+dokploy init --output dokploy.yaml --force
+
 dokploy apply -f dokploy.yaml
 dokploy apply -f dokploy.yaml --dry-run
+dokploy apply -f dokploy.yaml --state .dokploy-state.json
+
 dokploy deploy frontend -f dokploy.yaml
 dokploy status -f dokploy.yaml
+
 dokploy destroy frontend -f dokploy.yaml
 dokploy destroy -f dokploy.yaml
-dokploy init
+dokploy destroy -f dokploy.yaml --delete-volumes
 ```
 
-State is written next to the config as `dokploy-state.json` unless `stateFile` or `--state` is provided.
+## Example Config
+
+```yaml
+host: https://your-dokploy.example.com
+
+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: /
+      triggerType: push
+    build:
+      type: dockerfile
+      dockerfile: Dockerfile
+      contextPath: .
+    env:
+      NODE_ENV: production
+      VITE_BACKEND_URL: https://api.example.com
+    domains:
+      - host: app.example.com
+        port: 80
+        path: /
+        https: true
+        certificate: letsencrypt
+    deploy: true
+
+databases:
+  - name: app-db
+    type: postgres
+    version: "16"
+    databaseName: app
+    databaseUser: app
+    password: change-me
+    deploy: true
+```
 
-## Publishing
+More examples are in [`examples/`](examples/).
+
+## Config Notes
+
+- `host` can be the Dokploy root URL or `/api` URL.
+- `environment` is optional. If omitted, the CLI uses the first environment returned by Dokploy for the project.
+- `applications[].deploy: true` triggers a deploy after configuration.
+- `buildArgs`, `buildSecrets`, and `createEnvFile` are supported for applications.
+- Database creation requires a password because the Dokploy API requires one.
+- State is written next to the config as `dokploy-state.json` unless `stateFile` or `--state` is provided.
 
-The npm package name is `@lishugupta652/dokploy`; the command is `dokploy`.
+## Project Inspection
+
+Human-readable output:
 
 ```bash
-npm publish --access public
+dokploy projects --host https://your-dokploy.example.com
 ```
 
-`prepublishOnly` runs the TypeScript check and build before publishing.
+Short table only:
 
-Or use the helper script:
+```bash
+dokploy projects --summary --host https://your-dokploy.example.com
+```
+
+Raw JSON for scripts:
+
+```bash
+dokploy projects --json --host https://your-dokploy.example.com
+```
+
+## Troubleshooting
+
+`zsh: command not found: dokploy`
+
+You probably installed the package locally. Use:
+
+```bash
+npx dokploy --help
+```
+
+or install globally:
+
+```bash
+npm install -g @lishugupta652/dokploy
+```
+
+`Dokploy API /project.all failed with HTTP 404` and the response is HTML
+
+The request hit the Dokploy web UI instead of the API. Use a recent package version and pass either:
+
+```bash
+dokploy projects --host https://your-dokploy.example.com
+dokploy projects --host https://your-dokploy.example.com/api
+```
+
+`DOKPLOY_API_KEY is required`
+
+Set the API key before running commands:
+
+```bash
+export DOKPLOY_API_KEY=your-api-key
+```
+
+## Development
+
+```bash
+npm install
+npm run check
+npm run build
+npm run dev -- projects --host https://your-dokploy.example.com --summary
+```
+
+Using pnpm is fine if you switch the lockfile:
+
+```bash
+rm package-lock.json
+pnpm install
+pnpm run check
+pnpm run build
+```
+
+## Publishing
+
+The package name is `@lishugupta652/dokploy`; the binary is `dokploy`.
+
+Safe dry-run:
 
 ```bash
 ./scripts/publish.sh npm
+```
+
+Publish:
+
+```bash
 ./scripts/publish.sh npm --publish
+```
+
+If the current package version is already on npm, the publish script bumps `patch` automatically before publishing. Override the bump when needed:
+
+```bash
+./scripts/publish.sh npm --publish --bump patch
+./scripts/publish.sh npm --publish --bump minor
+./scripts/publish.sh npm --publish --bump major
+./scripts/publish.sh npm --publish --bump none
+```
+
+pnpm flow:
+
+```bash
 ./scripts/publish.sh pnpm
 ./scripts/publish.sh pnpm --publish
 ```
 
-The script defaults to dry-run mode and publishes only when `--publish` is passed.
+Publishing generates `CHANGELOG.md` from git commits since the latest tag. Conventional Commit messages are grouped into sections such as Features, Fixes, Breaking Changes, and Chores.
 
-Publishing also generates `CHANGELOG.md` from git commits since the latest tag. Conventional Commit messages are grouped into sections such as Features, Fixes, Breaking Changes, and Chores.
+Direct `npm publish --access public` is also protected by `prepublishOnly`: it checks whether the current version already exists on npm and bumps `patch` when needed before building and generating the changelog.
 
-## Commit Version Hook
+## Commit Messages And Versioning
 
-Install the repo hook once:
+Install hooks:
 
 ```bash
 npm run hooks:install
@@ -101,9 +304,3 @@ docs: update usage                 # no version bump
 ```
 
 Use `SKIP_DOKPLOY_VERSION_BUMP=1` to keep commit validation but skip version changes. Use `SKIP_DOKPLOY_COMMIT_CHECK=1` only when you intentionally need to bypass the hook.
-
-## 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lishugupta652/dokploy",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "A YAML-driven CLI for applying Dokploy projects through the Dokploy API.",
   "type": "module",
   "bin": {
@@ -22,7 +22,8 @@
     "commit-msg": "node scripts/commit-msg.mjs",
     "hooks:install": "node scripts/install-git-hooks.mjs",
     "prepack": "npm run build",
-    "prepublishOnly": "npm run check && npm run build && npm run changelog",
+    "prepublishOnly": "npm run version:publish && npm run check && npm run build && npm run changelog",
+    "version:publish": "node scripts/ensure-publish-version.mjs",
     "version:commit": "node scripts/bump-version-on-commit.mjs"
   },
   "publishConfig": {

package/scripts/ensure-publish-version.mjs

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const packageDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const packageJsonPath = path.join(packageDir, "package.json");
+const packageLockPath = path.join(packageDir, "package-lock.json");
+const options = parseArgs(process.argv.slice(2));
+
+const packageJson = readJson(packageJsonPath);
+const packageName = stringValue(packageJson.name, "");
+let version = stringValue(packageJson.version, "");
+
+if (!packageName || !version) {
+  throw new Error("package.json must contain name and version.");
+}
+
+let attempts = 0;
+while (isVersionPublished(options.packageManager, packageName, version)) {
+  if (options.bump === "none") {
+    console.error(`${packageName}@${version} is already published.`);
+    console.error("Pass --bump patch|minor|major or update package.json before publishing.");
+    process.exit(1);
+  }
+
+  const nextVersion = bumpVersion(version, options.bump);
+  console.log(`${packageName}@${version} is already published. Bumping ${options.bump}: ${nextVersion}`);
+  version = nextVersion;
+  attempts += 1;
+
+  if (attempts > 20) {
+    throw new Error("Stopped after 20 version bump attempts.");
+  }
+}
+
+if (version === packageJson.version) {
+  console.log(`${packageName}@${version} is not published yet.`);
+  process.exit(0);
+}
+
+if (options.dryRun) {
+  console.log(`Dry run: would update ${packageName} to ${version}.`);
+  process.exit(0);
+}
+
+packageJson.version = version;
+writeJson(packageJsonPath, packageJson);
+
+if (existsSync(packageLockPath)) {
+  const packageLock = readJson(packageLockPath);
+  packageLock.name = packageJson.name;
+  packageLock.version = version;
+  if (packageLock.packages?.[""]) {
+    packageLock.packages[""].name = packageJson.name;
+    packageLock.packages[""].version = version;
+    packageLock.packages[""].bin = packageJson.bin;
+  }
+  writeJson(packageLockPath, packageLock);
+}
+
+console.log(`Updated package version to ${packageName}@${version}.`);
+
+function parseArgs(args) {
+  const parsed = {
+    bump: "patch",
+    packageManager: "npm",
+    dryRun: false,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    switch (arg) {
+      case "--bump":
+        parsed.bump = stringArg(args, index);
+        index += 1;
+        break;
+      case "--package-manager":
+        parsed.packageManager = stringArg(args, index);
+        index += 1;
+        break;
+      case "--dry-run":
+        parsed.dryRun = true;
+        break;
+      default:
+        throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+
+  if (!["patch", "minor", "major", "none"].includes(parsed.bump)) {
+    throw new Error("--bump must be patch, minor, major, or none.");
+  }
+  if (!["npm", "pnpm"].includes(parsed.packageManager)) {
+    throw new Error("--package-manager must be npm or pnpm.");
+  }
+
+  return parsed;
+}
+
+function stringArg(args, index) {
+  const value = args[index + 1];
+  if (!value) {
+    throw new Error(`Missing value for ${args[index]}.`);
+  }
+  return value;
+}
+
+function isVersionPublished(packageManager, packageName, version) {
+  try {
+    const output = execFileSync(
+      packageManager,
+      ["view", `${packageName}@${version}`, "version", "--json"],
+      {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+      },
+    ).trim();
+
+    return output.length > 0 && output !== "null";
+  } catch (error) {
+    const stderr = String(error.stderr ?? "");
+    if (stderr.includes("E404") || stderr.includes("404 Not Found")) {
+      return false;
+    }
+    throw error;
+  }
+}
+
+function bumpVersion(version, bump) {
+  const match = version.match(/^(\d+)\.(\d+)\.(\d+)(-.+)?$/);
+  if (!match) {
+    throw new Error(`Unsupported semver version: ${version}`);
+  }
+
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  const patch = Number(match[3]);
+
+  switch (bump) {
+    case "major":
+      return `${major + 1}.0.0`;
+    case "minor":
+      return `${major}.${minor + 1}.0`;
+    case "patch":
+      return `${major}.${minor}.${patch + 1}`;
+    default:
+      throw new Error(`Unsupported bump type: ${bump}`);
+  }
+}
+
+function readJson(filePath) {
+  return JSON.parse(readFileSync(filePath, "utf8"));
+}
+
+function writeJson(filePath, value) {
+  writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function stringValue(value, fallback) {
+  return typeof value === "string" ? value : fallback;
+}

package/scripts/publish.sh

@@ -4,20 +4,23 @@ set -eu
 PACKAGE_MANAGER="npm"
 PUBLISH="0"
 ACCESS="public"
+BUMP="patch"
 
 usage() {
   cat <<'EOF'
 Usage:
-  ./scripts/publish.sh [npm|pnpm] [--publish] [--access public|restricted]
+  ./scripts/publish.sh [npm|pnpm] [--publish] [--access public|restricted] [--bump patch|minor|major|none]
 
 Examples:
   ./scripts/publish.sh npm
   ./scripts/publish.sh npm --publish
+  ./scripts/publish.sh npm --publish --bump minor
   ./scripts/publish.sh pnpm
   ./scripts/publish.sh pnpm --publish
 
 Default mode is safe: it runs checks and pack dry-run only.
 Pass --publish to publish @lishugupta652/dokploy to npm.
+In publish mode, if the current version already exists on npm, the script bumps patch by default.
 EOF
 }
 
@@ -43,6 +46,22 @@ while [ "$#" -gt 0 ]; do
       ACCESS="$2"
       shift 2
       ;;
+    --bump)
+      if [ "$#" -lt 2 ]; then
+        echo "Missing value for --bump" >&2
+        exit 1
+      fi
+      case "$2" in
+        patch|minor|major|none)
+          BUMP="$2"
+          ;;
+        *)
+          echo "--bump must be patch, minor, major, or none" >&2
+          exit 1
+          ;;
+      esac
+      shift 2
+      ;;
     -h|--help)
       usage
       exit 0
@@ -79,6 +98,7 @@ fi
 echo "Package manager: $PACKAGE_MANAGER"
 echo "Publish mode:    $PUBLISH"
 echo "Access:          $ACCESS"
+echo "Version bump:    $BUMP"
 echo ""
 
 if [ "$PUBLISH" = "1" ]; then
@@ -88,6 +108,10 @@ if [ "$PUBLISH" = "1" ]; then
   fi
   echo "Logged in as: $("$PACKAGE_MANAGER" whoami)"
   echo ""
+
+  echo "Checking npm version availability..."
+  node scripts/ensure-publish-version.mjs --package-manager "$PACKAGE_MANAGER" --bump "$BUMP"
+  echo ""
 fi
 
 echo "Checking package..."