@lishugupta652/dokploy 0.1.3 → 0.1.5

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,28 @@
+# Changelog
+
+## 0.1.5 - 2026-04-13
+
+_Initial changelog generated from repository history._
+
+### Fixes
+
+- scripts (2930c10)
+
+### Other Changes
+
+- 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

@@ -24,6 +24,14 @@ npm install -g @lishugupta652/dokploy
 dokploy --help
 ```
 
+For a local install, run the binary through npm:
+
+```bash
+npm install @lishugupta652/dokploy
+npx dokploy --help
+npm exec dokploy -- --help
+```
+
 ## Environment
 
 ```bash
@@ -31,7 +39,7 @@ 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.
+`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`.
 
 ## Commands
 
@@ -39,6 +47,7 @@ export DOKPLOY_HOST=https://your-dokploy.example.com/api
 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 apply -f dokploy.yaml
 dokploy apply -f dokploy.yaml --dry-run
 dokploy deploy frontend -f dokploy.yaml
@@ -60,6 +69,19 @@ npm publish --access public
 
 `prepublishOnly` runs the TypeScript check and build before publishing.
 
+Or use the helper script:
+
+```bash
+./scripts/publish.sh npm
+./scripts/publish.sh npm --publish
+./scripts/publish.sh pnpm
+./scripts/publish.sh pnpm --publish
+```
+
+The script defaults to dry-run mode and publishes only when `--publish` is passed.
+
+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.
+
 ## Commit Version Hook
 
 Install the repo hook once:
@@ -68,7 +90,17 @@ Install the repo hook once:
 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:
+
+```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
+```
+
+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
 

package/dist/client.js

@@ -14,7 +14,7 @@ export class DokployClient {
     baseUrl;
     apiKey;
     constructor(options) {
-        this.baseUrl = options.host.replace(/\/+$/, "");
+        this.baseUrl = normalizeDokployHost(options.host);
         this.apiKey = options.apiKey;
     }
     async get(endpoint, query) {
@@ -76,12 +76,35 @@ export class DokployClient {
     }
     formatErrorMessage(status, endpoint, body) {
         const detail = extractErrorDetail(body);
-        const hint = status === 401 || status === 403
-            ? " Check DOKPLOY_API_KEY and the API key permissions."
-            : "";
+        const hint = errorHint(status, body);
         return `Dokploy API ${endpoint} failed with HTTP ${status}${detail ? `: ${detail}` : ""}.${hint}`;
     }
 }
+function normalizeDokployHost(host) {
+    const url = new URL(host);
+    const pathname = url.pathname.replace(/\/+$/, "");
+    if (!pathname || pathname === "/") {
+        url.pathname = "/api";
+    }
+    else if (!pathname.endsWith("/api")) {
+        url.pathname = `${pathname}/api`;
+    }
+    else {
+        url.pathname = pathname;
+    }
+    url.search = "";
+    url.hash = "";
+    return url.toString().replace(/\/+$/, "");
+}
+function errorHint(status, body) {
+    if (status === 401 || status === 403) {
+        return " Check DOKPLOY_API_KEY and the API key permissions.";
+    }
+    if (status === 404 && /<html/i.test(body)) {
+        return " Dokploy returned an HTML page, which usually means the request hit the web UI instead of the API. The CLI now normalizes root hosts to /api; verify the host points to your Dokploy server.";
+    }
+    return "";
+}
 function extractErrorDetail(body) {
     if (!body.trim())
         return undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lishugupta652/dokploy",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "A YAML-driven CLI for applying Dokploy projects through the Dokploy API.",
   "type": "module",
   "bin": {
@@ -11,15 +11,18 @@
     "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 check && npm run build && npm run changelog",
     "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/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

@@ -0,0 +1,133 @@
+#!/usr/bin/env sh
+set -eu
+
+PACKAGE_MANAGER="npm"
+PUBLISH="0"
+ACCESS="public"
+
+usage() {
+  cat <<'EOF'
+Usage:
+  ./scripts/publish.sh [npm|pnpm] [--publish] [--access public|restricted]
+
+Examples:
+  ./scripts/publish.sh npm
+  ./scripts/publish.sh npm --publish
+  ./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.
+EOF
+}
+
+while [ "$#" -gt 0 ]; do
+  case "$1" in
+    npm|pnpm)
+      PACKAGE_MANAGER="$1"
+      shift
+      ;;
+    --publish)
+      PUBLISH="1"
+      shift
+      ;;
+    --dry-run)
+      PUBLISH="0"
+      shift
+      ;;
+    --access)
+      if [ "$#" -lt 2 ]; then
+        echo "Missing value for --access" >&2
+        exit 1
+      fi
+      ACCESS="$2"
+      shift 2
+      ;;
+    -h|--help)
+      usage
+      exit 0
+      ;;
+    *)
+      echo "Unknown argument: $1" >&2
+      usage
+      exit 1
+      ;;
+  esac
+done
+
+cd "$(dirname "$0")/.."
+
+if ! command -v "$PACKAGE_MANAGER" >/dev/null 2>&1; then
+  if [ "$PACKAGE_MANAGER" = "pnpm" ]; then
+    echo "pnpm is not installed. Try: corepack enable && corepack prepare pnpm@latest --activate" >&2
+  else
+    echo "$PACKAGE_MANAGER is not installed." >&2
+  fi
+  exit 1
+fi
+
+if [ "$PACKAGE_MANAGER" = "npm" ]; then
+  export NPM_CONFIG_CACHE="${NPM_CONFIG_CACHE:-/tmp/dokploy-npm-cache}"
+fi
+
+if [ "$PACKAGE_MANAGER" = "pnpm" ] && [ ! -f "pnpm-lock.yaml" ] && [ -f "package-lock.json" ]; then
+  echo "Note: package-lock.json exists and pnpm-lock.yaml does not."
+  echo "To fully switch this package to pnpm, run: rm package-lock.json && pnpm install"
+  echo ""
+fi
+
+echo "Package manager: $PACKAGE_MANAGER"
+echo "Publish mode:    $PUBLISH"
+echo "Access:          $ACCESS"
+echo ""
+
+if [ "$PUBLISH" = "1" ]; then
+  if ! "$PACKAGE_MANAGER" whoami >/dev/null 2>&1; then
+    echo "Not logged in to npm. Run: $PACKAGE_MANAGER login" >&2
+    exit 1
+  fi
+  echo "Logged in as: $("$PACKAGE_MANAGER" whoami)"
+  echo ""
+fi
+
+echo "Checking package..."
+"$PACKAGE_MANAGER" run check
+
+echo ""
+echo "Building package..."
+"$PACKAGE_MANAGER" run build
+
+echo ""
+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
+
+if [ "$PUBLISH" != "1" ]; then
+  echo ""
+  echo "Dry run complete. Publish with:"
+  echo "  ./scripts/publish.sh $PACKAGE_MANAGER --publish"
+  exit 0
+fi
+
+echo ""
+echo "Publishing @lishugupta652/dokploy..."
+"$PACKAGE_MANAGER" publish --access "$ACCESS"
+
+echo ""
+echo "Published. Verify with:"
+echo "  npm view @lishugupta652/dokploy version"
+echo "  npm install -g @lishugupta652/dokploy"
+echo "  dokploy --help"