d3ployer 0.0.1 → 0.0.3

package/dist/cli.js

@@ -36,18 +36,23 @@ program
         const scenarios = config.scenarios ?? {};
         const scenarioKeys = Object.keys(scenarios);
         if (scenarioKeys.length) {
-            for (const name of scenarioKeys) {
-                console.log(`  ${chalk.cyan(name)} → [${scenarios[name].join(', ')}]`);
+            for (const key of scenarioKeys) {
+                const s = scenarios[key];
+                const label = s.name !== key ? `${chalk.cyan(key)} (${s.name})` : chalk.cyan(key);
+                console.log(`  ${label} → [${s.tasks.join(', ')}]`);
             }
         }
         else {
             console.log('  (none)');
         }
         console.log(chalk.bold('\nTasks:'));
-        const taskKeys = Object.keys(config.tasks ?? {});
+        const tasks = config.tasks ?? {};
+        const taskKeys = Object.keys(tasks);
         if (taskKeys.length) {
-            for (const name of taskKeys) {
-                console.log(`  ${chalk.cyan(name)}`);
+            for (const key of taskKeys) {
+                const t = tasks[key];
+                const label = t.name !== key ? `${chalk.cyan(key)} (${t.name})` : chalk.cyan(key);
+                console.log(`  ${label}`);
             }
         }
         else {

package/dist/config.js

@@ -1,6 +1,6 @@
 import { defaultsDeep } from 'lodash-es';
 import os from 'node:os';
-import { defaultTasks } from './defaultTasks.js';
+import { defaultScenarios, defaultTasks } from './defaultTasks.js';
 const SERVER_DEFAULTS = {
     port: 22,
     username: os.userInfo().username,
@@ -9,18 +9,41 @@ const SERVER_DEFAULTS = {
 function resolveServer(input) {
     return defaultsDeep({}, input, SERVER_DEFAULTS);
 }
+function normalizeTask(key, input) {
+    if (typeof input === 'function') {
+        return { name: key, fn: input };
+    }
+    return { name: input.name, fn: input.task };
+}
+function normalizeScenario(key, input) {
+    if (Array.isArray(input)) {
+        return { name: key, tasks: input };
+    }
+    return { name: input.name, tasks: input.tasks };
+}
 export function defineConfig(input) {
     const servers = {};
     for (const [name, serverInput] of Object.entries(input.servers)) {
         servers[name] = resolveServer(serverInput);
     }
+    const tasks = { ...defaultTasks };
+    if (input.tasks) {
+        for (const [key, taskInput] of Object.entries(input.tasks)) {
+            tasks[key] = normalizeTask(key, taskInput);
+        }
+    }
+    const scenarios = { ...defaultScenarios };
+    if (input.scenarios) {
+        for (const [key, scenarioInput] of Object.entries(input.scenarios)) {
+            scenarios[key] = normalizeScenario(key, scenarioInput);
+        }
+    }
     return {
-        ...input,
+        packageManager: 'npm',
         rootDir: '',
+        ...input,
         servers,
-        tasks: {
-            ...defaultTasks,
-            ...input.tasks,
-        },
+        tasks,
+        scenarios,
     };
 }

package/dist/configLoader.js

@@ -1,6 +1,5 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { defineConfig } from './config.js';
 import { Exception } from './utils/Exception.js';
 const CONFIG_FILENAME = 'deployer.config.ts';
 export function findConfigFile(startDir = process.cwd()) {
@@ -23,8 +22,7 @@ export async function loadConfig(configPath) {
         throw new Exception(`Config file not found: ${absolutePath}`, 1774741902017);
     }
     const module = await import(absolutePath);
-    const raw = module.default ?? module;
-    const config = defineConfig(raw);
+    const config = module.default ?? module;
     config.rootDir = path.dirname(absolutePath);
     if (!config.servers || Object.keys(config.servers).length === 0) {
         throw new Exception('Config must define at least one server', 1774741913430);

package/dist/def.d.ts

@@ -9,6 +9,8 @@ export interface ServerConfig {
     password?: string;
     agent?: string;
     deployPath: string;
+    packageManager?: string;
+    initCmd?: string;
 }
 export type ServerConfigInput = Partial<ServerConfig> & Pick<ServerConfig, 'host' | 'deployPath'>;
 export interface FilesConfig {
@@ -25,24 +27,55 @@ export interface Placeholders {
     deployPath: string;
     timestamp: string;
 }
+export type ExecResult = {
+    success: boolean;
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+export type RunOptions = {
+    printOutput?: boolean;
+    ignoreError?: boolean;
+};
 export interface TaskContext {
     server: ServerConfig & {
         name: string;
     };
     ssh: SSH2Promise;
     config: DeployerConfig;
-    runRemote: (cmd: string) => Promise<string>;
-    runLocal: (cmd: string) => Promise<string>;
+    runLocal: (cmd: string, options?: RunOptions) => Promise<ExecResult>;
+    testLocal: (cmd: string) => Promise<boolean>;
+    run: (cmd: string, options?: RunOptions) => Promise<ExecResult>;
+    test: (cmd: string) => Promise<boolean>;
 }
 export type TaskFn = (ctx: TaskContext, ph: Placeholders) => Promise<void>;
+export interface TaskDef {
+    name: string;
+    fn: TaskFn;
+}
+export type TaskInput = TaskFn | {
+    name: string;
+    task: TaskFn;
+};
+export interface ScenarioDef {
+    name: string;
+    tasks: string[];
+}
+export type ScenarioInput = string[] | {
+    name: string;
+    tasks: string[];
+};
 export interface DeployerConfig {
     rootDir: string;
     servers: Record<string, ServerConfig>;
+    packageManager?: string;
     files?: FilesConfig;
     symlinks?: SymlinkConfig[];
-    tasks?: Record<string, TaskFn>;
-    scenarios?: Record<string, string[]>;
+    tasks?: Record<string, TaskDef>;
+    scenarios?: Record<string, ScenarioDef>;
 }
-export type DeployerConfigInput = Omit<DeployerConfig, 'servers' | 'rootDir'> & {
+export type DeployerConfigInput = Omit<DeployerConfig, 'servers' | 'rootDir' | 'tasks' | 'scenarios'> & {
     servers: Record<string, ServerConfigInput>;
+    tasks?: Record<string, TaskInput>;
+    scenarios?: Record<string, ScenarioInput>;
 };

package/dist/defaultTasks.d.ts

@@ -1,2 +1,3 @@
-import type { TaskFn } from './def.js';
-export declare const defaultTasks: Record<string, TaskFn>;
+import type { ScenarioDef, TaskDef } from './def.js';
+export declare const defaultTasks: Record<string, TaskDef>;
+export declare const defaultScenarios: Record<string, ScenarioDef>;

package/dist/defaultTasks.js

@@ -1,5 +1,6 @@
-import path from 'node:path';
+import chalk from 'chalk';
 import { spawn } from 'node:child_process';
+import path from 'node:path';
 import { Exception } from './utils/Exception.js';
 function buildRsyncCommand(server, source, dest, files) {
     const args = ['rsync', '-avz', '--delete', '--progress=info2'];
@@ -67,7 +68,7 @@ const uploadTask = async (ctx, ph) => {
     const remotePath = ph.deployPath;
     const dest = `${ctx.server.username}@${ctx.server.host}:${remotePath}`;
     const source = localBase.endsWith('/') ? localBase : localBase + '/';
-    await ctx.runRemote(`mkdir -p ${remotePath}`);
+    await ctx.run(`mkdir -p ${remotePath}`);
     const command = buildRsyncCommand(ctx.server, source, dest, files);
     await execRsync(command);
 };
@@ -83,10 +84,59 @@ const symlinksTask = async (ctx, ph) => {
         const path = link.path.startsWith('/')
             ? link.path
             : `${ph.deployPath}/${link.path}`;
-        await ctx.runRemote(`ln -sfn ${target} ${path}`);
+        await ctx.run(`ln -sfn ${target} ${path}`);
+    }
+};
+const depInstallTask = async (ctx, ph) => {
+    const pm = ctx.server.packageManager ?? ctx.config.packageManager ?? 'npm';
+    const cmd = `${pm} install`;
+    await ctx.run(cmd);
+};
+const printDeploymentTask = async (ctx, ph) => {
+    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 .');
+};
+const pm2SetupTask = async (ctx, ph) => {
+    const pm2ConfigExists = await ctx.test('test -f pm2.config.js');
+    if (!pm2ConfigExists) {
+        console.log(chalk.yellow('pm2.config.js not found, skipping PM2 setup'));
+        return;
     }
+    await ctx.run('pm2 start pm2.config.js --update-env');
+    await ctx.run('pm2 save');
 };
 export const defaultTasks = {
-    upload: uploadTask,
-    symlinks: symlinksTask,
+    upload: {
+        name: 'Upload files',
+        fn: uploadTask,
+    },
+    symlinks: {
+        name: 'Create symlinks',
+        fn: symlinksTask,
+    },
+    depInstall: {
+        name: 'Install dependencies',
+        fn: depInstallTask,
+    },
+    printDeployment: {
+        name: 'Print deployment info',
+        fn: printDeploymentTask,
+    },
+    pm2Setup: {
+        name: 'PM2 setup',
+        fn: pm2SetupTask,
+    },
+};
+export const defaultScenarios = {
+    deploy: {
+        name: 'Deploy',
+        tasks: [
+            'upload',
+            'symlinks',
+            'depInstall',
+            'pm2Setup',
+        ],
+    },
 };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export type { AuthMethod, DeployerConfig, DeployerConfigInput, FilesConfig, Placeholders, ServerConfig, ServerConfigInput, SymlinkConfig, TaskContext, TaskFn, } from './def.js';
+export type { AuthMethod, DeployerConfig, DeployerConfigInput, FilesConfig, Placeholders, ScenarioDef, ScenarioInput, ServerConfig, ServerConfigInput, SymlinkConfig, TaskContext, TaskDef, TaskFn, TaskInput, } from './def.js';
 export { defineConfig } from './config.js';
 export { runScenario, runTask } from './runner.js';
 export { loadConfig, findConfigFile } from './configLoader.js';

package/dist/runner.d.ts

@@ -1,5 +1,5 @@
-import type { DeployerConfig, ServerConfig, TaskFn } from './def.js';
+import type { DeployerConfig, ServerConfig, TaskDef } from './def.js';
 export declare function resolveServers(config: DeployerConfig, serverNames?: string[]): Array<[string, ServerConfig]>;
-export declare function resolveTaskFns(taskNames: string[], allTasks: Record<string, TaskFn>): Array<[string, TaskFn]>;
+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>;

package/dist/runner.js

@@ -3,57 +3,89 @@ import { Listr } from 'listr2';
 import { spawn } from 'node:child_process';
 import { createSSHConnection } from './connection.js';
 import { Exception } from './utils/Exception.js';
-function execLocal(command) {
+function execLocal(command, options) {
+    const result = {
+        success: undefined,
+        code: undefined,
+        stdout: '',
+        stderr: '',
+    };
     return new Promise((resolve, reject) => {
         const child = spawn('sh', ['-c', command], {
+            cwd: options.cwd,
             stdio: ['inherit', 'pipe', 'pipe'],
         });
-        const chunks = [];
         child.stdout.on('data', (data) => {
             const text = data.toString();
-            chunks.push(text);
-            process.stdout.write(text);
+            result.stdout += text;
+            if (options.printOutput) {
+                process.stdout.write(text);
+            }
         });
         child.stderr.on('data', (data) => {
             const text = data.toString();
-            chunks.push(text);
-            process.stderr.write(text);
+            result.stderr += text;
+            if (options.printOutput) {
+                process.stderr.write(text);
+            }
         });
         child.on('close', (code) => {
-            const output = chunks.join('');
-            if (code !== 0) {
-                reject(new Exception(`Local command failed (exit ${code}): ${command}\n${output}`, 1774742010146));
+            result.code = code;
+            result.success = code === 0;
+            if (code !== 0
+                && !options.ignoreError) {
+                reject(new Exception(`Local command failed (exit ${code}): ${command}\n${result.stderr}`, 1774742010146));
                 return;
             }
-            resolve(output);
+            resolve(result);
         });
         child.on('error', (err) => {
             reject(new Exception(`Local command failed: ${command}\n${err.message}`, 1774742013175));
         });
     });
 }
-function execRemote(ssh, command) {
+function execRemote(ssh, command, options) {
+    const result = {
+        success: undefined,
+        code: undefined,
+        stdout: '',
+        stderr: '',
+    };
+    const parts = [];
+    if (options.cwd) {
+        parts.push(`cd ${options.cwd}`);
+    }
+    if (options.initCmd) {
+        parts.push(options.initCmd);
+    }
+    parts.push(command);
+    const wrappedCommand = parts.join('; \\\n');
     return new Promise((resolve, reject) => {
-        ssh.spawn(command)
+        ssh.spawn(wrappedCommand)
             .then((stream) => {
-            const chunks = [];
             stream.on('data', (data) => {
                 const text = data.toString();
-                chunks.push(text);
-                process.stdout.write(text);
+                result.stdout += text;
+                if (options.printOutput) {
+                    process.stdout.write(text);
+                }
             });
             stream.stderr.on('data', (data) => {
                 const text = data.toString();
-                chunks.push(text);
-                process.stderr.write(text);
+                result.stderr += text;
+                if (options.printOutput) {
+                    process.stderr.write(text);
+                }
             });
             stream.on('close', (code) => {
-                const output = chunks.join('');
-                if (code !== 0) {
-                    reject(new Exception(`Remote command failed (exit ${code}): ${command}\n${output}`, 1774742047909));
+                result.code = code;
+                result.success = code === 0;
+                if (code !== 0
+                    && !options.ignoreError) {
+                    reject(new Exception(`Remote command failed (exit ${code}): ${command}\n${result.stderr}`, 1774742047909));
                     return;
                 }
-                resolve(output);
+                resolve(result);
             });
         })
             .catch((err) => {
@@ -73,8 +105,46 @@ function buildTaskContext(serverName, server, ssh, config) {
         server: { ...server, name: serverName },
         ssh,
         config,
-        runRemote: (cmd) => execRemote(ssh, cmd),
-        runLocal: (cmd) => execLocal(cmd),
+        runLocal: (cmd, options = {}) => {
+            options = {
+                ignoreError: false,
+                printOutput: true,
+                ...options,
+            };
+            return execLocal(cmd, {
+                cwd: config.rootDir,
+                ...options,
+            });
+        },
+        testLocal: async (cmd) => {
+            const result = await execLocal(cmd, {
+                ignoreError: true,
+                printOutput: false,
+                cwd: config.rootDir,
+            });
+            return result.success;
+        },
+        run: (cmd, options = {}) => {
+            options = {
+                ignoreError: false,
+                printOutput: true,
+                ...options,
+            };
+            return execRemote(ssh, cmd, {
+                cwd: server.deployPath,
+                initCmd: server.initCmd,
+                ...options,
+            });
+        },
+        test: async (cmd) => {
+            const result = await execRemote(ssh, cmd, {
+                ignoreError: true,
+                printOutput: false,
+                cwd: config.rootDir,
+                initCmd: server.initCmd,
+            });
+            return result.success;
+        },
     };
 }
 export function resolveServers(config, serverNames) {
@@ -93,14 +163,14 @@ export function resolveServers(config, serverNames) {
     }
     return result;
 }
-export function resolveTaskFns(taskNames, allTasks) {
+export function resolveTaskDefs(taskNames, allTasks) {
     return taskNames.map(name => {
-        const fn = allTasks[name];
-        if (!fn) {
+        const def = allTasks[name];
+        if (!def) {
             const available = Object.keys(allTasks).join(', ');
             throw new Exception(`Task "${name}" not found. Available: ${available}`, 1774742082083);
         }
-        return [name, fn];
+        return [name, def];
     });
 }
 const listrOptions = {
@@ -121,9 +191,9 @@ function buildServerListr(serverName, server, config, tasks) {
                 ctx.ph = buildPlaceholders(serverName, server);
             },
         },
-        ...tasks.map(([taskName, taskFn]) => ({
-            title: chalk.bgCyan.black(` ${taskName} `),
-            task: async (ctx, task) => taskFn(ctx.taskCtx, ctx.ph),
+        ...tasks.map(([_key, taskDef]) => ({
+            title: chalk.bgCyan.black(` ${taskDef.name} `),
+            task: async (ctx, task) => taskDef.fn(ctx.taskCtx, ctx.ph),
             options: listrOptions,
         })),
         {
@@ -136,13 +206,13 @@ function buildServerListr(serverName, server, config, tasks) {
     ], listrOptions);
 }
 export async function runScenario(config, scenarioName, serverNames) {
-    const scenarioTasks = config.scenarios?.[scenarioName];
-    if (!scenarioTasks) {
+    const scenarioDef = config.scenarios?.[scenarioName];
+    if (!scenarioDef) {
         const available = Object.keys(config.scenarios ?? {}).join(', ') || 'none';
         throw new Exception(`Scenario "${scenarioName}" not found. Available: ${available}`, 1774742090385);
     }
     const allTasks = config.tasks ?? {};
-    const tasks = resolveTaskFns(scenarioTasks, allTasks);
+    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}) `),
@@ -153,15 +223,15 @@ export async function runScenario(config, scenarioName, serverNames) {
 }
 export async function runTask(config, taskName, serverNames) {
     const allTasks = config.tasks ?? {};
-    const taskFn = allTasks[taskName];
-    if (!taskFn) {
+    const taskDef = allTasks[taskName];
+    if (!taskDef) {
         const available = Object.keys(allTasks).join(', ') || 'none';
         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, taskFn]]),
+        task: () => buildServerListr(name, server, config, [[taskName, taskDef]]),
         options: listrOptions,
     })), listrOptions);
     await listr.run();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "d3ployer",
-    "version": "0.0.1",
+    "version": "0.0.3",
     "license": "MIT",
     "type": "module",
     "bin": {