d3ployer 0.0.10 → 0.0.11

package/dist/cli.js

@@ -6,19 +6,24 @@ import { runScenario, runTask } from './runner.js';
 const program = new Command()
     .name('deployer')
     .description('TypeScript deployment tool')
-    .option('-c, --config <path>', 'path to deployer.config.ts');
+    .option('-c, --config <path>', 'path to deployer.config.ts')
+    .option('--skip <tasks>', 'comma-separated list of tasks to skip');
 program
     .argument('<name>', 'scenario or task name')
     .argument('[servers...]', 'target server(s)')
     .action(async (name, servers) => {
     try {
-        const config = await loadConfig(program.opts().config);
+        const opts = program.opts();
+        const config = await loadConfig(opts.config);
         const serverList = servers.length > 0 ? servers : undefined;
+        const skipTasks = opts.skip
+            ? opts.skip.split(',').map((s) => s.trim()).filter(Boolean)
+            : [];
         if (config.scenarios?.[name]) {
-            await runScenario(config, name, serverList);
+            await runScenario(config, name, serverList, { skip: skipTasks });
         }
         else {
-            await runTask(config, name, serverList);
+            await runTask(config, name, serverList, { skip: skipTasks });
         }
     }
     catch (err) {

package/dist/config.d.ts

@@ -1,3 +1,2 @@
 import type { DeployerConfig, DeployerConfigInput } from './def.js';
-export declare function camelToColonCase(str: string): string;
 export declare function defineConfig(input: DeployerConfigInput): DeployerConfig;

package/dist/config.js

@@ -1,6 +1,6 @@
 import { defaultsDeep } from 'lodash-es';
 import os from 'node:os';
-import { defaultScenarios, defaultTasks } from './defaultTasks.js';
+import { defaultScenarios, defaultTasks } from './tasks/index.js';
 const SERVER_DEFAULTS = {
     port: 22,
     username: os.userInfo().username,
@@ -35,9 +35,6 @@ function normalizeScenario(key, input) {
         tasks: input.tasks,
     };
 }
-export function camelToColonCase(str) {
-    return str.replace(/([a-z0-9])([A-Z])/g, '$1:$2').toLowerCase();
-}
 export function defineConfig(input) {
     const servers = {};
     for (const [name, serverInput] of Object.entries(input.servers)) {
@@ -45,57 +42,52 @@ export function defineConfig(input) {
     }
     const tasks = {};
     for (const [key, taskDef] of Object.entries(defaultTasks)) {
-        tasks[camelToColonCase(key)] = taskDef;
+        tasks[key] = taskDef;
     }
     if (input.tasks) {
         for (const [key, taskInput] of Object.entries(input.tasks)) {
-            tasks[camelToColonCase(key)] = normalizeTask(key, taskInput);
+            tasks[key] = normalizeTask(key, taskInput);
         }
     }
     const scenarios = {};
     for (const [key, scenarioDef] of Object.entries(defaultScenarios)) {
-        scenarios[camelToColonCase(key)] = {
+        scenarios[key] = {
             ...scenarioDef,
-            tasks: scenarioDef.tasks.map(camelToColonCase),
+            tasks: scenarioDef.tasks,
         };
     }
     if (input.scenarios) {
         for (const [key, scenarioInput] of Object.entries(input.scenarios)) {
             const normalized = normalizeScenario(key, scenarioInput);
-            scenarios[camelToColonCase(key)] = {
+            scenarios[key] = {
                 ...normalized,
-                tasks: normalized.tasks.map(camelToColonCase),
+                tasks: normalized.tasks,
             };
         }
     }
-    let packageManager;
-    if (input.packageManager === false) {
-        packageManager = false;
-    }
-    else {
-        packageManager = {
-            manager: 'npm',
-            productionOnly: true,
-            ...input.packageManager,
-        };
-    }
-    let dockerCompose;
-    if (input.dockerCompose === false) {
-        dockerCompose = false;
-    }
-    else {
-        dockerCompose = {
-            configFiles: undefined,
-            ...input.dockerCompose,
-        };
-    }
-    return {
+    return defaultsDeep({
         rootDir: '',
         ...input,
-        packageManager,
-        dockerCompose,
         servers,
         tasks,
         scenarios,
-    };
+    }, {
+        packageManager: {
+            manager: 'npm',
+            productionOnly: true,
+        },
+        pm2: {
+            logs: {
+                lines: 25,
+                time: 3,
+            },
+        },
+        dockerCompose: {
+            configFiles: undefined,
+            logs: {
+                lines: 25,
+                time: 3,
+            },
+        },
+    });
 }

package/dist/def.d.ts

@@ -1,3 +1,4 @@
+import type { ListrTaskWrapper } from 'listr2';
 import type SSH2Promise from 'ssh2-promise';
 export type AuthMethod = 'key' | 'password' | 'agent';
 export type PackageManager = 'npm' | 'yarn' | 'pnpm';
@@ -27,12 +28,34 @@ export interface SymlinkConfig {
     path: string;
     target: string;
 }
+export type ConfigOrDisable<T> = T | false;
+export interface LogsConfig {
+    time?: number;
+    lines?: number;
+}
+export type Pm2Config = {
+    logs: ConfigOrDisable<LogsConfig>;
+};
 export type DockerComposeConfig = {
     configFiles: string[];
+    logs: ConfigOrDisable<LogsConfig>;
 };
-export interface LogsConfig {
-    time?: number;
+export interface DeployerConfig {
+    rootDir: string;
+    servers: Record<string, ServerConfig>;
+    files?: FilesConfig;
+    symlinks?: SymlinkConfig[];
+    packageManager?: ConfigOrDisable<PackageManagerConfig>;
+    pm2?: ConfigOrDisable<Pm2Config>;
+    dockerCompose?: ConfigOrDisable<DockerComposeConfig>;
+    tasks?: Record<string, TaskDef>;
+    scenarios?: Record<string, ScenarioDef>;
 }
+export type DeployerConfigInput = Omit<DeployerConfig, 'servers' | 'rootDir' | 'tasks' | 'scenarios'> & {
+    servers: Record<string, ServerConfigInput>;
+    tasks?: Record<string, TaskInput>;
+    scenarios?: Record<string, ScenarioInput>;
+};
 export interface Placeholders {
     serverName: string;
     deployPath: string;
@@ -60,7 +83,7 @@ export interface TaskContext {
     test: (cmd: string) => Promise<boolean>;
     taskConfig?: any;
 }
-export type TaskFn = (ctx: TaskContext, ph: Placeholders) => Promise<void>;
+export type TaskFn = (ctx: TaskContext, ph: Placeholders, task: ListrTaskWrapper<any, any, any>) => Promise<void>;
 export type TaskSkipFn = (ctx: TaskContext, ph: Placeholders) => Promise<boolean | string> | boolean | string;
 export interface TaskDef {
     name: string;
@@ -82,20 +105,3 @@ export type ScenarioInput = string[] | {
     name: string;
     tasks: string[];
 };
-export interface DeployerConfig {
-    rootDir: string;
-    servers: Record<string, ServerConfig>;
-    files?: FilesConfig;
-    symlinks?: SymlinkConfig[];
-    packageManager?: PackageManagerConfig | false;
-    pm2?: boolean;
-    dockerCompose?: DockerComposeConfig | false;
-    logs?: LogsConfig | false;
-    tasks?: Record<string, TaskDef>;
-    scenarios?: Record<string, ScenarioDef>;
-}
-export type DeployerConfigInput = Omit<DeployerConfig, 'servers' | 'rootDir' | 'tasks' | 'scenarios'> & {
-    servers: Record<string, ServerConfigInput>;
-    tasks?: Record<string, TaskInput>;
-    scenarios?: Record<string, ScenarioInput>;
-};

package/dist/index.d.ts

@@ -2,5 +2,5 @@ export type { AuthMethod, DeployerConfig, DeployerConfigInput, FilesConfig, Logs
 export { defineConfig } from './config.js';
 export { runScenario, runTask } from './runner.js';
 export { loadConfig, findConfigFile } from './configLoader.js';
-export { buildRsyncCommand, downloadSkip, downloadTask } from './defaultTasks.js';
-export type { RsyncOptions } from './defaultTasks.js';
+export { buildRsyncCommand, downloadSkip, downloadTask } from './tasks/index.js';
+export type { RsyncOptions } from './tasks/upload.js';

package/dist/index.js

@@ -1,4 +1,4 @@
 export { defineConfig } from './config.js';
 export { runScenario, runTask } from './runner.js';
 export { loadConfig, findConfigFile } from './configLoader.js';
-export { buildRsyncCommand, downloadSkip, downloadTask } from './defaultTasks.js';
+export { buildRsyncCommand, downloadSkip, downloadTask } from './tasks/index.js';

package/dist/renderer.d.ts

@@ -0,0 +1,23 @@
+export declare class CustomRenderer {
+    static nonTTY: boolean;
+    static rendererOptions: {
+        pausedTimer: {
+            field: (time: any) => string;
+            format: () => (text: string | number) => string;
+            condition?: boolean | ((args_0: number) => boolean);
+            args?: [number];
+        };
+    };
+    static rendererTaskOptions: {};
+    private tasks;
+    private options;
+    private logger;
+    private cache;
+    constructor(tasks: any, options: any);
+    end(): void;
+    render(): void;
+    private formatTitle;
+    renderer(tasks: any[]): void;
+    calculate(task: any): void;
+    reset(task: any): void;
+}

package/dist/renderer.js

@@ -0,0 +1,153 @@
+import chalk from 'chalk';
+import { color, LISTR_LOGGER_STDERR_LEVELS, LISTR_LOGGER_STYLE, ListrLogger, ListrLogLevels, ListrTaskEventType, ListrTaskState, PRESET_TIMER, } from 'listr2';
+export class CustomRenderer {
+    static nonTTY = true;
+    static rendererOptions = {
+        pausedTimer: {
+            ...PRESET_TIMER,
+            field: (time) => `${ListrLogLevels.PAUSED}:${time}`,
+            format: () => color.yellowBright,
+        },
+    };
+    static rendererTaskOptions = {};
+    tasks;
+    options;
+    logger;
+    cache = {
+        rendererOptions: new Map(),
+        rendererTaskOptions: new Map(),
+    };
+    constructor(tasks, options) {
+        this.tasks = tasks;
+        this.options = {
+            ...CustomRenderer.rendererOptions,
+            ...options,
+            icon: {
+                ...LISTR_LOGGER_STYLE.icon,
+                ...options?.icon ?? {},
+            },
+            color: {
+                ...LISTR_LOGGER_STYLE.color,
+                ...options?.color ?? {},
+            },
+        };
+        this.logger = this.options.logger ?? new ListrLogger({
+            useIcons: true,
+            toStderr: LISTR_LOGGER_STDERR_LEVELS,
+        });
+        this.logger.options.icon = this.options.icon;
+        this.logger.options.color = this.options.color;
+        if (this.options.timestamp) {
+            this.logger.options.fields.prefix.unshift(this.options.timestamp);
+        }
+    }
+    end() { }
+    render() {
+        this.renderer(this.tasks);
+    }
+    formatTitle(title) {
+        return chalk.bgCyan.black(` ${title} `);
+    }
+    renderer(tasks) {
+        tasks.forEach((task) => {
+            this.calculate(task);
+            task.once(ListrTaskEventType.CLOSED, () => {
+                this.reset(task);
+            });
+            const rendererTaskOptions = this.cache.rendererTaskOptions.get(task.id);
+            task.on(ListrTaskEventType.SUBTASK, (subtasks) => {
+                this.renderer(subtasks);
+            });
+            task.on(ListrTaskEventType.STATE, (state) => {
+                if (!task.hasTitle())
+                    return;
+                const title = this.formatTitle(task.title);
+                if (state === ListrTaskState.STARTED) {
+                    this.logger.log(ListrLogLevels.STARTED, title);
+                }
+                // else if (state === ListrTaskState.COMPLETED) {
+                //     const timer = rendererTaskOptions?.timer;
+                //     this.logger.log(ListrLogLevels.COMPLETED, title, timer && {
+                //         suffix: {
+                //             ...timer,
+                //             condition: !!task.message?.duration && timer.condition,
+                //             args: [ task.message.duration ],
+                //         },
+                //     });
+                // }
+                else if (state === ListrTaskState.PROMPT) {
+                    this.logger.process.hijack();
+                    task.on(ListrTaskEventType.PROMPT, (prompt) => {
+                        this.logger.process.toStderr(prompt, false);
+                    });
+                }
+                else if (state === ListrTaskState.PROMPT_COMPLETED) {
+                    task.off(ListrTaskEventType.PROMPT);
+                    this.logger.process.release();
+                }
+            });
+            task.on(ListrTaskEventType.OUTPUT, (output) => {
+                this.logger.log(ListrLogLevels.OUTPUT, output);
+            });
+            task.on(ListrTaskEventType.MESSAGE, (message) => {
+                const title = this.formatTitle(task.title);
+                if (message.error) {
+                    this.logger.log(ListrLogLevels.FAILED, title, {
+                        suffix: {
+                            field: `${ListrLogLevels.FAILED}: ${message.error}`,
+                            format: () => color.red,
+                        },
+                    });
+                }
+                else if (message.skip) {
+                    process.stdout.write(chalk.gray(`Skipped: ${message.skip}\n`));
+                }
+                else if (message.rollback) {
+                    this.logger.log(ListrLogLevels.ROLLBACK, title, {
+                        suffix: {
+                            field: `${ListrLogLevels.ROLLBACK}: ${message.rollback}`,
+                            format: () => color.red,
+                        },
+                    });
+                }
+                else if (message.retry) {
+                    this.logger.log(ListrLogLevels.RETRY, title, {
+                        suffix: {
+                            field: `${ListrLogLevels.RETRY}:${message.retry.count}`,
+                            format: () => color.red,
+                        },
+                    });
+                }
+                else if (message.paused) {
+                    const rendererOptions = this.cache.rendererOptions.get(task.id);
+                    const timer = rendererOptions?.pausedTimer;
+                    this.logger.log(ListrLogLevels.PAUSED, title, timer && {
+                        suffix: {
+                            ...timer,
+                            condition: !!message?.paused && timer.condition,
+                            args: [message.paused - Date.now()],
+                        },
+                    });
+                }
+            });
+        });
+    }
+    calculate(task) {
+        if (this.cache.rendererOptions.has(task.id) && this.cache.rendererTaskOptions.has(task.id))
+            return;
+        const rendererOptions = {
+            ...this.options,
+            ...task.rendererOptions,
+        };
+        this.cache.rendererOptions.set(task.id, rendererOptions);
+        this.cache.rendererTaskOptions.set(task.id, {
+            ...CustomRenderer.rendererTaskOptions,
+            timer: rendererOptions.timer,
+            ...task.rendererTaskOptions,
+        });
+    }
+    reset(task) {
+        this.cache.rendererOptions.delete(task.id);
+        this.cache.rendererTaskOptions.delete(task.id);
+    }
+}

package/dist/runner.d.ts

@@ -1,5 +1,9 @@
 import type { DeployerConfig, ServerConfig, TaskDef } from './def.js';
-export declare function resolveServers(config: DeployerConfig, serverNames?: string[]): Array<[string, ServerConfig]>;
-export declare function resolveTaskDefs(taskNames: string[], allTasks: Record<string, TaskDef>): Array<[string, TaskDef]>;
-export declare function runScenario(config: DeployerConfig, scenarioName: string, serverNames?: string[]): Promise<void>;
-export declare function runTask(config: DeployerConfig, taskName: string, serverNames?: string[]): Promise<void>;
+export declare function resolveServers(config: DeployerConfig, serverNames?: string[]): Record<string, ServerConfig>;
+export declare function resolveTaskDefs(taskNames: string[], allTasks: Record<string, TaskDef>): Record<string, TaskDef>;
+export declare function runScenario(config: DeployerConfig, scenarioName: string, serverNames?: string[], options?: {
+    skip?: string[];
+}): Promise<void>;
+export declare function runTask(config: DeployerConfig, taskName: string, serverNames?: string[], options?: {
+    skip?: string[];
+}): Promise<void>;

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/logsStream.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 printLogsDockerComposeTask: TaskFn;

package/dist/tasks/logsStream.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 printLogsDockerComposeTask = 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/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.11",
     "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",