ui-syncup-cli 0.4.0-beta.6

package/README.md

@@ -0,0 +1,94 @@
+# ui-syncup CLI
+
+Self-host [UI SyncUp](https://github.com/BYKHD/ui-syncup) with a single command. No infrastructure knowledge required.
+
+## Requirements
+
+- [Docker](https://docs.docker.com/get-docker/) ≥ 24
+- Node.js ≥ 20 (only needed to run the CLI — the app itself runs in Docker)
+
+## Quick Start
+
+```bash
+mkdir my-syncup && cd my-syncup
+npx ui-syncup init
+```
+
+The wizard downloads `compose.yml`, walks you through service configuration, and starts the stack.
+
+## Commands
+
+### Setup & Lifecycle
+
+| Command | Description |
+|---|---|
+| `init` | Guided first-time setup wizard |
+| `start` | Start the stack (reads `COMPOSE_PROFILES` from `.env`) |
+| `stop` | Stop gracefully — data is preserved |
+| `restart [service]` | Restart all services or a single one |
+| `remove` | Remove containers (`--volumes` to also wipe all data) |
+
+### Observability
+
+| Command | Description |
+|---|---|
+| `status` | Show container states, health, and app URL |
+| `logs [service]` | Tail last 200 lines (`-F` to stream live) |
+| `doctor` | Validate env vars, health endpoint, and disk space |
+| `open` | Open the app in your default browser |
+
+### Maintenance
+
+| Command | Description |
+|---|---|
+| `upgrade` | Pull latest image and restart (migrations apply automatically) |
+| `backup` | Dump PostgreSQL + MinIO to a timestamped `.tar.gz` |
+| `restore <archive>` | Restore from a backup archive |
+
+## Usage Examples
+
+```bash
+# First-time setup
+npx ui-syncup init
+
+# Day-to-day
+ui-syncup status
+ui-syncup logs -F              # stream all logs
+ui-syncup logs app -F          # stream app logs only
+ui-syncup restart app          # restart just the app container
+
+# Upgrades
+ui-syncup upgrade
+
+# Backup & restore
+ui-syncup backup -o ~/backups
+ui-syncup restore ~/backups/ui-syncup-backup-2026-03-19T12-00.tar.gz
+
+# Teardown
+ui-syncup remove               # keep data volumes
+ui-syncup remove --volumes     # wipe everything
+```
+
+## Bundled Services (Docker Compose profiles)
+
+`init` lets you choose which services to bundle. Your selection is saved as `COMPOSE_PROFILES` in `.env` so subsequent `start`/`upgrade` commands pick it up automatically.
+
+| Profile | Service | Use when |
+|---|---|---|
+| `db` | PostgreSQL 15 | No external database |
+| `cache` | Redis 7 | No external Redis/Upstash |
+| `storage` | MinIO | No external S3/R2/Backblaze |
+
+## Backup Details
+
+`backup` only exports data for active profiles:
+
+- **PostgreSQL** (`db` profile) — `pg_dumpall` → `postgres.sql`
+- **MinIO** (`storage` profile) — volume tar → `minio_data.tar.gz`
+- Redis is intentionally excluded (cache — not persistent state)
+
+Output is a single `.tar.gz` archive you can store offsite.
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,779 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports2, module2) {
+    module2.exports = {
+      name: "ui-syncup-cli",
+      version: "0.4.0-beta.5",
+      description: "Self-host UI SyncUp with a single command",
+      bin: {
+        "ui-syncup": "./dist/index.js"
+      },
+      files: [
+        "dist"
+      ],
+      scripts: {
+        build: "tsup",
+        dev: "tsup --watch"
+      },
+      dependencies: {
+        commander: "^12.0.0",
+        "@inquirer/prompts": "^8.0.0",
+        chalk: "^5.3.0",
+        ora: "^8.0.0"
+      },
+      devDependencies: {
+        tsup: "^8.0.0",
+        typescript: "^5.0.0",
+        "@types/node": "^20.0.0"
+      },
+      engines: {
+        node: ">=20"
+      },
+      license: "MIT"
+    };
+  }
+});
+
+// index.ts
+var import_commander = require("commander");
+
+// src/commands/init.ts
+var import_node_fs2 = require("fs");
+var import_node_child_process2 = require("child_process");
+var import_prompts = require("@inquirer/prompts");
+
+// src/lib/ui.ts
+var import_chalk = __toESM(require("chalk"));
+var pipe = import_chalk.default.white("\u2502");
+var ui = {
+  banner: (version3) => {
+    const title = `  \u2732  UI SyncUp  v${version3}  `;
+    const tagline = `  A visual feedback and issue tracking platform  `;
+    const width = Math.max(title.length, tagline.length);
+    const pad = (s) => s + " ".repeat(width - s.length);
+    console.log(import_chalk.default.white("\u2554" + "\u2550".repeat(width) + "\u2557"));
+    console.log(
+      import_chalk.default.white("\u2551") + "  " + import_chalk.default.white("\u2732") + "  " + import_chalk.default.bold.white("UI SyncUp") + "  " + import_chalk.default.dim(`v${version3}`) + " ".repeat(width - title.length + 2) + import_chalk.default.white("\u2551")
+    );
+    console.log(import_chalk.default.white("\u2560" + "\u2500".repeat(width) + "\u2563"));
+    console.log(
+      import_chalk.default.white("\u2551") + import_chalk.default.dim(pad(tagline)) + import_chalk.default.white("\u2551")
+    );
+    console.log(import_chalk.default.white("\u255A" + "\u2550".repeat(width) + "\u255D"));
+  },
+  header: (msg) => {
+    console.log(" ");
+    console.log(import_chalk.default.cyan("\u2699\uFE0E") + " " + import_chalk.default.bold.white(msg));
+    console.log(pipe);
+  },
+  step: (n, total, msg) => {
+    console.log(import_chalk.default.magenta("\u25C6") + "  " + import_chalk.default.bold.magenta(`Step ${n} of ${total}`));
+    console.log(pipe + "  " + import_chalk.default.white(msg));
+  },
+  info: (msg) => console.log(pipe + "  \u{1F680} " + import_chalk.default.blue(msg)),
+  success: (msg) => console.log(pipe + "  \u2728 " + import_chalk.default.green(msg)),
+  warn: (msg) => console.log(pipe + "  \u26A0\uFE0F " + import_chalk.default.yellow(msg)),
+  error: (msg) => console.error(pipe + "  \u{1F6A8} " + import_chalk.default.red(msg))
+};
+
+// src/lib/env.ts
+var import_node_fs = require("fs");
+var import_node_crypto = require("crypto");
+var REQUIRED_VARS = [
+  "DATABASE_URL",
+  "DIRECT_URL",
+  "REDIS_URL",
+  "BETTER_AUTH_SECRET",
+  "BETTER_AUTH_URL",
+  "NEXT_PUBLIC_APP_URL",
+  "NEXT_PUBLIC_API_URL"
+];
+var ENV_EXAMPLE_URL = "https://github.com/BYKHD/ui-syncup/blob/main/.env.example";
+function parseEnv(filePath) {
+  if (!(0, import_node_fs.existsSync)(filePath)) return {};
+  const content = (0, import_node_fs.readFileSync)(filePath, "utf-8");
+  const vars = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const idx = trimmed.indexOf("=");
+    if (idx === -1) continue;
+    vars[trimmed.slice(0, idx)] = trimmed.slice(idx + 1);
+  }
+  return vars;
+}
+function writeEnv(filePath, vars) {
+  const lines = Object.entries(vars).map(([k, v]) => `${k}=${v}`);
+  (0, import_node_fs.writeFileSync)(filePath, lines.join("\n") + "\n", { mode: 384 });
+}
+function generateSecret() {
+  return (0, import_node_crypto.randomBytes)(32).toString("hex");
+}
+function getMissingVars(vars) {
+  return REQUIRED_VARS.filter((k) => !vars[k] || vars[k].trim() === "");
+}
+
+// src/lib/docker.ts
+var import_node_child_process = require("child_process");
+function isDockerRunning() {
+  try {
+    (0, import_node_child_process.execSync)("docker info", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function volumeExists(volumeName) {
+  try {
+    const result = (0, import_node_child_process.execSync)(`docker volume inspect ${volumeName}`, { stdio: "pipe" });
+    return !!result;
+  } catch {
+    return false;
+  }
+}
+function removeVolume(volumeName) {
+  try {
+    (0, import_node_child_process.execSync)(`docker volume rm ${volumeName}`, { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function runCompose(composeFile, args, profiles = [], quiet = false) {
+  const profileFlags = profiles.flatMap((p) => ["--profile", p]);
+  const cmd = ["docker", "compose", "-f", composeFile, ...profileFlags, ...args];
+  const result = (0, import_node_child_process.spawnSync)(cmd[0], cmd.slice(1), { stdio: quiet ? "pipe" : "inherit" });
+  return { success: result.status === 0 };
+}
+
+// src/commands/init.ts
+var { version } = require_package();
+var COMPOSE_URL = "https://raw.githubusercontent.com/BYKHD/ui-syncup/main/docker/compose.yml";
+var ENV_EXAMPLE_URL2 = "https://raw.githubusercontent.com/BYKHD/ui-syncup/main/.env.example";
+async function initCommand() {
+  ui.banner(version);
+  ui.header("Setup Wizard \u{1FA84}");
+  ui.step(1, 6, "Checking Docker...");
+  if (!isDockerRunning()) {
+    ui.error("Docker is not running. Please start Docker and try again.");
+    process.exit(1);
+  }
+  ui.success("Docker is running");
+  ui.step(2, 6, "Setting up compose.yml...");
+  if ((0, import_node_fs2.existsSync)("compose.yml")) {
+    ui.info("compose.yml already exists \u2014 skipping download");
+  } else {
+    (0, import_node_child_process2.execSync)(`curl -fsSL "${COMPOSE_URL}" -o compose.yml`, { stdio: "inherit" });
+    ui.success("Downloaded compose.yml");
+  }
+  ui.step(3, 6, "Setting up .env...");
+  let envVars = {};
+  const envExists = (0, import_node_fs2.existsSync)(".env");
+  if (envExists) {
+    ui.warn(".env already exists \u2014 checking for missing vars only");
+    envVars = parseEnv(".env");
+  } else {
+    (0, import_node_child_process2.execSync)(`curl -fsSL "${ENV_EXAMPLE_URL2}" -o .env`, { stdio: "inherit" });
+    envVars = parseEnv(".env");
+    ui.success("Downloaded .env template");
+  }
+  ui.step(4, 6, "Configuring services...");
+  const appUrl = await (0, import_prompts.input)({
+    message: "Public URL of your app (e.g. https://syncup.example.com):",
+    default: envVars["BETTER_AUTH_URL"] || "",
+    validate: (v) => v.startsWith("http") || "Must start with http:// or https://"
+  });
+  envVars["BETTER_AUTH_URL"] = appUrl;
+  envVars["NEXT_PUBLIC_APP_URL"] = appUrl;
+  envVars["NEXT_PUBLIC_API_URL"] = `${appUrl}/api`;
+  if (!envVars["BETTER_AUTH_SECRET"]) {
+    const autoSecret = await (0, import_prompts.confirm)({
+      message: "Auto-generate a secure BETTER_AUTH_SECRET?",
+      default: true
+    });
+    if (autoSecret) {
+      envVars["BETTER_AUTH_SECRET"] = generateSecret();
+      ui.success("Generated BETTER_AUTH_SECRET");
+    }
+  }
+  const profiles = [];
+  const dbChoice = await (0, import_prompts.select)({
+    message: "Database backend:",
+    choices: [
+      { name: "Bundled PostgreSQL (recommended)", value: "bundled" },
+      { name: "External (Supabase / Neon / other)", value: "external" }
+    ]
+  });
+  if (dbChoice === "bundled") {
+    profiles.push("db");
+    const projectName = process.env["COMPOSE_PROJECT_NAME"] || "ui-syncup";
+    const pgVolume = `${projectName}_postgres_data`;
+    const volumeAlreadyExists = volumeExists(pgVolume);
+    if (volumeAlreadyExists) {
+      ui.warn(`Existing PostgreSQL volume detected (${pgVolume}).`);
+      ui.warn("The password you enter MUST match the one used when the volume was first created.");
+      ui.warn('If you changed the password, choose "Reset" to wipe the volume and start fresh.');
+      const resetChoice = await (0, import_prompts.select)({
+        message: "How do you want to proceed?",
+        choices: [
+          { name: "Keep existing volume (enter the original password)", value: "keep" },
+          { name: "Reset volume \u2014 wipe all data and reinitialise (irreversible)", value: "reset" }
+        ]
+      });
+      if (resetChoice === "reset") {
+        const confirmed = await (0, import_prompts.confirm)({
+          message: `Delete volume "${pgVolume}" and all its data? This cannot be undone.`,
+          default: false
+        });
+        if (confirmed) {
+          if (!removeVolume(pgVolume)) {
+            ui.error(`Failed to remove volume ${pgVolume}. Is the container still running?`);
+            process.exit(1);
+          }
+          ui.success(`Volume ${pgVolume} removed \u2014 will be reinitialised with the new password.`);
+        } else {
+          ui.info("Reset cancelled \u2014 keeping existing volume. Enter the original password below.");
+        }
+      }
+    }
+    const pgPass = await (0, import_prompts.input)({
+      message: "PostgreSQL password (POSTGRES_PASSWORD, min 8 chars):",
+      validate: (v) => v.length >= 8 || "Minimum 8 characters"
+    });
+    envVars["POSTGRES_PASSWORD"] = pgPass;
+    envVars["DATABASE_URL"] = `postgresql://syncup:${pgPass}@postgres:5432/ui_syncup`;
+    envVars["DIRECT_URL"] = envVars["DATABASE_URL"];
+  } else {
+    envVars["DATABASE_URL"] = await (0, import_prompts.input)({
+      message: "DATABASE_URL (postgresql://...):",
+      validate: (v) => v.startsWith("postgres") || "Must be a PostgreSQL URL"
+    });
+    envVars["DIRECT_URL"] = await (0, import_prompts.input)({
+      message: "DIRECT_URL (non-pooled, for migrations):",
+      default: envVars["DATABASE_URL"]
+    });
+  }
+  const cacheChoice = await (0, import_prompts.select)({
+    message: "Cache backend:",
+    choices: [
+      { name: "Bundled Redis (recommended)", value: "bundled" },
+      { name: "External (Upstash / Redis Cloud)", value: "external" }
+    ]
+  });
+  if (cacheChoice === "bundled") {
+    profiles.push("cache");
+    envVars["REDIS_URL"] = "redis://redis:6379";
+  } else {
+    envVars["REDIS_URL"] = await (0, import_prompts.input)({
+      message: "REDIS_URL (redis://...):",
+      validate: (v) => v.startsWith("redis") || "Must be a Redis URL"
+    });
+  }
+  const storageChoice = await (0, import_prompts.select)({
+    message: "Storage backend:",
+    choices: [
+      { name: "Bundled MinIO (recommended)", value: "bundled" },
+      { name: "External S3 (AWS / R2 / Backblaze)", value: "external" }
+    ]
+  });
+  if (storageChoice === "bundled") {
+    profiles.push("storage");
+    const minioUser = await (0, import_prompts.input)({ message: "MinIO root username:", default: "minioadmin" });
+    const minioPass = await (0, import_prompts.input)({
+      message: "MinIO root password (min 8 chars):",
+      validate: (v) => v.length >= 8 || "Minimum 8 characters"
+    });
+    envVars["MINIO_ROOT_USER"] = minioUser;
+    envVars["MINIO_ROOT_PASSWORD"] = minioPass;
+    envVars["STORAGE_ENDPOINT"] = "http://minio:9000";
+    envVars["STORAGE_REGION"] = "us-east-1";
+    envVars["STORAGE_ACCESS_KEY_ID"] = minioUser;
+    envVars["STORAGE_SECRET_ACCESS_KEY"] = minioPass;
+    envVars["STORAGE_ATTACHMENTS_BUCKET"] = "ui-syncup-attachments";
+    envVars["STORAGE_MEDIA_BUCKET"] = "ui-syncup-media";
+    envVars["STORAGE_ATTACHMENTS_PUBLIC_URL"] = `${appUrl}/storage/attachments`;
+    envVars["STORAGE_MEDIA_PUBLIC_URL"] = `${appUrl}/storage/media`;
+  } else {
+    envVars["STORAGE_ENDPOINT"] = await (0, import_prompts.input)({ message: "Storage endpoint URL:" });
+    envVars["STORAGE_ACCESS_KEY_ID"] = await (0, import_prompts.input)({ message: "Storage access key ID:" });
+    envVars["STORAGE_SECRET_ACCESS_KEY"] = await (0, import_prompts.input)({ message: "Storage secret access key:" });
+  }
+  const emailChoice = await (0, import_prompts.select)({
+    message: "Email provider:",
+    choices: [
+      { name: "Resend (recommended for production)", value: "resend" },
+      { name: "SMTP \u2014 custom server (SendGrid, Postmark, etc.)", value: "smtp" },
+      { name: "Mailpit \u2014 bundled SMTP catcher (dev/test only)", value: "mailpit" },
+      { name: "Skip for now", value: "skip" }
+    ]
+  });
+  if (emailChoice === "resend") {
+    envVars["RESEND_API_KEY"] = await (0, import_prompts.input)({ message: "Resend API key:" });
+    envVars["RESEND_FROM_EMAIL"] = await (0, import_prompts.input)({ message: "From email address:" });
+  } else if (emailChoice === "smtp") {
+    envVars["SMTP_HOST"] = await (0, import_prompts.input)({ message: "SMTP host:" });
+    envVars["SMTP_PORT"] = await (0, import_prompts.input)({ message: "SMTP port:", default: "587" });
+    envVars["SMTP_USER"] = await (0, import_prompts.input)({ message: "SMTP username:" });
+    envVars["SMTP_PASSWORD"] = await (0, import_prompts.input)({ message: "SMTP password:" });
+    envVars["SMTP_FROM_EMAIL"] = await (0, import_prompts.input)({ message: "From email:" });
+    envVars["SMTP_SECURE"] = await (0, import_prompts.input)({ message: "TLS? (true/false):", default: "true" });
+  } else if (emailChoice === "mailpit") {
+    profiles.push("mail");
+    envVars["SMTP_HOST"] = "mailpit";
+    envVars["SMTP_PORT"] = "1025";
+    envVars["SMTP_USER"] = "user";
+    envVars["SMTP_PASSWORD"] = "password";
+    envVars["SMTP_FROM_EMAIL"] = "noreply@localhost.com";
+    envVars["SMTP_SECURE"] = "false";
+  }
+  envVars["COMPOSE_PROFILES"] = profiles.join(",");
+  ui.step(5, 6, "Writing .env...");
+  writeEnv(".env", envVars);
+  ui.success(".env written (permissions: 0600)");
+  ui.step(6, 6, "Starting UI SyncUp...");
+  const result = runCompose("compose.yml", ["up", "-d"], profiles);
+  if (!result.success) {
+    ui.error("docker compose up failed \u2014 check logs with: docker compose logs app");
+    process.exit(1);
+  }
+  ui.success("UI SyncUp is running!");
+  ui.info(`Open: ${appUrl}`);
+  if (profiles.includes("mail")) {
+    ui.info("Mailpit inbox: http://localhost:8025");
+  }
+  if (profiles.length > 0) {
+    ui.info(`Active profiles: ${profiles.join(", ")}`);
+  }
+}
+
+// src/commands/start.ts
+var import_node_fs3 = require("fs");
+async function startCommand(composeFile) {
+  ui.header("UI SyncUp \u2014 Start");
+  if (!isDockerRunning()) {
+    ui.error("Docker is not running.");
+    process.exit(1);
+  }
+  const profiles = (0, import_node_fs3.existsSync)(".env") ? (parseEnv(".env")["COMPOSE_PROFILES"] ?? "").split(",").filter(Boolean) : [];
+  ui.info("Starting stack...");
+  const result = runCompose(composeFile, ["up", "-d"], profiles);
+  if (!result.success) {
+    ui.error("Failed to start stack \u2014 check logs with: ui-syncup logs");
+    process.exit(1);
+  }
+  ui.success("Stack is running.");
+}
+
+// src/commands/stop.ts
+async function stopCommand(composeFile) {
+  ui.header("UI SyncUp \u2014 Stop");
+  if (!isDockerRunning()) {
+    ui.error("Docker is not running.");
+    process.exit(1);
+  }
+  ui.info("Stopping stack...");
+  const result = runCompose(composeFile, ["stop"]);
+  if (!result.success) {
+    ui.error("Failed to stop stack");
+    process.exit(1);
+  }
+  ui.success("Stack stopped. Data preserved \u2014 run: ui-syncup start to resume.");
+}
+
+// src/commands/restart.ts
+async function restartCommand(composeFile, service) {
+  ui.header("UI SyncUp \u2014 Restart");
+  if (!isDockerRunning()) {
+    ui.error("Docker is not running.");
+    process.exit(1);
+  }
+  const args = service ? ["restart", service] : ["restart"];
+  ui.info(service ? `Restarting ${service}...` : "Restarting all services...");
+  const result = runCompose(composeFile, args);
+  if (!result.success) {
+    ui.error("Restart failed");
+    process.exit(1);
+  }
+  ui.success("Restart complete.");
+}
+
+// src/commands/status.ts
+var import_node_child_process3 = require("child_process");
+var import_node_fs4 = require("fs");
+async function statusCommand(composeFile) {
+  if (!isDockerRunning()) {
+    ui.error("Docker is not running.");
+    process.exit(1);
+  }
+  if (!(0, import_node_fs4.existsSync)(composeFile)) {
+    ui.error(`Compose file not found: ${composeFile}. Run: ui-syncup init`);
+    process.exit(1);
+  }
+  (0, import_node_child_process3.spawnSync)("docker", ["compose", "-f", composeFile, "ps"], { stdio: "inherit" });
+  const vars = (0, import_node_fs4.existsSync)(".env") ? parseEnv(".env") : {};
+  const port = vars["PORT"] || "3000";
+  const appUrl = vars["NEXT_PUBLIC_APP_URL"] || `http://localhost:${port}`;
+  console.log("");
+  ui.info(`App \u2192 ${appUrl}`);
+}
+
+// src/commands/logs.ts
+var import_node_child_process4 = require("child_process");
+var import_node_fs5 = require("fs");
+async function logsCommand(composeFile, service, follow) {
+  if (!isDockerRunning()) {
+    ui.error("Docker is not running.");
+    process.exit(1);
+  }
+  if (!(0, import_node_fs5.existsSync)(composeFile)) {
+    ui.error(`Compose file not found: ${composeFile}. Run: ui-syncup init`);
+    process.exit(1);
+  }
+  const args = ["compose", "-f", composeFile, "logs", "--tail=200"];
+  if (follow) args.push("--follow");
+  if (service) args.push(service);
+  (0, import_node_child_process4.spawnSync)("docker", args, { stdio: "inherit" });
+}
+
+// src/commands/upgrade.ts
+var import_ora = __toESM(require("ora"));
+async function upgradeCommand(composeFile) {
+  ui.header("UI SyncUp \u2014 Upgrade");
+  if (!isDockerRunning()) {
+    ui.error("Docker is not running.");
+    process.exit(1);
+  }
+  const pull = (0, import_ora.default)("Pulling latest image...").start();
+  const pullResult = runCompose(composeFile, ["pull"], [], true);
+  if (!pullResult.success) {
+    pull.fail("docker compose pull failed");
+    process.exit(1);
+  }
+  pull.succeed("Latest image pulled");
+  const up = (0, import_ora.default)("Restarting stack (migrations run automatically)...").start();
+  const upResult = runCompose(composeFile, ["up", "-d", "--remove-orphans"], [], true);
+  if (!upResult.success) {
+    up.fail("Stack restart failed \u2014 check logs with: ui-syncup logs");
+    process.exit(1);
+  }
+  up.succeed("Upgrade complete. Migrations applied.");
+}
+
+// src/commands/backup.ts
+var import_node_child_process5 = require("child_process");
+var import_node_fs6 = require("fs");
+var import_node_path = require("path");
+var import_ora2 = __toESM(require("ora"));
+async function backupCommand(composeFile, outputDir) {
+  ui.header("UI SyncUp \u2014 Backup");
+  if (!isDockerRunning()) {
+    ui.error("Docker is not running.");
+    process.exit(1);
+  }
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const label = `ui-syncup-backup-${timestamp}`;
+  const backupDir = (0, import_node_path.resolve)(outputDir, label);
+  (0, import_node_fs6.mkdirSync)(backupDir, { recursive: true });
+  const vars = (0, import_node_fs6.existsSync)(".env") ? parseEnv(".env") : {};
+  const profiles = (vars["COMPOSE_PROFILES"] ?? "").split(",").filter(Boolean);
+  let backedUp = false;
+  if (profiles.includes("db")) {
+    const spinner = (0, import_ora2.default)("Dumping PostgreSQL...").start();
+    try {
+      const dump = (0, import_node_child_process5.execSync)(
+        `docker compose -f ${composeFile} exec -T postgres pg_dumpall -U postgres`,
+        { encoding: "utf-8", maxBuffer: 256 * 1024 * 1024 }
+      );
+      (0, import_node_fs6.writeFileSync)(`${backupDir}/postgres.sql`, dump);
+      spinner.succeed("PostgreSQL dump saved");
+      backedUp = true;
+    } catch {
+      spinner.fail("PostgreSQL backup failed \u2014 is the db container running?");
+    }
+  } else {
+    ui.info("Skipping PostgreSQL (db profile not active)");
+  }
+  if (profiles.includes("storage")) {
+    const spinner = (0, import_ora2.default)("Exporting MinIO volume...").start();
+    const result = (0, import_node_child_process5.spawnSync)("docker", [
+      "run",
+      "--rm",
+      "-v",
+      "ui-syncup_minio_data:/volume",
+      "-v",
+      `${backupDir}:/backup`,
+      "alpine",
+      "tar",
+      "czf",
+      "/backup/minio_data.tar.gz",
+      "-C",
+      "/volume",
+      "."
+    ], { stdio: "pipe" });
+    if (result.status === 0) {
+      spinner.succeed("MinIO volume exported");
+      backedUp = true;
+    } else {
+      spinner.fail("MinIO backup failed \u2014 is the storage profile running?");
+    }
+  } else {
+    ui.info("Skipping MinIO (storage profile not active)");
+  }
+  if (!backedUp) {
+    ui.warn("No data services active. Set COMPOSE_PROFILES=db,storage in .env to enable backups.");
+    (0, import_node_fs6.rmSync)(backupDir, { recursive: true });
+    return;
+  }
+  const archiving = (0, import_ora2.default)("Archiving...").start();
+  const archivePath = (0, import_node_path.resolve)(outputDir, `${label}.tar.gz`);
+  (0, import_node_child_process5.spawnSync)("tar", ["-czf", archivePath, "-C", (0, import_node_path.resolve)(outputDir), label], { stdio: "pipe" });
+  (0, import_node_fs6.rmSync)(backupDir, { recursive: true });
+  archiving.succeed(`Backup saved \u2192 ${archivePath}`);
+  console.log("");
+  ui.info(`To restore: ui-syncup restore ${archivePath}`);
+}
+
+// src/commands/restore.ts
+var import_node_child_process6 = require("child_process");
+var import_node_fs7 = require("fs");
+var import_node_path2 = require("path");
+var import_prompts2 = require("@inquirer/prompts");
+var import_ora3 = __toESM(require("ora"));
+async function restoreCommand(composeFile, archivePath) {
+  ui.header("UI SyncUp \u2014 Restore");
+  if (!isDockerRunning()) {
+    ui.error("Docker is not running.");
+    process.exit(1);
+  }
+  const resolvedArchive = (0, import_node_path2.resolve)(archivePath);
+  if (!(0, import_node_fs7.existsSync)(resolvedArchive)) {
+    ui.error(`Archive not found: ${resolvedArchive}`);
+    process.exit(1);
+  }
+  ui.warn("Restore will overwrite current data. The app container will be stopped briefly.");
+  const confirmed = await (0, import_prompts2.confirm)({ message: "Continue with restore?" });
+  if (!confirmed) {
+    ui.info("Aborted.");
+    return;
+  }
+  const tmpDir = `/tmp/ui-syncup-restore-${Date.now()}`;
+  (0, import_node_fs7.mkdirSync)(tmpDir, { recursive: true });
+  const extractSpinner = (0, import_ora3.default)("Extracting archive...").start();
+  const extractResult = (0, import_node_child_process6.spawnSync)("tar", ["-xzf", resolvedArchive, "-C", tmpDir]);
+  if (extractResult.status !== 0) {
+    extractSpinner.fail("Failed to extract archive");
+    (0, import_node_fs7.rmSync)(tmpDir, { recursive: true });
+    process.exit(1);
+  }
+  extractSpinner.succeed("Archive extracted");
+  const entries = (0, import_node_fs7.readdirSync)(tmpDir);
+  const backupDir = (0, import_node_path2.join)(tmpDir, entries[0]);
+  const vars = (0, import_node_fs7.existsSync)(".env") ? parseEnv(".env") : {};
+  const profiles = (vars["COMPOSE_PROFILES"] ?? "").split(",").filter(Boolean);
+  const stopSpinner = (0, import_ora3.default)("Stopping app container...").start();
+  runCompose(composeFile, ["stop", "app"], [], true);
+  stopSpinner.succeed("App container stopped");
+  const sqlFile = (0, import_node_path2.join)(backupDir, "postgres.sql");
+  if ((0, import_node_fs7.existsSync)(sqlFile) && profiles.includes("db")) {
+    const spinner = (0, import_ora3.default)("Restoring PostgreSQL...").start();
+    const result = (0, import_node_child_process6.spawnSync)(
+      "bash",
+      ["-c", `docker compose -f ${composeFile} exec -T postgres psql -U postgres < "${sqlFile}"`],
+      { stdio: "pipe" }
+    );
+    if (result.status === 0) {
+      spinner.succeed("PostgreSQL restored");
+    } else {
+      spinner.fail("PostgreSQL restore failed \u2014 check: ui-syncup logs postgres");
+    }
+  }
+  const minioArchive = (0, import_node_path2.join)(backupDir, "minio_data.tar.gz");
+  if ((0, import_node_fs7.existsSync)(minioArchive) && profiles.includes("storage")) {
+    const spinner = (0, import_ora3.default)("Restoring MinIO volume...").start();
+    (0, import_node_child_process6.spawnSync)("docker", [
+      "run",
+      "--rm",
+      "-v",
+      "ui-syncup_minio_data:/volume",
+      "-v",
+      `${backupDir}:/backup`,
+      "alpine",
+      "sh",
+      "-c",
+      "tar xzf /backup/minio_data.tar.gz -C /volume"
+    ], { stdio: "pipe" });
+    spinner.succeed("MinIO volume restored");
+  }
+  (0, import_node_fs7.rmSync)(tmpDir, { recursive: true });
+  const restartSpinner = (0, import_ora3.default)("Restarting stack...").start();
+  runCompose(composeFile, ["up", "-d"], [], true);
+  restartSpinner.succeed("Stack restarted");
+  console.log("");
+  ui.success("Restore complete.");
+}
+
+// src/commands/open.ts
+var import_node_child_process7 = require("child_process");
+var import_node_fs8 = require("fs");
+async function openCommand() {
+  const vars = (0, import_node_fs8.existsSync)(".env") ? parseEnv(".env") : {};
+  const port = vars["PORT"] || "3000";
+  const url = vars["NEXT_PUBLIC_APP_URL"] || `http://localhost:${port}`;
+  ui.info(`Opening ${url}...`);
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+  try {
+    (0, import_node_child_process7.execSync)(`${cmd} "${url}"`, { stdio: "ignore" });
+  } catch {
+    ui.warn(`Could not open browser automatically. Visit: ${url}`);
+  }
+}
+
+// src/commands/remove.ts
+var import_prompts3 = require("@inquirer/prompts");
+async function removeCommand(composeFile, withVolumes) {
+  ui.header("UI SyncUp \u2014 Remove");
+  if (!isDockerRunning()) {
+    ui.error("Docker is not running.");
+    process.exit(1);
+  }
+  if (withVolumes) {
+    ui.warn("This permanently deletes ALL data: database, storage, and cache volumes.");
+  } else {
+    ui.warn("This stops and removes containers. Data volumes will be preserved.");
+  }
+  const confirmed = await (0, import_prompts3.confirm)({
+    message: withVolumes ? "Delete all data and remove the stack?" : "Remove the stack (keep data volumes)?"
+  });
+  if (!confirmed) {
+    ui.info("Aborted.");
+    return;
+  }
+  const args = ["down"];
+  if (withVolumes) args.push("--volumes");
+  const result = runCompose(composeFile, args);
+  if (!result.success) {
+    ui.error("Remove failed");
+    process.exit(1);
+  }
+  ui.success(
+    withVolumes ? "Stack and all data removed." : "Stack removed. Data volumes preserved. Run: ui-syncup start to restart."
+  );
+}
+
+// src/commands/doctor.ts
+var import_node_child_process8 = require("child_process");
+var import_node_fs9 = require("fs");
+async function doctorCommand() {
+  ui.header("UI SyncUp \u2014 Doctor");
+  let allGood = true;
+  ui.info("Checking Docker daemon...");
+  if (isDockerRunning()) {
+    ui.success("Docker is running");
+  } else {
+    ui.error("Docker is not running");
+    allGood = false;
+  }
+  ui.info("Checking .env required variables...");
+  if (!(0, import_node_fs9.existsSync)(".env")) {
+    ui.error(".env not found. Run: npx ui-syncup init");
+    allGood = false;
+  } else {
+    const vars = parseEnv(".env");
+    const missing = getMissingVars(vars);
+    if (missing.length === 0) {
+      ui.success("All required env vars present");
+    } else {
+      for (const k of missing) {
+        ui.error(`Missing: ${k} \u2014 see ${ENV_EXAMPLE_URL}`);
+      }
+      allGood = false;
+    }
+  }
+  ui.info("Checking /api/health...");
+  try {
+    const vars = (0, import_node_fs9.existsSync)(".env") ? parseEnv(".env") : {};
+    const appUrl = vars["NEXT_PUBLIC_APP_URL"] || "http://localhost:3000";
+    const raw = (0, import_node_child_process8.execSync)(`curl -sf "${appUrl}/api/health"`, {
+      encoding: "utf-8",
+      timeout: 5e3
+    });
+    const json = JSON.parse(raw);
+    if (json.status === "ok") {
+      ui.success(`Health OK \u2014 version: ${json.version}`);
+    } else {
+      ui.warn(`Health returned status: ${json.status}`);
+    }
+  } catch {
+    ui.error("Health endpoint unreachable \u2014 is the stack running?");
+    allGood = false;
+  }
+  ui.info("Checking disk space...");
+  try {
+    const dfOut = (0, import_node_child_process8.execSync)("df -k . | awk 'NR==2{print $4}'", {
+      encoding: "utf-8"
+    }).trim();
+    const freeGB = parseInt(dfOut, 10) / 1024 / 1024;
+    if (freeGB >= 2) {
+      ui.success(`Disk space OK \u2014 ${freeGB.toFixed(1)} GB free`);
+    } else {
+      ui.warn(`Low disk space \u2014 ${freeGB.toFixed(1)} GB free (recommend >= 2 GB)`);
+      allGood = false;
+    }
+  } catch {
+    ui.warn("Could not check disk space");
+  }
+  console.log("");
+  if (allGood) {
+    ui.success("All checks passed.");
+  } else {
+    ui.error("Some checks failed \u2014 see above.");
+    process.exit(1);
+  }
+}
+
+// index.ts
+var { version: version2 } = require_package();
+var DEFAULT_COMPOSE = "compose.yml";
+var program = new import_commander.Command().name("ui-syncup").description("Self-host UI SyncUp with a single command").version(version2);
+program.command("init").description("Guided setup: download compose file, configure services, start the stack").action(initCommand);
+program.command("start").description("Start the stack (reads COMPOSE_PROFILES from .env)").option("-f, --file <path>", "Path to compose file", DEFAULT_COMPOSE).action(({ file }) => startCommand(file));
+program.command("stop").description("Stop the stack gracefully (data is preserved)").option("-f, --file <path>", "Path to compose file", DEFAULT_COMPOSE).action(({ file }) => stopCommand(file));
+program.command("restart [service]").description("Restart all services or a single one (app|postgres|redis|minio)").option("-f, --file <path>", "Path to compose file", DEFAULT_COMPOSE).action((service, { file }) => restartCommand(file, service));
+program.command("status").description("Show container states, health, and app URL").option("-f, --file <path>", "Path to compose file", DEFAULT_COMPOSE).action(({ file }) => statusCommand(file));
+program.command("logs [service]").description("Tail logs for all services or a single one (app|postgres|redis|minio)").option("-f, --file <path>", "Path to compose file", DEFAULT_COMPOSE).option("-F, --follow", "Stream logs (Ctrl+C to stop)", false).action((service, { file, follow }) => logsCommand(file, service, follow));
+program.command("upgrade").description("Pull latest image and restart the stack (migrations run automatically)").option("-f, --file <path>", "Path to compose file", DEFAULT_COMPOSE).action(({ file }) => upgradeCommand(file));
+program.command("backup").description("Dump PostgreSQL and MinIO to a timestamped .tar.gz archive").option("-f, --file <path>", "Path to compose file", DEFAULT_COMPOSE).option("-o, --output <dir>", "Directory to write the archive into", ".").action(({ file, output }) => backupCommand(file, output));
+program.command("restore <archive>").description("Restore from a backup archive (stops app briefly during restore)").option("-f, --file <path>", "Path to compose file", DEFAULT_COMPOSE).action((archive, { file }) => restoreCommand(file, archive));
+program.command("open").description("Open the app in your default browser").action(openCommand);
+program.command("remove").description("Remove containers (add --volumes to also wipe all data)").option("-f, --file <path>", "Path to compose file", DEFAULT_COMPOSE).option("--volumes", "Also delete all data volumes (irreversible)", false).action(({ file, volumes }) => removeCommand(file, volumes));
+program.command("doctor").description("Validate environment, service health, and disk space").action(doctorCommand);
+program.parse();

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "ui-syncup-cli",
+  "version": "0.4.0-beta.6",
+  "description": "Self-host UI SyncUp with a single command",
+  "bin": {
+    "ui-syncup": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "@inquirer/prompts": "^8.0.0",
+    "chalk": "^5.3.0",
+    "ora": "^8.0.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT"
+}