d3ployer 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 100k
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,159 @@
+# d3ployer
+
+A TypeScript-based SSH deployment CLI tool. Run tasks and scenarios against remote servers over SSH, with rsync for file transfer.
+
+## Install
+
+```bash
+npm install d3ployer
+```
+
+This exposes the `dpl` CLI command.
+
+## Quick start
+
+Create a `deployer.config.ts` in your project root:
+
+```ts
+import { defineConfig } from 'd3ployer';
+
+export default defineConfig({
+  servers: {
+    prod: {
+      host: '192.168.1.10',
+      deployPath: '/opt/myapp',
+    },
+  },
+  files: {
+    basePath: './dist',
+    exclude: ['node_modules', '.git'],
+  },
+  symlinks: [
+    { path: 'config.json', target: '/etc/myapp/config.json' },
+  ],
+  tasks: {
+    restart: async (ctx) => {
+      await ctx.runRemote('systemctl restart myapp');
+    },
+  },
+  scenarios: {
+    deploy: ['upload', 'symlinks', 'depInstall', 'restart'],
+  },
+});
+```
+
+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
+```
+
+## CLI
+
+```
+dpl <name> [servers...]    Run a scenario or task
+dpl list                   List scenarios, tasks, and servers
+
+Options:
+  -c, --config <path>      Path to deployer.config.ts
+```
+
+If `<name>` matches a scenario, it runs all tasks in that scenario sequentially. Otherwise it runs the matching task directly.
+
+## Config
+
+### `servers`
+
+Define target servers. Only `host` and `deployPath` are required.
+
+| Field           | Default              | Description                          |
+| --------------- | -------------------- | ------------------------------------ |
+| `host`          | (required)           | Server hostname or IP                |
+| `deployPath`    | (required)           | Remote path to deploy to             |
+| `port`          | `22`                 | SSH port                             |
+| `username`      | Current OS user      | SSH username                         |
+| `authMethod`    | `'agent'`            | `'agent'`, `'key'`, or `'password'`  |
+| `privateKey`    | -                    | Path to private key (for `'key'`)    |
+| `password`      | -                    | SSH password (for `'password'`)      |
+| `agent`         | `SSH_AUTH_SOCK`      | SSH agent socket path                |
+| `packageManager`| -                    | Override package manager per server  |
+| `initCmd`       | -                    | Command to run on connect            |
+
+### `files`
+
+Configure rsync file upload.
+
+```ts
+files: {
+  basePath: './dist',       // local directory to sync (default: '.')
+  include: ['src/**'],      // rsync include patterns
+  exclude: ['node_modules'],// rsync exclude patterns
+}
+```
+
+### `symlinks`
+
+Create symlinks on the remote server.
+
+```ts
+symlinks: [
+  { path: 'config.json', target: '/etc/myapp/config.json' },
+]
+```
+
+Relative paths are resolved against `deployPath`.
+
+### `tasks`
+
+Custom task functions receive a `TaskContext` and `Placeholders`:
+
+```ts
+tasks: {
+  migrate: async (ctx, ph) => {
+    await ctx.runRemote(`cd ${ph.deployPath} && npm run migrate`);
+  },
+}
+```
+
+**TaskContext** provides:
+- `runRemote(cmd)` - execute a command on the remote server
+- `runLocal(cmd)` - execute a command locally
+- `server` - current server config
+- `ssh` - SSH2Promise connection
+- `config` - full deployer config
+
+**Placeholders** provide:
+- `serverName` - name of the current server
+- `deployPath` - remote deploy path
+- `timestamp` - ISO timestamp (safe for filenames)
+
+### `scenarios`
+
+Named sequences of tasks:
+
+```ts
+scenarios: {
+  deploy: ['upload', 'symlinks', 'depInstall', 'restart'],
+}
+```
+
+## Built-in tasks
+
+| Task         | Description                                    |
+| ------------ | ---------------------------------------------- |
+| `upload`     | Rsync files to the remote server               |
+| `symlinks`   | Create configured symlinks on the remote server |
+| `depInstall` | Run package manager install on the remote server|
+
+## Requirements
+
+- Node.js (ESM)
+- `rsync` installed locally (for the `upload` task)
+- SSH access to target servers
+
+## License
+
+MIT

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import './cli.js';

package/dist/bin.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import './cli.js';

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { loadConfig } from './configLoader.js';
+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');
+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 serverList = servers.length > 0 ? servers : undefined;
+        if (config.scenarios?.[name]) {
+            await runScenario(config, name, serverList);
+        }
+        else {
+            await runTask(config, name, serverList);
+        }
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
+program
+    .command('list')
+    .description('list available scenarios, tasks and servers')
+    .action(async () => {
+    try {
+        const config = await loadConfig(program.opts().config);
+        console.log(chalk.bold('\nScenarios:'));
+        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(', ')}]`);
+            }
+        }
+        else {
+            console.log('  (none)');
+        }
+        console.log(chalk.bold('\nTasks:'));
+        const taskKeys = Object.keys(config.tasks ?? {});
+        if (taskKeys.length) {
+            for (const name of taskKeys) {
+                console.log(`  ${chalk.cyan(name)}`);
+            }
+        }
+        else {
+            console.log('  (none)');
+        }
+        console.log(chalk.bold('\nServers:'));
+        for (const [name, s] of Object.entries(config.servers)) {
+            console.log(`  ${chalk.cyan(name)} → ${s.username}@${s.host}:${s.port ?? 22} (${s.deployPath})`);
+        }
+        console.log();
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exit(1);
+    }
+});
+program.parse();

package/dist/config.d.ts

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

package/dist/config.js

@@ -0,0 +1,26 @@
+import { defaultsDeep } from 'lodash-es';
+import os from 'node:os';
+import { defaultTasks } from './defaultTasks.js';
+const SERVER_DEFAULTS = {
+    port: 22,
+    username: os.userInfo().username,
+    authMethod: 'agent',
+};
+function resolveServer(input) {
+    return defaultsDeep({}, input, SERVER_DEFAULTS);
+}
+export function defineConfig(input) {
+    const servers = {};
+    for (const [name, serverInput] of Object.entries(input.servers)) {
+        servers[name] = resolveServer(serverInput);
+    }
+    return {
+        ...input,
+        rootDir: '',
+        servers,
+        tasks: {
+            ...defaultTasks,
+            ...input.tasks,
+        },
+    };
+}

package/dist/configLoader.d.ts

@@ -0,0 +1,3 @@
+import type { DeployerConfig } from './def.js';
+export declare function findConfigFile(startDir?: string): string;
+export declare function loadConfig(configPath?: string): Promise<DeployerConfig>;

package/dist/configLoader.js

@@ -0,0 +1,33 @@
+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()) {
+    let dir = path.resolve(startDir);
+    let parent = dir;
+    do {
+        dir = parent;
+        const candidate = path.join(dir, CONFIG_FILENAME);
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+        parent = path.dirname(dir);
+    } while (parent !== dir);
+    throw new Exception(`Could not find ${CONFIG_FILENAME} in ${startDir} or any parent directory`, 1774741892462);
+}
+export async function loadConfig(configPath) {
+    const resolvedPath = configPath ?? findConfigFile();
+    const absolutePath = path.resolve(resolvedPath);
+    if (!fs.existsSync(absolutePath)) {
+        throw new Exception(`Config file not found: ${absolutePath}`, 1774741902017);
+    }
+    const module = await import(absolutePath);
+    const raw = module.default ?? module;
+    const config = defineConfig(raw);
+    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);
+    }
+    return config;
+}

package/dist/connection.d.ts

@@ -0,0 +1,3 @@
+import SSH2Promise from 'ssh2-promise';
+import type { ServerConfig } from './def.js';
+export declare function createSSHConnection(server: ServerConfig): SSH2Promise;

package/dist/connection.js

@@ -0,0 +1,30 @@
+import fs from 'node:fs';
+import SSH2Promise from 'ssh2-promise';
+import { Exception } from './utils/Exception.js';
+export function createSSHConnection(server) {
+    const sshConfig = {
+        host: server.host,
+        port: server.port ?? 22,
+        username: server.username,
+        reconnect: false,
+    };
+    switch (server.authMethod ?? 'agent') {
+        case 'key':
+            if (!server.privateKey) {
+                throw new Exception(`Server "${server.host}": privateKey is required for key auth`, 1774741923779);
+            }
+            sshConfig.privateKey = fs.readFileSync(server.privateKey);
+            break;
+        case 'password':
+            if (!server.password) {
+                throw new Exception(`Server "${server.host}": password is required for password auth`, 1774741926213);
+            }
+            sshConfig.password = server.password;
+            break;
+        case 'agent':
+            sshConfig.agent = server.agent ?? process.env.SSH_AUTH_SOCK;
+            break;
+    }
+    console.log(`Connecting to ${server.username}@${server.host}:${sshConfig.port}`);
+    return new SSH2Promise(sshConfig);
+}

package/dist/def.d.ts

@@ -0,0 +1,48 @@
+import type SSH2Promise from 'ssh2-promise';
+export type AuthMethod = 'key' | 'password' | 'agent';
+export interface ServerConfig {
+    host: string;
+    port: number;
+    username: string;
+    authMethod: AuthMethod;
+    privateKey?: string;
+    password?: string;
+    agent?: string;
+    deployPath: string;
+}
+export type ServerConfigInput = Partial<ServerConfig> & Pick<ServerConfig, 'host' | 'deployPath'>;
+export interface FilesConfig {
+    basePath?: string;
+    include?: string[];
+    exclude?: string[];
+}
+export interface SymlinkConfig {
+    path: string;
+    target: string;
+}
+export interface Placeholders {
+    serverName: string;
+    deployPath: string;
+    timestamp: string;
+}
+export interface TaskContext {
+    server: ServerConfig & {
+        name: string;
+    };
+    ssh: SSH2Promise;
+    config: DeployerConfig;
+    runRemote: (cmd: string) => Promise<string>;
+    runLocal: (cmd: string) => Promise<string>;
+}
+export type TaskFn = (ctx: TaskContext, ph: Placeholders) => Promise<void>;
+export interface DeployerConfig {
+    rootDir: string;
+    servers: Record<string, ServerConfig>;
+    files?: FilesConfig;
+    symlinks?: SymlinkConfig[];
+    tasks?: Record<string, TaskFn>;
+    scenarios?: Record<string, string[]>;
+}
+export type DeployerConfigInput = Omit<DeployerConfig, 'servers' | 'rootDir'> & {
+    servers: Record<string, ServerConfigInput>;
+};

package/dist/def.js

@@ -0,0 +1 @@
+export {};

package/dist/defaultTasks.d.ts

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

package/dist/defaultTasks.js

@@ -0,0 +1,92 @@
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { Exception } from './utils/Exception.js';
+function buildRsyncCommand(server, source, dest, files) {
+    const args = ['rsync', '-avz', '--delete', '--progress=info2'];
+    // 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.include) {
+        for (const pattern of files.include) {
+            args.push(`--include=${pattern}`);
+        }
+        args.push('--exclude=*');
+    }
+    if (files.exclude) {
+        for (const pattern of files.exclude) {
+            args.push(`--exclude=${pattern}`);
+        }
+    }
+    args.push(source, dest);
+    return args.join(' ');
+}
+function execRsync(command) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('sh', ['-c', command], {
+            stdio: ['inherit', 'pipe', 'pipe'],
+        });
+        const stderrChunks = [];
+        child.stdout.on('data', (data) => {
+            process.stdout.write(data);
+        });
+        child.stderr.on('data', (data) => {
+            stderrChunks.push(data.toString());
+            process.stderr.write(data);
+        });
+        child.on('close', (code) => {
+            if (code !== 0) {
+                const details = stderrChunks.length
+                    ? `\n${stderrChunks.join('')}`
+                    : '';
+                reject(new Exception(`rsync exited with code ${code} (cmd: ${command})${details}`, 1774741947570));
+                return;
+            }
+            resolve();
+        });
+        child.on('error', (err) => {
+            reject(new Exception(`rsync failed: ${command}\n${err.message}`, 1774741947571));
+        });
+    });
+}
+const uploadTask = async (ctx, ph) => {
+    const files = ctx.config.files;
+    if (!files) {
+        return;
+    }
+    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.runRemote(`mkdir -p ${remotePath}`);
+    const command = buildRsyncCommand(ctx.server, source, dest, files);
+    await execRsync(command);
+};
+const symlinksTask = async (ctx, ph) => {
+    const symlinks = ctx.config.symlinks;
+    if (!symlinks || symlinks.length === 0) {
+        return;
+    }
+    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.runRemote(`ln -sfn ${target} ${path}`);
+    }
+};
+export const defaultTasks = {
+    upload: uploadTask,
+    symlinks: symlinksTask,
+};

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,3 @@
+export { defineConfig } from './config.js';
+export { runScenario, runTask } from './runner.js';
+export { loadConfig, findConfigFile } from './configLoader.js';

package/dist/runner.d.ts

@@ -0,0 +1,5 @@
+import type { DeployerConfig, ServerConfig, TaskFn } 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 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

@@ -0,0 +1,168 @@
+import chalk from 'chalk';
+import { Listr } from 'listr2';
+import { spawn } from 'node:child_process';
+import { createSSHConnection } from './connection.js';
+import { Exception } from './utils/Exception.js';
+function execLocal(command) {
+    return new Promise((resolve, reject) => {
+        const child = spawn('sh', ['-c', command], {
+            stdio: ['inherit', 'pipe', 'pipe'],
+        });
+        const chunks = [];
+        child.stdout.on('data', (data) => {
+            const text = data.toString();
+            chunks.push(text);
+            process.stdout.write(text);
+        });
+        child.stderr.on('data', (data) => {
+            const text = data.toString();
+            chunks.push(text);
+            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));
+                return;
+            }
+            resolve(output);
+        });
+        child.on('error', (err) => {
+            reject(new Exception(`Local command failed: ${command}\n${err.message}`, 1774742013175));
+        });
+    });
+}
+function execRemote(ssh, command) {
+    return new Promise((resolve, reject) => {
+        ssh.spawn(command)
+            .then((stream) => {
+            const chunks = [];
+            stream.on('data', (data) => {
+                const text = data.toString();
+                chunks.push(text);
+                process.stdout.write(text);
+            });
+            stream.stderr.on('data', (data) => {
+                const text = data.toString();
+                chunks.push(text);
+                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));
+                    return;
+                }
+                resolve(output);
+            });
+        })
+            .catch((err) => {
+            reject(new Exception(`Remote command failed: ${command}\n${err.message}`, 1774742062700));
+        });
+    });
+}
+function buildPlaceholders(serverName, server) {
+    return {
+        serverName,
+        deployPath: server.deployPath,
+        timestamp: new Date().toISOString().replace(/[:.]/g, '-'),
+    };
+}
+function buildTaskContext(serverName, server, ssh, config) {
+    return {
+        server: { ...server, name: serverName },
+        ssh,
+        config,
+        runRemote: (cmd) => execRemote(ssh, cmd),
+        runLocal: (cmd) => execLocal(cmd),
+    };
+}
+export function resolveServers(config, serverNames) {
+    const allEntries = Object.entries(config.servers);
+    if (!serverNames || serverNames.length === 0) {
+        return allEntries;
+    }
+    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]);
+    }
+    return result;
+}
+export function resolveTaskFns(taskNames, allTasks) {
+    return taskNames.map(name => {
+        const fn = allTasks[name];
+        if (!fn) {
+            const available = Object.keys(allTasks).join(', ');
+            throw new Exception(`Task "${name}" not found. Available: ${available}`, 1774742082083);
+        }
+        return [name, fn];
+    });
+}
+const listrOptions = {
+    concurrent: false,
+    renderer: 'simple',
+    rendererOptions: {
+        clearOutput: true,
+    },
+};
+function buildServerListr(serverName, server, config, tasks) {
+    return new Listr([
+        {
+            task: async (ctx) => {
+                const ssh = createSSHConnection(server);
+                await ssh.connect();
+                ctx.ssh = ssh;
+                ctx.taskCtx = buildTaskContext(serverName, server, ssh, config);
+                ctx.ph = buildPlaceholders(serverName, server);
+            },
+        },
+        ...tasks.map(([taskName, taskFn]) => ({
+            title: chalk.bgCyan.black(` ${taskName} `),
+            task: async (ctx, task) => taskFn(ctx.taskCtx, ctx.ph),
+            options: listrOptions,
+        })),
+        {
+            task: async (ctx) => {
+                if (ctx.ssh) {
+                    await ctx.ssh.close();
+                }
+            },
+        },
+    ], listrOptions);
+}
+export async function runScenario(config, scenarioName, serverNames) {
+    const scenarioTasks = config.scenarios?.[scenarioName];
+    if (!scenarioTasks) {
+        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 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),
+        options: listrOptions,
+    })), listrOptions);
+    await listr.run();
+}
+export async function runTask(config, taskName, serverNames) {
+    const allTasks = config.tasks ?? {};
+    const taskFn = allTasks[taskName];
+    if (!taskFn) {
+        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]]),
+        options: listrOptions,
+    })), listrOptions);
+    await listr.run();
+}

package/dist/utils/Exception.d.ts

@@ -0,0 +1,10 @@
+type Reason = Error | string;
+export declare class Exception extends Error {
+    code: number;
+    protected _reasons: Reason[];
+    get reasons(): Reason[];
+    constructor(message: string, code?: number, error?: Reason);
+    toString(): string;
+    protected _initErrorMessage(message: any, error: any): void;
+}
+export {};

package/dist/utils/Exception.js

@@ -0,0 +1,33 @@
+export class Exception extends Error {
+    code;
+    _reasons = [];
+    get reasons() { return this._reasons; }
+    constructor(message, code = -1, error) {
+        super(message);
+        this.code = code;
+        if (error) {
+            this._reasons = error instanceof Exception
+                ? error.reasons.concat([error])
+                : [error];
+            this._initErrorMessage(this.message, error);
+        }
+    }
+    toString() {
+        return `Exception #${this.code}: ${this.message}`;
+    }
+    _initErrorMessage(message, error) {
+        // @ts-ignore - it depends on the environment
+        const captureStackTrace = Error.captureStackTrace;
+        if (typeof captureStackTrace === 'function') {
+            captureStackTrace(this, this.constructor);
+        }
+        else {
+            this.stack = (new Error(message)).stack;
+        }
+        const messageLines = (this.message.match(/\n/g) || []).length + 1;
+        this.stack = this.constructor.name + ': [' + this.code + '] ' + message + '\n' +
+            this.stack.split('\n').slice(1, messageLines + 1).join('\n')
+            + '\n'
+            + error.stack;
+    }
+}

package/dist/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './Exception.js';

package/dist/utils/index.js

@@ -0,0 +1 @@
+export * from './Exception.js';

package/package.json

@@ -0,0 +1,66 @@
+{
+    "name": "d3ployer",
+    "version": "0.0.1",
+    "license": "MIT",
+    "type": "module",
+    "bin": {
+        "dpl": "dist/bin.js"
+    },
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js"
+        }
+    },
+    "types": "./dist/index.d.ts",
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "tsc -p tsconfig.build.json",
+        "dev": "tsx src/main.ts",
+        "dev:watch": "tsx --watch src/main.ts",
+        "dev:inspect": "tsx --inspect-brk src/main.ts",
+        "script": "tsx src/script.ts",
+        "deploy": "tsx src/cli.ts",
+        "test": "mocha --import=tsx",
+        "test:inspect": "mocha --import=tsx --inspect-brk",
+        "coverage": "c8 mocha --import=tsx",
+        "prepare": "husky"
+    },
+    "dependencies": {
+        "chalk": "^5.6.2",
+        "commander": "^14.0.3",
+        "listr2": "^10.2.1",
+        "lodash-es": "^4.17.23",
+        "ssh2-promise": "^1.0.3"
+    },
+    "devDependencies": {
+        "@eslint/js": "^9.39.3",
+        "@stylistic/eslint-plugin": "^2.13.0",
+        "@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",
+        "chai": "^6.2.2",
+        "chai-as-promised": "^8.0.2",
+        "eslint": "^8.57.1",
+        "eslint-plugin-import": "^2.32.0",
+        "husky": "^9.1.7",
+        "lint-staged": "^15.5.2",
+        "mocha": "^11.3.0",
+        "patch-package": "^8.0.1",
+        "tsx": "^4.21.0",
+        "typescript": "^5.9.3",
+        "typescript-eslint": "^8.56.0"
+    },
+    "lint-staged": {
+        "*.{js,jsx,ts,tsx}": [
+            "eslint --fix",
+            "git add"
+        ]
+    }
+}