@lishugupta652/dokploy 0.1.4 → 0.1.6

package/.githooks/commit-msg

@@ -0,0 +1,9 @@
+#!/bin/sh
+set -e
+
+PACKAGE_DIR="dokploy-deploy-automation"
+if [ ! -f "$PACKAGE_DIR/scripts/commit-msg.mjs" ]; then
+  PACKAGE_DIR="."
+fi
+
+node "$PACKAGE_DIR/scripts/commit-msg.mjs" "$1"

package/.githooks/pre-commit

@@ -1,10 +1,5 @@
 #!/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"
+# Commit message validation and semver bumping happen in commit-msg.
+exit 0

package/CHANGELOG.md

@@ -0,0 +1,44 @@
+# 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._
+
+### Fixes
+
+- scripts (2930c10)
+
+### Other Changes
+
+- test (9ab9e57)
+- add script for deployment (c511505)
+- first commit (3f5e457)
+
+## 0.1.4 - 2026-04-13
+
+_Initial changelog generated from repository history._
+
+### Fixes
+
+- scripts (2930c10)
+
+### Other Changes
+
+- 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
+
+- Node.js 18 or newer
+- A running Dokploy instance
+- A Dokploy API key
 
-After build, the CLI binary is `dokploy`.
+The API key is read only from `DOKPLOY_API_KEY`. Do not put it in YAML config.
 
-For global install after publishing:
+## 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,66 +46,261 @@ 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 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`.
+`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
+```
+
+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
 
-## Publishing
+```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
+```
+
+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
+dokploy projects --host https://your-dokploy.example.com
+```
+
+Short table only:
+
+```bash
+dokploy projects --summary --host https://your-dokploy.example.com
+```
+
+Raw JSON for scripts:
 
 ```bash
-npm publish --access public
+dokploy projects --json --host https://your-dokploy.example.com
 ```
 
-`prepublishOnly` runs the TypeScript check and build before publishing.
+## Troubleshooting
+
+`zsh: command not found: dokploy`
+
+You probably installed the package locally. Use:
+
+```bash
+npx dokploy --help
+```
 
-Or use the helper script:
+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.
+
+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
 ```
 
-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.
+The `commit-msg` hook enforces Conventional Commits and bumps `package.json` plus `package-lock.json` from the commit message:
 
-## Notes
+```text
+feat: add project listing          # minor
+fix(projects): normalize host      # patch
+perf: improve status lookup        # patch
+feat!: change config schema        # major
+docs: update usage                 # no version bump
+```
 
-- `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.
+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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lishugupta652/dokploy",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "A YAML-driven CLI for applying Dokploy projects through the Dokploy API.",
   "type": "module",
   "bin": {
@@ -11,15 +11,19 @@
     "examples",
     "scripts",
     ".githooks",
+    "CHANGELOG.md",
     "README.md"
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "changelog": "node scripts/generate-changelog.mjs",
     "check": "tsc -p tsconfig.json --noEmit",
     "dev": "tsx src/index.ts",
+    "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",
+    "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/commit-msg.mjs

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import { readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const allowedTypes = new Set([
+  "feat",
+  "fix",
+  "perf",
+  "refactor",
+  "docs",
+  "test",
+  "build",
+  "ci",
+  "chore",
+  "style",
+  "revert",
+]);
+
+const bumpByType = new Map([
+  ["feat", "minor"],
+  ["fix", "patch"],
+  ["perf", "patch"],
+]);
+
+const messagePath = process.argv[2];
+if (!messagePath) {
+  console.error("Missing commit message file path.");
+  process.exit(1);
+}
+
+const message = readFileSync(messagePath, "utf8");
+const header = firstCommitMessageLine(message);
+
+if (!header) {
+  fail("Commit message is empty.");
+}
+
+if (process.env.SKIP_DOKPLOY_COMMIT_CHECK === "1") {
+  process.exit(0);
+}
+
+if (isGeneratedCommit(header)) {
+  process.exit(0);
+}
+
+const parsed = parseConventionalCommit(header);
+if (!parsed) {
+  fail(`Invalid commit message: ${header}`);
+}
+
+if (!allowedTypes.has(parsed.type)) {
+  fail(`Unsupported commit type "${parsed.type}".`);
+}
+
+if (parsed.subject.trim().length === 0) {
+  fail("Commit subject cannot be empty.");
+}
+
+const bump = resolveBump(parsed, message);
+if (!bump) {
+  console.log(`Commit type "${parsed.type}" does not change the package version.`);
+  process.exit(0);
+}
+
+if (process.env.SKIP_DOKPLOY_VERSION_BUMP === "1") {
+  console.log(`Skipping ${bump} version bump because SKIP_DOKPLOY_VERSION_BUMP=1.`);
+  process.exit(0);
+}
+
+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 packageJson = readJson(packageJsonPath);
+const nextVersion = bumpVersion(packageJson.version, bump);
+
+if (process.env.DOKPLOY_VERSION_DRY_RUN === "1") {
+  console.log(`${parsed.type} commit will create ${bump} version: ${packageJson.version} -> ${nextVersion}`);
+  process.exit(0);
+}
+
+packageJson.version = nextVersion;
+writeJson(packageJsonPath, packageJson);
+
+const packageLock = readJson(packageLockPath);
+packageLock.name = packageJson.name;
+packageLock.version = nextVersion;
+if (packageLock.packages?.[""]) {
+  packageLock.packages[""].name = packageJson.name;
+  packageLock.packages[""].version = nextVersion;
+  packageLock.packages[""].bin = packageJson.bin;
+}
+writeJson(packageLockPath, packageLock);
+
+execFileSync("git", ["-C", packageDir, "add", packageJsonPath, packageLockPath], {
+  stdio: "inherit",
+});
+
+console.log(`${parsed.type} commit created ${bump} version: ${packageJson.name}@${nextVersion}`);
+
+function firstCommitMessageLine(rawMessage) {
+  return rawMessage
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .find((line) => line.length > 0 && !line.startsWith("#"));
+}
+
+function isGeneratedCommit(headerLine) {
+  return (
+    headerLine.startsWith("Merge ") ||
+    headerLine.startsWith("Revert ") ||
+    headerLine.startsWith("fixup!") ||
+    headerLine.startsWith("squash!")
+  );
+}
+
+function parseConventionalCommit(headerLine) {
+  const match = headerLine.match(/^([a-z]+)(\([a-z0-9._/-]+\))?(!)?: (.+)$/);
+  if (!match) return undefined;
+
+  return {
+    type: match[1],
+    breaking: Boolean(match[3]),
+    subject: match[4],
+  };
+}
+
+function resolveBump(parsedCommit, rawMessage) {
+  if (parsedCommit.breaking || /\nBREAKING[ -]CHANGE:/m.test(rawMessage)) {
+    return "major";
+  }
+  return bumpByType.get(parsedCommit.type);
+}
+
+function bumpVersion(version, bump) {
+  if (typeof version !== "string") {
+    throw new Error("package.json version must be a string");
+  }
+
+  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 fail(messageText) {
+  console.error(messageText);
+  console.error("");
+  console.error("Use Conventional Commits:");
+  console.error("  feat: add project listing");
+  console.error("  fix(projects): normalize Dokploy host");
+  console.error("  feat!: change config schema");
+  console.error("");
+  console.error("Version bump rules:");
+  console.error("  feat or feat(scope)  -> minor");
+  console.error("  fix/perf             -> patch");
+  console.error("  ! or BREAKING CHANGE -> major");
+  console.error("  docs/chore/etc.      -> no version bump");
+  process.exit(1);
+}

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/generate-changelog.mjs

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+import { execFileSync } from "node:child_process";
+import { 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 changelogPath = path.join(packageDir, "CHANGELOG.md");
+const args = new Set(process.argv.slice(2));
+const dryRun = args.has("--dry-run");
+
+const packageJson = readJson(packageJsonPath);
+const version = stringValue(packageJson.version, "0.0.0");
+const today = new Date().toISOString().slice(0, 10);
+const lastTag = getLastTag();
+const commits = getCommits(lastTag);
+const section = renderVersionSection(version, today, lastTag, commits);
+
+if (dryRun) {
+  console.log(section.trimEnd());
+  process.exit(0);
+}
+
+const currentChangelog = readChangelog();
+const nextChangelog = upsertVersionSection(currentChangelog, version, section);
+writeFileSync(changelogPath, nextChangelog, "utf8");
+
+console.log(`Updated CHANGELOG.md for ${packageJson.name}@${version}`);
+
+function getLastTag() {
+  try {
+    return execFileSync("git", ["-C", packageDir, "describe", "--tags", "--abbrev=0"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+  } catch {
+    return undefined;
+  }
+}
+
+function getCommits(tag) {
+  const range = tag ? [`${tag}..HEAD`] : [];
+  const output = execFileSync(
+    "git",
+    [
+      "-C",
+      packageDir,
+      "log",
+      "--date=short",
+      "--pretty=format:%H%x1f%ad%x1f%s%x1f%b%x1e",
+      ...range,
+    ],
+    { encoding: "utf8" },
+  );
+
+  return output
+    .split("\x1e")
+    .map((record) => record.trim())
+    .filter(Boolean)
+    .map(parseCommit);
+}
+
+function parseCommit(record) {
+  const [hash = "", date = "", subject = "", body = ""] = record.split("\x1f");
+  const conventional = subject.match(/^([a-z]+)(\([a-z0-9._/-]+\))?(!)?: (.+)$/);
+
+  if (!conventional) {
+    return {
+      hash,
+      date,
+      type: "other",
+      breaking: /\nBREAKING[ -]CHANGE:/m.test(body),
+      subject,
+    };
+  }
+
+  return {
+    hash,
+    date,
+    type: conventional[1],
+    breaking: Boolean(conventional[3]) || /\nBREAKING[ -]CHANGE:/m.test(body),
+    subject: conventional[4],
+  };
+}
+
+function renderVersionSection(nextVersion, date, tag, commits) {
+  const lines = [`## ${nextVersion} - ${date}`, ""];
+  lines.push(tag ? `_Changes since ${tag}._` : "_Initial changelog generated from repository history._");
+  lines.push("");
+
+  if (commits.length === 0) {
+    lines.push("- No commits found since the last tag.", "");
+    return `${lines.join("\n")}\n`;
+  }
+
+  const breaking = commits.filter((commit) => commit.breaking);
+  appendGroup(lines, "Breaking Changes", breaking);
+
+  const grouped = [
+    ["Features", ["feat"]],
+    ["Fixes", ["fix"]],
+    ["Performance", ["perf"]],
+    ["Refactoring", ["refactor"]],
+    ["Documentation", ["docs"]],
+    ["Tests", ["test"]],
+    ["Build", ["build"]],
+    ["CI", ["ci"]],
+    ["Chores", ["chore"]],
+    ["Styles", ["style"]],
+    ["Reverts", ["revert"]],
+    ["Other Changes", ["other"]],
+  ];
+
+  for (const [title, types] of grouped) {
+    appendGroup(
+      lines,
+      title,
+      commits.filter((commit) => types.includes(commit.type) && !commit.breaking),
+    );
+  }
+
+  return `${lines.join("\n").trimEnd()}\n\n`;
+}
+
+function appendGroup(lines, title, commits) {
+  if (commits.length === 0) return;
+
+  lines.push(`### ${title}`, "");
+  for (const commit of commits) {
+    lines.push(`- ${commit.subject} (${commit.hash.slice(0, 7)})`);
+  }
+  lines.push("");
+}
+
+function upsertVersionSection(currentChangelog, nextVersion, section) {
+  const header = "# Changelog\n\n";
+  const body = currentChangelog.startsWith("# Changelog\n")
+    ? currentChangelog.slice(header.length)
+    : currentChangelog.trimStart();
+  const versionHeader = `## ${nextVersion} - `;
+  const start = body.indexOf(versionHeader);
+
+  if (start === -1) {
+    return `${header}${section}${body.trimStart()}`;
+  }
+
+  const nextSectionStart = body.indexOf("\n## ", start + 1);
+  const before = body.slice(0, start);
+  const after = nextSectionStart === -1 ? "" : body.slice(nextSectionStart + 1);
+
+  return `${header}${before}${section}${after}`.replace(/\n{3,}/g, "\n\n");
+}
+
+function readChangelog() {
+  try {
+    return readFileSync(changelogPath, "utf8");
+  } catch {
+    return "# Changelog\n\n";
+  }
+}
+
+function readJson(filePath) {
+  return JSON.parse(readFileSync(filePath, "utf8"));
+}
+
+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..."
@@ -102,6 +126,15 @@ echo "CLI smoke test..."
 node dist/index.js --version
 node dist/index.js --help >/dev/null
 
+echo ""
+if [ "$PUBLISH" = "1" ]; then
+  echo "Generating changelog..."
+  "$PACKAGE_MANAGER" run changelog
+else
+  echo "Changelog dry-run..."
+  "$PACKAGE_MANAGER" run changelog -- --dry-run
+fi
+
 echo ""
 echo "Pack dry-run..."
 "$PACKAGE_MANAGER" pack --dry-run