@noego/captain 1.0.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2025
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,198 @@
+# Captain
+
+A lightweight, easy-to-use task scheduler for running TypeScript files and shell commands with cron expressions.
+
+## Quick Start
+
+```bash
+# Install from npm
+npm install -g captain
+```
+
+### TypeScript/JavaScript Tasks
+
+Create a TypeScript task:
+
+```typescript
+// task.ts
+console.log("Task running at:", new Date());
+```
+
+Create a task configuration:
+
+```yaml
+# tasks.yaml
+tasks:
+  simple:
+    description: "A simple job that runs every minute"
+    schedule: "* * * * *"
+    file: "./task.ts"
+```
+
+Run Captain:
+
+```bash
+captain ./tasks.yaml
+```
+
+### Shell Commands
+
+Create a task configuration with shell commands:
+
+```yaml
+# tasks.yaml
+tasks:
+  health_check:
+    description: "Check API health every minute"
+    schedule: "* * * * *"
+    command: "curl -s https://httpbin.org/get"
+```
+
+Run Captain:
+
+```bash
+captain ./tasks.yaml
+```
+
+## Installation
+
+```bash
+# Global installation (recommended for CLI usage)
+npm install -g captain
+
+# Local installation (for project usage)
+npm install --save captain
+```
+
+## Usage Guide
+
+### 1. Create TypeScript Tasks
+
+Create TypeScript files for your scheduled tasks:
+
+```typescript
+// tasks/log-metrics.ts
+import fs from 'fs';
+
+// Access environment variables from YAML config
+const logPath = process.env.LOG_PATH || './metrics.log';
+
+// Log system metrics
+const metrics = {
+  timestamp: new Date().toISOString(),
+  memoryUsage: process.memoryUsage(),
+  uptime: process.uptime()
+};
+
+// Append to log file
+fs.appendFileSync(logPath, JSON.stringify(metrics) + '\n');
+console.log(`Metrics logged to ${logPath}`);
+```
+
+### 2. Configure Tasks with YAML
+
+Create a YAML configuration file defining your tasks:
+
+```yaml
+# scheduler.yaml
+tasks:
+  metrics_logger:
+    description: "Log system metrics every 15 minutes"
+    schedule: "*/15 * * * *"
+    file: "./tasks/log-metrics.ts"
+    timeout: 30  # seconds
+    env:
+      LOG_PATH: "./logs/system-metrics.log"
+      
+  cleanup_task:
+    description: "Clean up temp files daily at midnight"
+    schedule: "0 0 * * *"
+    file: "./tasks/cleanup.ts"
+    concurrency:
+      max: 1
+      allow_overlap: false
+
+  # Shell command example
+  health_check:
+    description: "Check API health every 5 minutes"
+    schedule: "*/5 * * * *"
+    command: "curl -s https://api.example.com/health"
+    timeout: 10
+
+  backup:
+    description: "Run backup script daily"
+    schedule: "0 2 * * *"
+    command: "./scripts/backup.sh"
+
+config:
+  default_timeout: 60
+  log_level: "info"
+```
+
+### 3. Run Captain
+
+```bash
+# Start the scheduler
+captain ./scheduler.yaml
+
+# List all configured tasks
+captain ./scheduler.yaml --list
+
+# Run a specific task immediately
+captain ./scheduler.yaml --run metrics_logger
+
+# Combine multiple configuration files
+captain ./system-tasks.yaml ./app-tasks.yaml
+```
+
+## Task Configuration Reference
+
+Each task supports the following options:
+
+| Option | Type | Required | Description |
+|--------|------|----------|-------------|
+| `description` | string | No | Human-readable description of the task |
+| `schedule` | string | Yes | Cron expression (e.g. "*/5 * * * *") |
+| `file` | string | No* | Path to TypeScript file to execute |
+| `command` | string | No* | Shell command to execute (uses $SHELL or /bin/sh) |
+| `timeout` | number | No | Maximum runtime in seconds before termination |
+| `concurrency` | object | No | Concurrency settings |
+| `concurrency.max` | number | No | Maximum instances (default: 1) |
+| `concurrency.allow_overlap` | boolean | No | Allow task to overlap itself (default: false) |
+| `env` | object | No | Environment variables to pass to task |
+| `retry` | object | No | Retry settings for failed tasks |
+| `retry.attempts` | number | No | Number of retry attempts |
+| `retry.backoff` | string | No | Backoff strategy ("fixed" or "exponential") |
+| `retry.delay` | number | No | Delay in seconds between retries |
+
+\* Either `file` or `command` is required, but not both.
+
+## Common Use Cases
+
+- **Recurring database maintenance**: Schedule database cleanup, backups, or migrations
+- **Application monitoring**: Log metrics, check service health, or generate reports
+- **Data processing**: Schedule batch processing of data at regular intervals
+- **Service coordination**: Trigger API calls or service interactions on a schedule
+
+## Developing with Captain
+
+For developers who want to modify or extend Captain:
+
+```bash
+# Clone the repository
+git clone <repository-url>
+cd captain
+
+# Install dependencies 
+npm install
+
+# Run in development mode
+npm run dev
+
+# Run tests
+npm test
+```
+
+## License
+
+ISC

package/bin/captain.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+require('../dist/index');

package/dist/components/cli.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLI = void 0;
+const commander_1 = require("commander");
+class CLI {
+    constructor(logger, parser, scheduler, executor) {
+        this.logger = logger;
+        this.parser = parser;
+        this.scheduler = scheduler;
+        this.executor = executor;
+        this.program = new commander_1.Command();
+    }
+    setup() {
+        this.program
+            .name('captain')
+            .description('YAML-driven task runner for TypeScript')
+            .version('1.0.0')
+            .argument('[files...]', 'YAML task files to process')
+            .option('-r, --run <task>', 'Run a specific task immediately')
+            .option('-l, --list', 'List all tasks without running them')
+            .option('-e, --env-file <file>', 'Path to environment file', '.env')
+            .action(async (files, options) => {
+            await this.processFiles(files, options);
+        });
+    }
+    async processFiles(files, options) {
+        if (files.length === 0) {
+            this.logger.error('No task files specified');
+            this.program.help();
+            return;
+        }
+        // Parse all files
+        const allTasks = {};
+        let globalConfig = {};
+        for (const file of files) {
+            try {
+                const tasksFile = await this.parser.parseFile(file);
+                // Merge tasks
+                Object.entries(tasksFile.tasks).forEach(([name, task]) => {
+                    allTasks[name] = { ...task, source: file };
+                });
+                // Update global config (last file wins for conflicts)
+                if (tasksFile.config) {
+                    globalConfig = { ...globalConfig, ...tasksFile.config };
+                }
+            }
+            catch (error) {
+                this.logger.error(`Error processing file ${file}: ${error}`);
+            }
+        }
+        // Handle list option
+        if (options.list) {
+            this.listTasks(allTasks);
+            return;
+        }
+        // Handle run option
+        if (options.run) {
+            await this.runSingleTask(options.run, allTasks);
+            return;
+        }
+        // Schedule all tasks
+        this.scheduleTasks(allTasks);
+        // Keep the process running
+        this.logger.info('Captain is running. Press Ctrl+C to exit.');
+    }
+    listTasks(tasks) {
+        this.logger.info('Available tasks:');
+        Object.entries(tasks).forEach(([name, task]) => {
+            this.logger.info(`- ${name}: ${task.description || 'No description'}`);
+            this.logger.info(`  Schedule: ${task.schedule}`);
+            this.logger.info(`  File: ${task.file}`);
+            this.logger.info('');
+        });
+    }
+    async runSingleTask(taskName, tasks) {
+        const task = tasks[taskName];
+        if (!task) {
+            this.logger.error(`Task "${taskName}" not found`);
+            return;
+        }
+        this.logger.info(`Running task ${taskName} immediately`);
+        await this.executor.executeTask(taskName, task);
+        this.logger.info('Task execution complete');
+    }
+    scheduleTasks(tasks) {
+        Object.entries(tasks).forEach(([name, task]) => {
+            if (this.parser.validateTask(name, task)) {
+                this.scheduler.scheduleTask(name, task, async () => {
+                    await this.executor.executeTask(name, task);
+                });
+            }
+        });
+        this.logger.info(`Scheduled ${Object.keys(tasks).length} tasks`);
+    }
+    parse(argv) {
+        this.program.parse(argv);
+    }
+}
+exports.CLI = CLI;

package/dist/components/executor.js

@@ -0,0 +1,155 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Executor = void 0;
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+class Executor {
+    constructor(logger) {
+        this.logger = logger;
+        this.runningTasks = new Map();
+    }
+    async executeTask(taskName, taskDef) {
+        try {
+            // Check concurrency limits
+            if (!this.checkConcurrency(taskName, taskDef)) {
+                return false;
+            }
+            const env = { ...process.env, ...taskDef.env };
+            let childProcess;
+            if (taskDef.file) {
+                // Execute TypeScript/JavaScript file using tsx
+                const filePath = path.resolve(process.cwd(), taskDef.file);
+                this.logger.info(`Executing task ${taskName}: ${filePath}`);
+                childProcess = (0, child_process_1.spawn)('npx', ['tsx', filePath], {
+                    env,
+                    stdio: ['ignore', 'pipe', 'pipe']
+                });
+            }
+            else if (taskDef.command) {
+                // Execute shell command using user's shell
+                const shell = process.env.SHELL || '/bin/sh';
+                this.logger.info(`Executing task ${taskName}: ${taskDef.command}`);
+                childProcess = (0, child_process_1.spawn)(shell, ['-c', taskDef.command], {
+                    env,
+                    stdio: ['ignore', 'pipe', 'pipe']
+                });
+            }
+            else {
+                this.logger.error(`Task ${taskName} has no file or command`);
+                return false;
+            }
+            // Create execution record
+            const execution = {
+                taskName,
+                process: childProcess,
+                startTime: new Date()
+            };
+            // Set timeout if specified
+            if (taskDef.timeout) {
+                execution.timeout = setTimeout(() => {
+                    this.logger.warn(`Task ${taskName} timed out after ${taskDef.timeout}s`);
+                    childProcess.kill();
+                }, taskDef.timeout * 1000);
+            }
+            // Store in running tasks
+            const runningTasks = this.runningTasks.get(taskName) || [];
+            runningTasks.push(execution);
+            this.runningTasks.set(taskName, runningTasks);
+            // Handle stdout
+            childProcess.stdout.on('data', (data) => {
+                this.logger.info(`[${taskName}] ${data.toString().trim()}`);
+            });
+            // Handle stderr
+            childProcess.stderr.on('data', (data) => {
+                this.logger.error(`[${taskName}] ${data.toString().trim()}`);
+            });
+            // Handle process completion
+            return new Promise((resolve) => {
+                childProcess.on('close', (code) => {
+                    // Clear timeout if it exists
+                    if (execution.timeout) {
+                        clearTimeout(execution.timeout);
+                    }
+                    // Remove from running tasks
+                    this.removeRunningTask(taskName, execution);
+                    const success = code === 0;
+                    const duration = (new Date().getTime() - execution.startTime.getTime()) / 1000;
+                    if (success) {
+                        this.logger.info(`Task ${taskName} completed successfully in ${duration}s`);
+                    }
+                    else {
+                        this.logger.error(`Task ${taskName} failed with exit code ${code} after ${duration}s`);
+                        // Implement retry logic here if needed
+                    }
+                    resolve(success);
+                });
+            });
+        }
+        catch (error) {
+            this.logger.error(`Failed to execute task ${taskName}: ${error}`);
+            return false;
+        }
+    }
+    checkConcurrency(taskName, taskDef) {
+        const runningTasks = this.runningTasks.get(taskName) || [];
+        const maxConcurrency = taskDef.concurrency?.max || 1;
+        // Check if max concurrency would be exceeded
+        if (runningTasks.length >= maxConcurrency) {
+            this.logger.warn(`Task ${taskName} reached max concurrency (${maxConcurrency})`);
+            return false;
+        }
+        // Check if overlap is allowed
+        if (runningTasks.length > 0 && taskDef.concurrency?.allow_overlap === false) {
+            this.logger.warn(`Task ${taskName} is already running and overlap is not allowed`);
+            return false;
+        }
+        return true;
+    }
+    removeRunningTask(taskName, execution) {
+        const runningTasks = this.runningTasks.get(taskName) || [];
+        const index = runningTasks.indexOf(execution);
+        if (index !== -1) {
+            runningTasks.splice(index, 1);
+            if (runningTasks.length === 0) {
+                this.runningTasks.delete(taskName);
+            }
+            else {
+                this.runningTasks.set(taskName, runningTasks);
+            }
+        }
+    }
+}
+exports.Executor = Executor;

package/dist/components/parser.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+class Parser {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    async parseFile(filePath) {
+        try {
+            this.logger.debug(`Parsing file: ${filePath}`);
+            // Read file
+            const fileContents = await promises_1.default.readFile(filePath, 'utf8');
+            // Parse YAML
+            const parsedData = js_yaml_1.default.load(fileContents);
+            // Validate structure
+            if (!parsedData.tasks) {
+                throw new Error(`Invalid task file: ${filePath}. No tasks defined.`);
+            }
+            this.logger.info(`Parsed ${Object.keys(parsedData.tasks).length} tasks from ${filePath}`);
+            return parsedData;
+        }
+        catch (error) {
+            this.logger.error(`Failed to parse file ${filePath}: ${error}`);
+            throw error;
+        }
+    }
+    validateTask(taskName, task) {
+        // Check required fields
+        if (!task.schedule) {
+            this.logger.error(`Task ${taskName} is missing required field: schedule`);
+            return false;
+        }
+        if (!task.file && !task.command) {
+            this.logger.error(`Task ${taskName} must have either 'file' or 'command'`);
+            return false;
+        }
+        if (task.file && task.command) {
+            this.logger.error(`Task ${taskName} cannot have both 'file' and 'command'`);
+            return false;
+        }
+        return true;
+    }
+}
+exports.Parser = Parser;

package/dist/components/scheduler.js

@@ -0,0 +1,88 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scheduler = void 0;
+const cron = __importStar(require("node-cron"));
+class Scheduler {
+    constructor(logger) {
+        this.logger = logger;
+        this.schedules = new Map();
+    }
+    scheduleTask(taskName, taskDef, callback) {
+        try {
+            // Validate cron expression
+            if (!cron.validate(taskDef.schedule)) {
+                this.logger.error(`Invalid cron schedule for task ${taskName}: ${taskDef.schedule}`);
+                return false;
+            }
+            // Schedule the task
+            const scheduledTask = cron.schedule(taskDef.schedule, async () => {
+                this.logger.info(`Running scheduled task: ${taskName}`);
+                try {
+                    await callback();
+                }
+                catch (error) {
+                    this.logger.error(`Error in scheduled task ${taskName}: ${error}`);
+                }
+            });
+            // Store the scheduled task
+            this.schedules.set(taskName, scheduledTask);
+            this.logger.info(`Scheduled task ${taskName} with cron: ${taskDef.schedule}`);
+            return true;
+        }
+        catch (error) {
+            this.logger.error(`Failed to schedule task ${taskName}: ${error}`);
+            return false;
+        }
+    }
+    stopTask(taskName) {
+        const scheduledTask = this.schedules.get(taskName);
+        if (scheduledTask) {
+            scheduledTask.stop();
+            this.schedules.delete(taskName);
+            this.logger.info(`Stopped scheduled task: ${taskName}`);
+            return true;
+        }
+        return false;
+    }
+    stopAllTasks() {
+        for (const [taskName, scheduledTask] of this.schedules.entries()) {
+            scheduledTask.stop();
+            this.logger.info(`Stopped scheduled task: ${taskName}`);
+        }
+        this.schedules.clear();
+    }
+}
+exports.Scheduler = Scheduler;

package/dist/container.js

@@ -0,0 +1,84 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeContainer = initializeContainer;
+const ioc_1 = __importStar(require("@noego/ioc"));
+const winston_1 = __importDefault(require("winston"));
+// Import components (we'll create these soon)
+const parser_1 = require("./components/parser");
+const scheduler_1 = require("./components/scheduler");
+const executor_1 = require("./components/executor");
+const cli_1 = require("./components/cli");
+// Create and configure logger
+function createLogger() {
+    return winston_1.default.createLogger({
+        level: 'info',
+        format: winston_1.default.format.combine(winston_1.default.format.timestamp(), winston_1.default.format.printf(({ level, message, timestamp }) => {
+            return `${timestamp} ${level}: ${message}`;
+        })),
+        transports: [
+            new winston_1.default.transports.Console()
+        ]
+    });
+}
+// Initialize container
+function initializeContainer() {
+    const container = (0, ioc_1.default)();
+    // Register logger as singleton
+    container.registerFunction('logger', createLogger, {
+        loadAs: ioc_1.LoadAs.Singleton
+    });
+    // Register components
+    container.registerClass(parser_1.Parser, {
+        param: ['logger'],
+        loadAs: ioc_1.LoadAs.Singleton
+    });
+    container.registerClass(scheduler_1.Scheduler, {
+        param: ['logger'],
+        loadAs: ioc_1.LoadAs.Singleton
+    });
+    container.registerClass(executor_1.Executor, {
+        param: ['logger'],
+        loadAs: ioc_1.LoadAs.Singleton
+    });
+    container.registerClass(cli_1.CLI, {
+        param: ['logger', parser_1.Parser, scheduler_1.Scheduler, executor_1.Executor],
+        loadAs: ioc_1.LoadAs.Singleton
+    });
+    return container;
+}

package/dist/index.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dotenv_1 = require("dotenv");
+const fs_1 = require("fs");
+const container_1 = require("./container");
+const cli_1 = require("./components/cli");
+// Function to load environment file
+function loadEnvFile(envPath = '.env') {
+    if ((0, fs_1.existsSync)(envPath)) {
+        (0, dotenv_1.config)({ path: envPath });
+        console.log(`Loaded environment variables from ${envPath}`);
+    }
+    else if (envPath !== '.env') {
+        // Only error if a specific file was requested
+        console.error(`Environment file ${envPath} not found`);
+        process.exit(1);
+    }
+}
+// Main entry point
+async function main() {
+    process.title = 'Captain';
+    try {
+        // Parse arguments early to get env-file option
+        const envFileIndex = process.argv.indexOf('--env-file') !== -1
+            ? process.argv.indexOf('--env-file')
+            : process.argv.indexOf('-e');
+        const envFile = envFileIndex !== -1 && envFileIndex + 1 < process.argv.length
+            ? process.argv[envFileIndex + 1]
+            : '.env';
+        loadEnvFile(envFile);
+        // Initialize IOC container
+        const container = (0, container_1.initializeContainer)();
+        // Get CLI component
+        const cli = await container.instance(cli_1.CLI);
+        // Setup CLI
+        cli.setup();
+        // Parse command line arguments
+        cli.parse(process.argv);
+    }
+    catch (error) {
+        console.error('Failed to start Captain:', error);
+        process.exit(1);
+    }
+}
+// Run the application
+main();

package/dist/models/task.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@noego/captain",
+  "version": "1.0.0",
+  "description": "YAML-driven task runner for TypeScript files",
+  "main": "dist/index.js",
+  "bin": {
+    "captain": "./bin/captain.js"
+  },
+  "files": [
+    "dist",
+    "bin",
+    "README.md",
+    "LICENSE"
+  ],
+  "directories": {
+    "example": "examples",
+    "test": "tests"
+  },
+  "scripts": {
+    "build": "npx tsc",
+    "test": "jest",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts"
+  },
+  "keywords": [
+    "cron",
+    "task",
+    "scheduler",
+    "yaml"
+  ],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "@noego/ioc": "^0.0.10",
+    "commander": "^13.1.0",
+    "dotenv": "^16.5.0",
+    "js-yaml": "^4.1.0",
+    "node-cron": "^3.0.3",
+    "ts-node": "^10.9.2",
+    "winston": "^3.17.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^22.13.9",
+    "@types/node-cron": "^3.0.11",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.6",
+    "typescript": "^5.8.3"
+  }
+}