d3ployer 0.0.10 → 0.0.12

package/dist/runner.js

@@ -1,5 +1,5 @@
-import chalk from 'chalk';
 import { Listr } from 'listr2';
+import { CustomRenderer } from './renderer.js';
 import { spawn } from 'node:child_process';
 import { createSSHConnection } from './connection.js';
 import { Exception } from './utils/Exception.js';
@@ -148,32 +148,32 @@ function buildTaskContext(serverName, server, ssh, config) {
     };
 }
 export function resolveServers(config, serverNames) {
-    const allEntries = Object.entries(config.servers);
     if (!serverNames || serverNames.length === 0) {
-        return allEntries;
+        return config.servers;
     }
-    const result = [];
+    const result = {};
     for (const name of serverNames) {
         const server = config.servers[name];
         if (!server) {
             const available = Object.keys(config.servers).join(', ');
             throw new Exception(`Server "${name}" not found. Available: ${available}`, 1774742073310);
         }
-        result.push([name, server]);
+        result[name] = server;
     }
     return result;
 }
 export function resolveTaskDefs(taskNames, allTasks) {
-    return taskNames.map(name => {
+    return Object.fromEntries(taskNames
+        .map(name => {
         const def = allTasks[name];
         if (!def) {
             const available = Object.keys(allTasks).join(', ');
             throw new Exception(`Task "${name}" not found. Available: ${available}`, 1774742082083);
         }
         return [name, def];
-    });
+    }));
 }
-function buildServerListr(serverName, server, config, tasks) {
+function buildServerListr(serverName, server, config, tasks, skipTasks = []) {
     return new Listr([
         {
             task: async (ctx) => {
@@ -184,17 +184,21 @@ function buildServerListr(serverName, server, config, tasks) {
                 ctx.ph = buildPlaceholders(serverName, server);
             },
         },
-        ...tasks.map(([_key, taskDef]) => ({
-            title: chalk.bgCyan.black(` ${taskDef.name} `),
-            skip: taskDef.skip
-                ? (ctx) => {
-                    ctx.taskCtx.taskConfig = taskDef.config;
-                    return taskDef.skip(ctx.taskCtx, ctx.ph);
+        ...Object.entries(tasks)
+            .map(([key, taskDef]) => ({
+            title: taskDef.name,
+            skip: (ctx) => {
+                if (skipTasks.includes(key)) {
+                    return 'Skipped via --skip';
                 }
-                : undefined,
-            task: async (ctx) => {
                 ctx.taskCtx.taskConfig = taskDef.config;
-                return taskDef.task(ctx.taskCtx, ctx.ph);
+                return taskDef.skip
+                    ? taskDef.skip(ctx.taskCtx, ctx.ph)
+                    : false;
+            },
+            task: async (ctx, task) => {
+                ctx.taskCtx.taskConfig = taskDef.config;
+                return taskDef.task(ctx.taskCtx, ctx.ph, task);
             },
         })),
         {
@@ -206,10 +210,10 @@ function buildServerListr(serverName, server, config, tasks) {
         },
     ], {
         concurrent: false,
-        renderer: 'simple',
+        renderer: CustomRenderer,
     });
 }
-export async function runScenario(config, scenarioName, serverNames) {
+export async function runScenario(config, scenarioName, serverNames, options = {}) {
     const scenarioDef = config.scenarios?.[scenarioName];
     if (!scenarioDef) {
         const available = Object.keys(config.scenarios ?? {}).join(', ') || 'none';
@@ -218,16 +222,18 @@ export async function runScenario(config, scenarioName, serverNames) {
     const allTasks = config.tasks ?? {};
     const tasks = resolveTaskDefs(scenarioDef.tasks, allTasks);
     const servers = resolveServers(config, serverNames);
-    const listr = new Listr(servers.map(([name, server]) => ({
-        title: chalk.bgMagenta.black(` ${name} (${server.host}) `),
-        task: () => buildServerListr(name, server, config, tasks),
+    const skipTasks = options.skip ?? [];
+    const listr = new Listr(Object.entries(servers)
+        .map(([name, server]) => ({
+        title: `${scenarioDef.name} to ${name} (${server.host})`,
+        task: () => buildServerListr(name, server, config, tasks, skipTasks),
     })), {
         concurrent: false,
-        renderer: 'simple',
+        renderer: CustomRenderer,
     });
     await listr.run();
 }
-export async function runTask(config, taskName, serverNames) {
+export async function runTask(config, taskName, serverNames, options = {}) {
     const allTasks = config.tasks ?? {};
     const taskDef = allTasks[taskName];
     if (!taskDef) {
@@ -235,12 +241,14 @@ export async function runTask(config, taskName, serverNames) {
         throw new Exception(`Task "${taskName}" not found. Available: ${available}`, 1774742100356);
     }
     const servers = resolveServers(config, serverNames);
-    const listr = new Listr(servers.map(([name, server]) => ({
-        title: chalk.bgMagenta.black(` ${name} (${server.host}) `),
-        task: () => buildServerListr(name, server, config, [[taskName, taskDef]]),
+    const skipTasks = options.skip ?? [];
+    const listr = new Listr(Object.entries(servers)
+        .map(([name, server]) => ({
+        title: `${taskDef.name} to ${name} (${server.host})`,
+        task: () => buildServerListr(name, server, config, { [taskName]: taskDef }, skipTasks),
     })), {
         concurrent: false,
-        renderer: 'simple',
+        renderer: CustomRenderer,
     });
     await listr.run();
 }

package/dist/tasks/clearTarget.d.ts

@@ -0,0 +1,2 @@
+import type { TaskFn } from '../def.js';
+export declare const clearTargetTask: TaskFn;

package/dist/tasks/clearTarget.js

@@ -0,0 +1,15 @@
+import { ListrEnquirerPromptAdapter } from '@listr2/prompt-adapter-enquirer';
+import chalk from 'chalk';
+export const clearTargetTask = async (ctx, ph, task) => {
+    const confirmed = await task.prompt(ListrEnquirerPromptAdapter).run({
+        type: 'Confirm',
+        message: chalk.red(`Remove entire deploy path ${ph.deployPath} on ${ctx.server.host}?`),
+        initial: false,
+    });
+    console.log();
+    if (!confirmed) {
+        task.skip('User cancelled');
+        return;
+    }
+    await ctx.run(`rm -rf ${ph.deployPath}`);
+};

package/dist/tasks/download.d.ts

@@ -0,0 +1,3 @@
+import type { TaskFn, TaskSkipFn } from '../def.js';
+export declare const downloadSkip: TaskSkipFn;
+export declare const downloadTask: TaskFn;

package/dist/tasks/download.js

@@ -0,0 +1,27 @@
+import chalk from 'chalk';
+import path from 'node:path';
+import { Exception } from '../utils/index.js';
+import { buildRsyncCommand } from './upload.js';
+export const downloadSkip = (ctx) => {
+    const files = ctx.taskConfig;
+    return !files
+        ? 'No files configuration provided in task config'
+        : false;
+};
+export const downloadTask = async (ctx, ph) => {
+    const files = ctx.taskConfig;
+    if (!files) {
+        throw new Exception('No files configuration provided in task config', 1784523741234);
+    }
+    const localBase = files.basePath?.startsWith('/')
+        ? files.basePath
+        : path.resolve(ctx.config.rootDir, files.basePath ?? '.');
+    const remotePath = ph.deployPath;
+    const source = `${ctx.server.username}@${ctx.server.host}:${remotePath}/`;
+    const dest = localBase.endsWith('/') ? localBase : localBase + '/';
+    const command = buildRsyncCommand(ctx.server, source, dest, files, {
+        delete: false,
+    });
+    console.log(chalk.grey(command));
+    await ctx.runLocal(command);
+};

package/dist/tasks/index.d.ts

@@ -0,0 +1,6 @@
+import type { ScenarioDef, TaskDef } from '../def.js';
+export { buildRsyncCommand } from './upload.js';
+export type { RsyncOptions } from './upload.js';
+export { downloadSkip, downloadTask } from './download.js';
+export declare const defaultTasks: Record<string, TaskDef>;
+export declare const defaultScenarios: Record<string, ScenarioDef>;

package/dist/tasks/index.js

@@ -0,0 +1,76 @@
+import { clearTargetTask } from './clearTarget.js';
+import { downloadSkip, downloadTask } from './download.js';
+import { installPackagesSkip, installPackagesTask } from './installPackages.js';
+import { printDeploymentTask } from './printDeployment.js';
+import { printLogsDockerSkip, printLogsDockerTask, printLogsPm2Skip, printLogsPm2Task } from './printLogs.js';
+import { setupDockerSkip, setupDockerTask } from './setupDocker.js';
+import { setupPm2Skip, setupPm2Task } from './setupPm2.js';
+import { symlinksSkip, symlinksTask } from './symlinks.js';
+import { uploadSkip, uploadTask } from './upload.js';
+export { buildRsyncCommand } from './upload.js';
+export { downloadSkip, downloadTask } from './download.js';
+export const defaultTasks = {
+    'clear:target': {
+        name: 'Clear target',
+        task: clearTargetTask,
+    },
+    upload: {
+        name: 'Upload files',
+        skip: uploadSkip,
+        task: uploadTask,
+    },
+    download: {
+        name: 'Download files',
+        skip: downloadSkip,
+        task: downloadTask,
+    },
+    symlinks: {
+        name: 'Create symlinks',
+        skip: symlinksSkip,
+        task: symlinksTask,
+    },
+    'install:packages': {
+        name: 'Install packages',
+        skip: installPackagesSkip,
+        task: installPackagesTask,
+    },
+    'setup:pm2': {
+        name: 'PM2 setup',
+        skip: setupPm2Skip,
+        task: setupPm2Task,
+    },
+    'setup:docker': {
+        name: 'Docker Compose setup',
+        skip: setupDockerSkip,
+        task: setupDockerTask,
+    },
+    'print:deployment': {
+        name: 'Print deployment info',
+        task: printDeploymentTask,
+    },
+    'print:logs:pm2': {
+        name: 'Print PM2 logs',
+        skip: printLogsPm2Skip,
+        task: printLogsPm2Task,
+    },
+    'print:logs:docker': {
+        name: 'Print docker logs',
+        skip: printLogsDockerSkip,
+        task: printLogsDockerTask,
+    },
+};
+export const defaultScenarios = {
+    deploy: {
+        name: 'Deploy',
+        tasks: [
+            'upload',
+            'symlinks',
+            'install:packages',
+            'setup:pm2',
+            'setup:docker',
+            'print:deployment',
+            'print:logs:pm2',
+            'print:logs:docker',
+        ],
+    },
+};

package/dist/tasks/installPackages.d.ts

@@ -0,0 +1,3 @@
+import type { TaskFn, TaskSkipFn } from '../def.js';
+export declare const installPackagesSkip: TaskSkipFn;
+export declare const installPackagesTask: TaskFn;

package/dist/tasks/installPackages.js

@@ -0,0 +1,38 @@
+import { Exception } from '../utils/index.js';
+export const installPackagesSkip = (ctx) => {
+    if (ctx.server.packageManager !== undefined) {
+        return ctx.server.packageManager === false
+            ? 'Package manager disabled for server'
+            : false;
+    }
+    if (ctx.config.packageManager !== undefined) {
+        return ctx.config.packageManager === false
+            ? 'Package manager disabled in config'
+            : false;
+    }
+    return false;
+};
+export const installPackagesTask = async (ctx) => {
+    const config = {
+        manager: 'npm',
+        productionOnly: true,
+        ...ctx.config.packageManager,
+        ...ctx.server.packageManager,
+    };
+    let cmd = `${config.manager} install`;
+    if (config.productionOnly) {
+        if (config.manager === 'npm') {
+            cmd += ' --omit=dev';
+        }
+        else if (config.manager === 'yarn') {
+            cmd += ' --production';
+        }
+        else if (config.manager === 'pnpm') {
+            cmd += ' --prod';
+        }
+        else {
+            throw new Exception(`Unsupported package manager "${config.manager}"`, 1774823752134);
+        }
+    }
+    await ctx.run(cmd);
+};

package/dist/tasks/printDeployment.d.ts

@@ -0,0 +1,2 @@
+import type { TaskFn } from '../def.js';
+export declare const printDeploymentTask: TaskFn;

package/dist/tasks/printDeployment.js

@@ -0,0 +1,8 @@
+import chalk from 'chalk';
+export const printDeploymentTask = async (ctx, ph) => {
+    await ctx.run('date');
+    console.log(chalk.cyan('Deployment directory'), ph.deployPath);
+    await ctx.run('ls -la .');
+    console.log(chalk.cyan('Directory size'));
+    await ctx.run('du -hd 1 .');
+};

package/dist/tasks/printLogs.d.ts

@@ -0,0 +1,5 @@
+import type { TaskFn, TaskSkipFn } from '../def.js';
+export declare const printLogsPm2Skip: TaskSkipFn;
+export declare const printLogsDockerSkip: TaskSkipFn;
+export declare const printLogsPm2Task: TaskFn;
+export declare const printLogsDockerTask: TaskFn;

package/dist/tasks/printLogs.js

@@ -0,0 +1,69 @@
+import chalk from 'chalk';
+import { buildDockerComposeTestCmd } from './setupDocker.js';
+export const printLogsPm2Skip = async (ctx) => {
+    if (ctx.config.pm2 === false
+        || ctx.config.pm2.logs === false) {
+        return 'Logs disabled';
+    }
+    const hasPm2 = await ctx.test('test -f pm2.config.*');
+    if (!hasPm2) {
+        return 'No PM2 detected';
+    }
+    return false;
+};
+export const printLogsDockerSkip = async (ctx) => {
+    if (ctx.config.dockerCompose === false
+        || ctx.config.dockerCompose.logs === false) {
+        return 'Logs disabled';
+    }
+    const testCmd = buildDockerComposeTestCmd(ctx.config.dockerCompose);
+    const hasDocker = await ctx.test(testCmd);
+    if (!hasDocker) {
+        return 'No Docker Compose detected';
+    }
+    return false;
+};
+export const printLogsPm2Task = async (ctx) => {
+    if (ctx.config.pm2 === false
+        || ctx.config.pm2.logs === false) {
+        return;
+    }
+    const logsConfig = {
+        time: 3,
+        lines: 25,
+        ...ctx.config.pm2.logs,
+    };
+    const hasPm2 = await ctx.test('test -f pm2.config.*');
+    if (hasPm2) {
+        const pm2ConfigRaw = await ctx.run('cat pm2.config.*', { printOutput: false });
+        const nameMatch = pm2ConfigRaw.stdout.match(/name: ['"](?<name>.+?)['"]/);
+        const name = nameMatch.groups?.name ?? 'all';
+        console.log(chalk.cyan(`Streaming PM2 logs for ${logsConfig.time}s...`));
+        await ctx.run(`timeout ${logsConfig.time} pm2 logs --lines=${logsConfig.lines} "${name}" || true`, {
+            printOutput: true,
+            ignoreError: true,
+        });
+    }
+};
+export const printLogsDockerTask = async (ctx) => {
+    if (ctx.config.dockerCompose === false
+        || ctx.config.dockerCompose.logs === false) {
+        return;
+    }
+    const logsConfig = {
+        time: 3,
+        lines: 25,
+        ...ctx.config.dockerCompose.logs,
+    };
+    const testCmd = buildDockerComposeTestCmd(ctx.config.dockerCompose);
+    const hasDocker = await ctx.test(testCmd);
+    if (hasDocker) {
+        const configFiles = ctx.config.dockerCompose.configFiles ?? [];
+        const options = configFiles.map(f => `-f ${f}`).join(' ');
+        console.log(chalk.cyan(`Streaming Docker Compose logs for ${logsConfig.time}s...`));
+        await ctx.run(`timeout ${logsConfig.time} docker compose ${options} logs --tail=${logsConfig.lines} -f || true`, {
+            printOutput: true,
+            ignoreError: true,
+        });
+    }
+};

package/dist/tasks/setupDocker.d.ts

@@ -0,0 +1,4 @@
+import type { DockerComposeConfig, TaskFn, TaskSkipFn } from '../def.js';
+export declare function buildDockerComposeTestCmd(dockerComposeConfig: DockerComposeConfig | false): string;
+export declare const setupDockerSkip: TaskSkipFn;
+export declare const setupDockerTask: TaskFn;

package/dist/tasks/setupDocker.js

@@ -0,0 +1,33 @@
+export function buildDockerComposeTestCmd(dockerComposeConfig) {
+    if (dockerComposeConfig === false) {
+        return 'false';
+    }
+    const configFiles = dockerComposeConfig.configFiles ?? [
+        'docker-compose.yml',
+        'docker-compose.yaml',
+        'compose.yml',
+        'compose.yaml',
+    ];
+    const testCmdPart = configFiles.map(f => `-f ${f}`);
+    return `test ${testCmdPart.join(' -o ')}`;
+}
+export const setupDockerSkip = async (ctx) => {
+    if (ctx.config.dockerCompose === false) {
+        return 'Docker Compose disabled';
+    }
+    const testCmd = buildDockerComposeTestCmd(ctx.config.dockerCompose);
+    const composeExists = await ctx.test(testCmd);
+    if (!composeExists) {
+        return 'Docker Compose config not found';
+    }
+    return false;
+};
+export const setupDockerTask = async (ctx) => {
+    if (ctx.config.dockerCompose === false) {
+        return;
+    }
+    const configFiles = ctx.config.dockerCompose?.configFiles ?? [];
+    const options = configFiles.map(f => `-f ${f}`).join(' ');
+    await ctx.run(`docker compose ${options} down --remove-orphans`);
+    await ctx.run(`docker compose ${options} up -d --build`);
+};

package/dist/tasks/setupPm2.d.ts

@@ -0,0 +1,3 @@
+import type { TaskFn, TaskSkipFn } from '../def.js';
+export declare const setupPm2Skip: TaskSkipFn;
+export declare const setupPm2Task: TaskFn;

package/dist/tasks/setupPm2.js

@@ -0,0 +1,14 @@
+export const setupPm2Skip = async (ctx) => {
+    if (ctx.config.pm2 === false) {
+        return 'PM2 disabled';
+    }
+    const pm2ConfigExists = await ctx.test('test -f pm2.config.*');
+    if (!pm2ConfigExists) {
+        return 'PM2 config not found';
+    }
+    return false;
+};
+export const setupPm2Task = async (ctx) => {
+    await ctx.run('pm2 start pm2.config.* --update-env');
+    await ctx.run('pm2 save');
+};

package/dist/tasks/symlinks.d.ts

@@ -0,0 +1,3 @@
+import type { TaskFn, TaskSkipFn } from '../def.js';
+export declare const symlinksSkip: TaskSkipFn;
+export declare const symlinksTask: TaskFn;

package/dist/tasks/symlinks.js

@@ -0,0 +1,18 @@
+export const symlinksSkip = (ctx) => {
+    const symlinks = ctx.config.symlinks;
+    return !symlinks || symlinks.length === 0
+        ? 'No symlinks defined in config'
+        : false;
+};
+export const symlinksTask = async (ctx, ph) => {
+    const symlinks = ctx.config.symlinks;
+    for (const link of symlinks) {
+        const target = link.target.startsWith('/')
+            ? link.target
+            : `${ph.deployPath}/${link.target}`;
+        const path = link.path.startsWith('/')
+            ? link.path
+            : `${ph.deployPath}/${link.path}`;
+        await ctx.run(`ln -sfn ${target} ${path}`);
+    }
+};

package/dist/tasks/upload.d.ts

@@ -0,0 +1,7 @@
+import type { FilesConfig, ServerConfig, TaskFn, TaskSkipFn } from '../def.js';
+export type RsyncOptions = {
+    delete?: boolean;
+};
+export declare function buildRsyncCommand(server: ServerConfig, source: string, dest: string, files: FilesConfig, options?: RsyncOptions): string;
+export declare const uploadSkip: TaskSkipFn;
+export declare const uploadTask: TaskFn;

package/dist/tasks/upload.js

@@ -0,0 +1,54 @@
+import chalk from 'chalk';
+import path from 'node:path';
+export function buildRsyncCommand(server, source, dest, files, options = {}) {
+    const { delete: useDelete = true, } = options;
+    const args = ['rsync', '-avz', '--progress=info2'];
+    if (useDelete) {
+        args.push('--delete');
+    }
+    // ssh shell
+    const sshParts = ['ssh'];
+    if (server.port && server.port !== 22) {
+        sshParts.push(`-p ${server.port}`);
+    }
+    if (server.authMethod === 'key' && server.privateKey) {
+        sshParts.push(`-i ${server.privateKey}`);
+    }
+    sshParts.push('-o StrictHostKeyChecking=no');
+    args.push('-e', `"${sshParts.join(' ')}"`);
+    // include/exclude
+    if (files.exclude) {
+        for (const pattern of files.exclude) {
+            args.push(`--exclude="${pattern}"`);
+        }
+    }
+    if (files.include) {
+        for (const pattern of files.include) {
+            args.push(`--include="${pattern}"`);
+        }
+        args.push('--exclude="*"');
+    }
+    args.push(source, dest);
+    return args.join(' ');
+}
+export const uploadSkip = (ctx) => {
+    const files = ctx.config.files;
+    return !files
+        ? 'No files configuration defined'
+        : false;
+};
+export const uploadTask = async (ctx, ph) => {
+    const files = ctx.config.files;
+    const localBase = files.basePath?.startsWith('/')
+        ? files.basePath
+        : path.resolve(ctx.config.rootDir, files.basePath ?? '.');
+    const remotePath = ph.deployPath;
+    const dest = `${ctx.server.username}@${ctx.server.host}:${remotePath}`;
+    const source = localBase.endsWith('/') ? localBase : localBase + '/';
+    await ctx.run(`mkdir -p ${remotePath}`);
+    const command = buildRsyncCommand(ctx.server, source, dest, files, {
+        delete: true,
+    });
+    console.log(chalk.grey(command));
+    await ctx.runLocal(command);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "d3ployer",
-    "version": "0.0.10",
+    "version": "0.0.12",
     "license": "MIT",
     "type": "module",
     "bin": {
@@ -25,11 +25,12 @@
         "prepare": "husky"
     },
     "dependencies": {
-        "@inquirer/confirm": "^6.0.10",
+        "@listr2/prompt-adapter-enquirer": "^4.2.1",
         "chalk": "^5.6.2",
         "commander": "^14.0.3",
+        "enquirer": "^2.4.1",
         "listr2": "^10.2.1",
-        "lodash-es": "^4.17.23",
+        "lodash-es": "^4.18.1",
         "ssh2-promise": "^1.0.3"
     },
     "devDependencies": {
@@ -38,7 +39,6 @@
         "@tsconfig/node24": "^24.0.4",
         "@types/chai": "^5.2.3",
         "@types/chai-as-promised": "^8.0.2",
-        "@types/lodash-es": "^4.17.12",
         "@types/mocha": "^10.0.10",
         "@types/node": "^24.10.13",
         "c8": "^10.1.3",

package/dist/defaultTasks.d.ts

@@ -1,9 +0,0 @@
-import type { FilesConfig, ScenarioDef, ServerConfig, TaskDef, TaskFn, TaskSkipFn } from './def.js';
-export type RsyncOptions = {
-    delete?: boolean;
-};
-export declare function buildRsyncCommand(server: ServerConfig, source: string, dest: string, files: FilesConfig, options?: RsyncOptions): string;
-export declare const downloadSkip: TaskSkipFn;
-export declare const downloadTask: TaskFn;
-export declare const defaultTasks: Record<string, TaskDef>;
-export declare const defaultScenarios: Record<string, ScenarioDef>;