easy-vps 0.1.1 → 0.1.2

package/bin/cli.js

@@ -160,6 +160,29 @@ async function main() {
       break
   }
 
+  // `npx easy-vps` / `easy-vps` with no subcommand: show the animated installer,
+  // then start the panel in the background so it survives a closed terminal.
+  if (!options.command) {
+    try {
+      await app.runInstaller({ port, host })
+    } catch (error) {
+      console.error(`installer error (continuing): ${error.message}`)
+    }
+
+    const mode = await daemon.start({ port, host })
+    const state = await daemon.status()
+    if (!state.running) {
+      console.error(`easy-vps did not start — ${state.detail}`)
+      process.exit(1)
+    }
+
+    console.log(`\n  easy-vps v${app.version()} — started (${mode})\n`)
+    printUrls(port)
+    console.log('\n  The panel is running in the background and will keep running')
+    console.log('  after this terminal is closed. Manage it with: status | stop | logs\n')
+    process.exit(0)
+  }
+
   let server
   try {
     server = await app.startServer({ port, host })

package/dist/index.d.ts

@@ -20,3 +20,5 @@ export * as instances from './services/instances';
 export * as logs from './services/logs';
 export * as firewall from './services/firewall';
 export * as backupScheduler from './services/backup-scheduler';
+export * as installer from './services/installer';
+export { runInstaller } from './services/installer';

package/dist/index.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.backupScheduler = exports.firewall = exports.logs = exports.instances = exports.database = exports.deploy = exports.domain = exports.system = exports.auth = exports.DEFAULT_HOST = exports.DEFAULT_PORT = void 0;
+exports.runInstaller = exports.installer = exports.backupScheduler = exports.firewall = exports.logs = exports.instances = exports.database = exports.deploy = exports.domain = exports.system = exports.auth = exports.DEFAULT_HOST = exports.DEFAULT_PORT = void 0;
 exports.clientDir = clientDir;
 exports.createApp = createApp;
 exports.startServer = startServer;
@@ -141,3 +141,6 @@ exports.instances = __importStar(require("./services/instances"));
 exports.logs = __importStar(require("./services/logs"));
 exports.firewall = __importStar(require("./services/firewall"));
 exports.backupScheduler = __importStar(require("./services/backup-scheduler"));
+exports.installer = __importStar(require("./services/installer"));
+var installer_1 = require("./services/installer");
+Object.defineProperty(exports, "runInstaller", { enumerable: true, get: function () { return installer_1.runInstaller; } });

package/dist/services/daemon.js

@@ -74,7 +74,7 @@ After=network.target
 
 [Service]
 Type=simple
-ExecStart=${process.execPath} ${cliPath()} --port ${options.port} --host ${options.host}
+ExecStart=${process.execPath} ${cliPath()} run --port ${options.port} --host ${options.host}
 Restart=on-failure
 RestartSec=5
 Environment=NODE_ENV=production
@@ -93,7 +93,7 @@ async function startSystemd(options) {
 /** Fallback: fully detached child that outlives the parent shell. */
 function startProcess(options) {
     const out = (0, node_fs_1.openSync)(logPath(), 'a');
-    const child = (0, node_child_process_1.spawn)(process.execPath, [cliPath(), '--port', String(options.port), '--host', options.host], { detached: true, stdio: ['ignore', out, out] });
+    const child = (0, node_child_process_1.spawn)(process.execPath, [cliPath(), 'run', '--port', String(options.port), '--host', options.host], { detached: true, stdio: ['ignore', out, out] });
     child.unref();
     (0, node_fs_1.writeFileSync)(pidPath(), String(child.pid), 'utf8');
     return child.pid;

package/dist/services/installer.d.ts

@@ -0,0 +1,13 @@
+export interface InstallerOptions {
+    port: number;
+    host: string;
+}
+/**
+ * Runs the animated "installing packages" step. Never throws: a failed install
+ * degrades to a warning and the caller still starts the panel.
+ */
+export declare function runInstaller(options: InstallerOptions): Promise<void>;
+declare const _default: {
+    runInstaller: typeof runInstaller;
+};
+export default _default;

package/dist/services/installer.js

@@ -0,0 +1,140 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInstaller = runInstaller;
+// Animated installer: detects and installs the system packages easy-vps needs to
+// operate as a VPS control panel (nginx, certbot, ufw, docker, postgres, pm2),
+// then hands off to the daemon so the panel keeps running after the terminal closes.
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_util_1 = require("node:util");
+const spinner_1 = require("./spinner");
+const run = (0, node_util_1.promisify)(node_child_process_1.execFile);
+function isRoot() {
+    return typeof process.getuid === 'function' && process.getuid() === 0;
+}
+function stateDir() {
+    const dir = isRoot() ? '/var/lib/easy-vps' : node_path_1.default.join(node_os_1.default.homedir(), '.easy-vps');
+    (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    return dir;
+}
+// Packages easy-vps orchestrates. Node is required (already provided by the
+// runtime running this script); the rest enable their respective panel features.
+const PACKAGES = [
+    { name: 'Node.js', bin: 'node', manager: 'apt', pkg: 'nodejs', required: true, note: 'runtime' },
+    { name: 'nginx', bin: 'nginx', manager: 'apt', pkg: 'nginx', note: 'domains & reverse proxy' },
+    { name: 'certbot', bin: 'certbot', manager: 'apt', pkg: 'certbot', note: 'free HTTPS' },
+    { name: 'ufw', bin: 'ufw', manager: 'apt', pkg: 'ufw', note: 'firewall' },
+    { name: 'docker', bin: 'docker', manager: 'apt', pkg: 'docker.io', note: 'app deployment' },
+    { name: 'postgresql', bin: 'psql', manager: 'apt', pkg: 'postgresql', note: 'managed databases' },
+    { name: 'pm2', bin: 'pm2', manager: 'npm', pkg: 'pm2', note: 'node deployment' },
+];
+async function hasBinary(bin) {
+    try {
+        await run('command', ['-v', bin]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function sudoPrefix() {
+    if (isRoot())
+        return [];
+    // Only use sudo when it is actually available; otherwise the install steps warn.
+    if (await hasBinary('sudo'))
+        return ['sudo'];
+    return [];
+}
+async function aptUpdate(prefix) {
+    await run(prefix[0] ?? 'apt-get', [...(prefix[0] ? [] : []), 'apt-get', 'update', '-y'], {
+        shell: false,
+    });
+}
+async function installApt(pkg, prefix) {
+    const cmd = prefix.concat(['apt-get', 'install', '-y', pkg.pkg]);
+    await run(cmd[0], cmd.slice(1), { shell: false });
+}
+async function installNpm(pkg, prefix) {
+    const cmd = prefix.concat(['npm', 'install', '-g', pkg.pkg]);
+    await run(cmd[0], cmd.slice(1), { shell: false });
+}
+/**
+ * Runs the animated "installing packages" step. Never throws: a failed install
+ * degrades to a warning and the caller still starts the panel.
+ */
+async function runInstaller(options) {
+    const marker = node_path_1.default.join(stateDir(), '.installed');
+    const skipInstall = process.env.EASY_VPS_NO_INSTALL === '1' || process.env.EASY_VPS_NO_INSTALL === 'true';
+    const reinstall = process.env.EASY_VPS_REINSTALL === '1' || process.env.EASY_VPS_REINSTALL === 'true';
+    // Header
+    process.stdout.write(`\n  ${'easy-vps installer'}\n\n`);
+    if (skipInstall) {
+        process.stdout.write('  install step skipped (EASY_VPS_NO_INSTALL set)\n\n');
+    }
+    else if ((0, node_fs_1.existsSync)(marker) && !reinstall) {
+        process.stdout.write('  dependencies already installed — starting panel\n\n');
+        return;
+    }
+    const prefix = await sudoPrefix();
+    const needApt = PACKAGES.filter((p) => p.manager === 'apt' && !skipInstall);
+    const needNpm = PACKAGES.filter((p) => p.manager === 'npm' && !skipInstall);
+    // Refresh the apt index once if any apt package is missing.
+    if (needApt.length) {
+        const missingApt = [];
+        for (const p of needApt) {
+            if (!(await hasBinary(p.bin)))
+                missingApt.push(p);
+        }
+        if (missingApt.length) {
+            const spinner = new spinner_1.Spinner('updating package index');
+            spinner.start();
+            try {
+                await aptUpdate(prefix);
+                spinner.succeed('package index updated');
+            }
+            catch (error) {
+                spinner.warn(`could not update index (${error.message.split('\n')[0]})`);
+            }
+        }
+    }
+    // Install each package, animating as we go.
+    for (const pkg of PACKAGES) {
+        if (skipInstall)
+            break;
+        const spinner = new spinner_1.Spinner(`installing ${pkg.name}`);
+        spinner.start();
+        try {
+            if (await hasBinary(pkg.bin)) {
+                spinner.succeed(pkg.note ?? 'already installed');
+                continue;
+            }
+            if (pkg.manager === 'apt')
+                await installApt(pkg, prefix);
+            else
+                await installNpm(pkg, prefix);
+            spinner.succeed(pkg.note ?? 'installed');
+        }
+        catch (error) {
+            const detail = error.message.split('\n')[0];
+            if (pkg.required) {
+                spinner.warn(`not available (${detail})`);
+            }
+            else {
+                spinner.warn(`skipped (${detail})`);
+            }
+        }
+    }
+    process.stdout.write('\n');
+    try {
+        (0, node_fs_1.writeFileSync)(marker, `${new Date().toISOString()}\nport=${options.port} host=${options.host}\n`, 'utf8');
+    }
+    catch {
+        // marker is best-effort
+    }
+}
+exports.default = { runInstaller };

package/dist/services/spinner.d.ts

@@ -0,0 +1,21 @@
+export declare class Spinner {
+    private fd;
+    private readonly color;
+    private readonly bold;
+    private readonly dim;
+    private readonly green;
+    private readonly yellow;
+    private readonly reset;
+    private readonly clear;
+    private timer;
+    private frame;
+    private readonly label;
+    constructor(label: string);
+    private write;
+    private render;
+    start(): this;
+    private stop;
+    succeed(detail?: string): void;
+    warn(detail?: string): void;
+    close(): void;
+}

package/dist/services/spinner.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Spinner = void 0;
+// Animated terminal spinner for the install flow.
+//
+// `npx` may pipe the child and hide stdout, so we write to the controlling
+// terminal (/dev/tty) when one exists and fall back to stdout otherwise.
+const node_fs_1 = require("node:fs");
+const ESC = String.fromCharCode(27);
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+function openTty() {
+    try {
+        return (0, node_fs_1.openSync)('/dev/tty', 'w');
+    }
+    catch {
+        return null;
+    }
+}
+class Spinner {
+    fd = null;
+    color;
+    bold;
+    dim;
+    green;
+    yellow;
+    reset;
+    clear;
+    timer = null;
+    frame = 0;
+    label;
+    constructor(label) {
+        this.fd = openTty();
+        this.color = this.fd !== null && !process.env.NO_COLOR;
+        this.bold = this.color ? `${ESC}[1m` : '';
+        this.dim = this.color ? `${ESC}[2m` : '';
+        this.green = this.color ? `${ESC}[32m` : '';
+        this.yellow = this.color ? `${ESC}[33m` : '';
+        this.reset = this.color ? `${ESC}[0m` : '';
+        this.clear = this.fd !== null ? `${ESC}[K` : '';
+        this.label = label;
+    }
+    write(text) {
+        try {
+            if (this.fd !== null)
+                (0, node_fs_1.writeSync)(this.fd, text);
+            else
+                process.stdout.write(text);
+        }
+        catch {
+            // terminal went away; nothing to do
+        }
+    }
+    render() {
+        const glyph = this.color ? FRAMES[this.frame % FRAMES.length] : '·';
+        this.write(`${this.clear}\r${this.dim}${glyph}${this.reset} ${this.label}`);
+        this.frame++;
+    }
+    start() {
+        this.render();
+        this.timer = setInterval(() => this.render(), 80);
+        if (this.timer.unref)
+            this.timer.unref();
+        return this;
+    }
+    stop(final) {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        this.write(`${this.clear}\r${final}\n`);
+    }
+    succeed(detail) {
+        const extra = detail ? ` ${this.dim}(${detail})${this.reset}` : '';
+        this.stop(`${this.green}✔${this.reset} ${this.label}${extra}`);
+    }
+    warn(detail) {
+        const extra = detail ? ` ${this.dim}(${detail})${this.reset}` : '';
+        this.stop(`${this.yellow}!${this.reset} ${this.label}${extra}`);
+    }
+    close() {
+        if (this.timer)
+            this.stop('');
+        if (this.fd !== null) {
+            try {
+                (0, node_fs_1.closeSync)(this.fd);
+            }
+            catch {
+                // ignore
+            }
+            this.fd = null;
+        }
+    }
+}
+exports.Spinner = Spinner;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "easy-vps",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Install dependencies, point domains, deploy apps and run Postgres on a VPS from one UI",
   "keywords": [
     "vps",