d3ployer 0.0.10 → 0.0.12

package/README.md

@@ -37,7 +37,7 @@ export default defineConfig({
     },
   },
   scenarios: {
-    deploy: ['upload', 'symlinks', 'dep:install', 'restart'],
+    deploy: ['upload', 'symlinks', 'install:packages', 'restart'],
   },
 });
 ```
@@ -45,10 +45,11 @@ export default defineConfig({
 Then deploy:
 
 ```bash
-dpl deploy           # run "deploy" scenario on all servers
-dpl deploy prod      # run on specific server(s)
-dpl upload           # run a single task
-dpl list             # list available scenarios, tasks, and servers
+dpl deploy                          # run "deploy" scenario on all servers
+dpl deploy prod                     # run on specific server(s)
+dpl upload                          # run a single task
+dpl deploy --skip install:packages  # skip specific tasks (comma-separated)
+dpl list                            # list available scenarios, tasks, and servers
 ```
 
 ## CLI
@@ -59,6 +60,7 @@ dpl list                   List scenarios, tasks, and servers
 
 Options:
   -c, --config <path>      Path to deployer.config.ts
+  --skip <tasks>           Comma-separated list of tasks to skip
 ```
 
 If `<name>` matches a scenario, it runs all tasks in that scenario sequentially. Otherwise it runs the matching task directly.
@@ -119,20 +121,33 @@ packageManager: {
 
 ### `pm2`
 
-Set to `false` to disable the built-in PM2 task. When enabled (default), the `pm2:setup` task auto-detects `pm2.config.*` files and runs `pm2 start`.
+Configure PM2 integration. Set to `false` to disable entirely. The `setup:pm2` task auto-detects `pm2.config.*` files. Post-deploy log streaming is configured via `pm2.logs`.
 
-### `dockerCompose`
-
-Set to `false` to disable the built-in Docker Compose task. When enabled (default), the `docker:setup` task auto-detects compose files and runs `docker compose up -d --build`.
+```ts
+pm2: {
+  logs: {
+    time: 5,   // seconds to stream (default: 3)
+    lines: 50, // log lines to show (default: 25)
+  },
+  // logs: false  — disable log streaming only
+}
+// pm2: false    — disable PM2 entirely
+```
 
-### `logs`
+### `dockerCompose`
 
-Configure post-deploy log streaming. The `stream:logs` task will stream PM2 or Docker Compose logs for the configured duration. Set to `false` to disable.
+Configure Docker Compose integration. Set to `false` to disable entirely. The `setup:docker` task auto-detects compose files. Specify custom compose files via `configFiles`.
 
 ```ts
-logs: {
-  time: 5, // seconds to stream logs (default: 3)
+dockerCompose: {
+  configFiles: ['docker-compose.prod.yml'], // optional, defaults to auto-detect
+  logs: {
+    time: 5,   // seconds to stream (default: 3)
+    lines: 50, // log lines to show (default: 25)
+  },
+  // logs: false  — disable log streaming only
 }
+// dockerCompose: false  — disable Docker Compose entirely
 ```
 
 ### `tasks`
@@ -141,7 +156,7 @@ Custom task functions receive a `TaskContext` and `Placeholders`:
 
 ```ts
 tasks: {
-  migrate: async (ctx, ph) => {
+  migrate: async (ctx, ph, task) => {
     await ctx.run('npm run migrate');
   },
 }
@@ -154,7 +169,7 @@ tasks: {
   myTask: {
     name: 'My Task',
     skip: async (ctx) => !someCondition ? 'Reason to skip' : false,
-    task: async (ctx, ph) => { /* ... */ },
+    task: async (ctx, ph, task) => { /* ... */ },
     config: { /* passed as ctx.taskConfig */ },
   },
 }
@@ -187,7 +202,7 @@ Named sequences of tasks:
 
 ```ts
 scenarios: {
-  deploy: ['upload', 'symlinks', 'dep:install', 'restart'],
+  deploy: ['upload', 'symlinks', 'install:packages', 'restart'],
 }
 ```
 
@@ -197,30 +212,31 @@ Or as objects with a custom name:
 scenarios: {
   deploy: {
     name: 'Deploy',
-    tasks: ['upload', 'symlinks', 'dep:install', 'restart'],
+    tasks: ['upload', 'symlinks', 'install:packages', 'restart'],
   },
 }
 ```
 
 ## Built-in tasks
 
-| Task               | Description                                              |
-| ------------------ | -------------------------------------------------------- |
-| `upload`           | Rsync files to the remote server                         |
-| `download`         | Rsync files from the remote server (uses task config)    |
-| `symlinks`         | Create configured symlinks on the remote server          |
-| `dep:install`      | Install dependencies via npm/yarn/pnpm                   |
-| `pm2:setup`        | Start/restart PM2 processes (auto-detects pm2.config.*)  |
-| `docker:setup`     | Run docker compose up (auto-detects compose files)       |
-| `clear:target`     | Remove the entire deploy path (with confirmation prompt) |
-| `print:deployment` | Print deployment info (date, files, disk usage)          |
-| `stream:logs`      | Stream PM2/Docker Compose logs for a few seconds         |
+| Task                | Description                                              |
+| ------------------- | -------------------------------------------------------- |
+| `upload`            | Rsync files to the remote server                         |
+| `download`          | Rsync files from the remote server (uses task config)    |
+| `symlinks`          | Create configured symlinks on the remote server          |
+| `install:packages`  | Install dependencies via npm/yarn/pnpm                   |
+| `setup:pm2`         | Start/restart PM2 processes (auto-detects pm2.config.*)  |
+| `setup:docker`      | Run docker compose up (auto-detects compose files)       |
+| `clear:target`      | Remove the entire deploy path (with confirmation prompt) |
+| `print:deployment`  | Print deployment info (date, files, disk usage)          |
+| `print:logs:pm2`    | Stream PM2 logs for a configured duration                |
+| `print:logs:docker` | Stream Docker Compose logs for a configured duration     |
 
 ### Default `deploy` scenario
 
-The built-in `deploy` scenario runs: `upload` → `symlinks` → `dep:install` → `pm2:setup` → `docker:setup` → `print:deployment` → `stream:logs`
+The built-in `deploy` scenario runs: `upload` → `symlinks` → `install:packages` → `setup:pm2` → `setup:docker` → `print:deployment` → `print:logs:pm2` → `print:logs:docker`
 
-Tasks with skip conditions will be automatically skipped when not applicable (e.g. `pm2:setup` skips if no PM2 config file exists).
+Tasks with skip conditions will be automatically skipped when not applicable (e.g. `setup:pm2` skips if no PM2 config file exists).
 
 ## Requirements
 

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>;