cligr 1.0.0

package/src/commands/groups.ts

@@ -0,0 +1,68 @@
+import { ConfigLoader } from '../config/loader.js';
+
+interface GroupDetails {
+  name: string;
+  tool: string;
+  restart: string;
+  itemCount: number;
+}
+
+export async function groupsCommand(verbose: boolean): Promise<number> {
+  const loader = new ConfigLoader();
+
+  try {
+    const groupNames = loader.listGroups();
+
+    if (groupNames.length === 0) {
+      // No groups defined - empty output
+      return 0;
+    }
+
+    if (verbose) {
+      // Verbose mode: gather details and print table
+      const config = loader.load();
+      const details: GroupDetails[] = [];
+
+      for (const name of groupNames) {
+        const group = config.groups[name];
+        details.push({
+          name,
+          tool: group.tool || '(none)',
+          restart: group.restart,
+          itemCount: group.items.length,
+        });
+      }
+
+      // Calculate column widths
+      const maxNameLen = Math.max('GROUP'.length, ...details.map(d => d.name.length));
+      const maxToolLen = Math.max('TOOL'.length, ...details.map(d => d.tool.length));
+      const maxRestartLen = Math.max('RESTART'.length, ...details.map(d => d.restart.length));
+
+      // Print header
+      const header = 'GROUP'.padEnd(maxNameLen) + '  ' +
+                     'TOOL'.padEnd(maxToolLen) + '  ' +
+                     'RESTART'.padEnd(maxRestartLen) + '  ' +
+                     'ITEMS';
+      console.log(header);
+
+      // Print rows
+      for (const d of details) {
+        const row = d.name.padEnd(maxNameLen) + '  ' +
+                    d.tool.padEnd(maxToolLen) + '  ' +
+                    d.restart.padEnd(maxRestartLen) + '  ' +
+                    String(d.itemCount);
+        console.log(row);
+      }
+    } else {
+      // Simple mode: just list names
+      for (const name of groupNames) {
+        console.log(name);
+      }
+    }
+
+    return 0;
+  } catch (err) {
+    console.error((err as Error).message);
+    return 1;
+  }
+}

package/src/commands/ls.ts

@@ -0,0 +1,26 @@
+import { ConfigLoader } from '../config/loader.js';
+
+export async function lsCommand(groupName: string): Promise<number> {
+  const loader = new ConfigLoader();
+
+  try {
+    const { config } = loader.getGroup(groupName);
+
+    console.log(`\nGroup: ${groupName}`);
+    console.log(`Tool: ${config.tool}`);
+    console.log(`Restart: ${config.restart}`);
+    console.log('\nItems:');
+
+    for (const item of config.items) {
+      // Show the full item string as-is in the output
+      console.log(`  - ${item}`);
+    }
+
+    console.log('');
+
+    return 0;
+  } catch (err) {
+    console.error((err as Error).message);
+    return 1;
+  }
+}

package/src/commands/up.ts

@@ -0,0 +1,44 @@
+import { ConfigLoader } from '../config/loader.js';
+import { TemplateExpander } from '../process/template.js';
+import { ProcessManager } from '../process/manager.js';
+
+export async function upCommand(groupName: string): Promise<number> {
+  const loader = new ConfigLoader();
+  const manager = new ProcessManager();
+
+  try {
+    // Load group config
+    const { config, tool, toolTemplate } = loader.getGroup(groupName);
+
+    // Build process items
+    const items = config.items.map((itemStr, index) =>
+      TemplateExpander.parseItem(tool, toolTemplate, itemStr, index)
+    );
+
+    // Spawn all processes
+    manager.spawnGroup(groupName, items, config.restart);
+
+    console.log(`Started group ${groupName} with ${items.length} process(es)`);
+    console.log('Press Ctrl+C to stop...');
+
+    // Wait for signals
+    return new Promise((resolve) => {
+      const cleanup = async () => {
+        console.log('\nShutting down...');
+        process.removeListener('SIGINT', cleanup);
+        process.removeListener('SIGTERM', cleanup);
+        await manager.killAll();
+        resolve(0);
+      };
+
+      process.on('SIGINT', cleanup);
+      process.on('SIGTERM', cleanup);
+    });
+  } catch (error) {
+    if (error instanceof Error && error.name === 'ConfigError') {
+      console.error(error.message);
+      return 1;
+    }
+    throw error;
+  }
+}

package/src/config/loader.ts

@@ -0,0 +1,103 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import yaml from 'js-yaml';
+import type { CliGrConfig, GroupConfig, ToolConfig } from './types.js';
+
+const CONFIG_FILENAME = '.cligr.yml';
+
+export class ConfigError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'ConfigError';
+  }
+}
+
+export class ConfigLoader {
+  private configPath: string;
+
+  constructor(configPath?: string) {
+    if (configPath) {
+      // User provided explicit path
+      this.configPath = path.resolve(configPath);
+    } else {
+      // Auto-detect: home dir first, then current dir
+      const homeDirConfig = path.join(os.homedir(), CONFIG_FILENAME);
+      const currentDirConfig = path.resolve(CONFIG_FILENAME);
+
+      if (fs.existsSync(homeDirConfig)) {
+        this.configPath = homeDirConfig;
+      } else if (fs.existsSync(currentDirConfig)) {
+        this.configPath = currentDirConfig;
+      } else {
+        // Store home dir as default, will error in load()
+        this.configPath = homeDirConfig;
+      }
+    }
+  }
+
+  load(): CliGrConfig {
+    if (!fs.existsSync(this.configPath)) {
+      throw new ConfigError(
+        `Config file not found. Looking for:\n` +
+        `  - ${path.join(os.homedir(), CONFIG_FILENAME)}\n` +
+        `  - ${path.resolve(CONFIG_FILENAME)}`
+      );
+    }
+
+    const content = fs.readFileSync(this.configPath, 'utf-8');
+    let config: unknown;
+
+    try {
+      config = yaml.load(content);
+    } catch (err) {
+      throw new ConfigError(`Invalid YAML: ${(err as Error).message}`);
+    }
+
+    return this.validate(config);
+  }
+
+  private validate(config: unknown): CliGrConfig {
+    if (!config || typeof config !== 'object') {
+      throw new ConfigError('Config must be an object');
+    }
+
+    const cfg = config as Record<string, unknown>;
+
+    if (!cfg.groups || typeof cfg.groups !== 'object') {
+      throw new ConfigError('Config must have a "groups" object');
+    }
+
+    return cfg as CliGrConfig;
+  }
+
+  getGroup(name: string): { config: GroupConfig; tool: string | null; toolTemplate: string | null } {
+    const config = this.load();
+    const group = config.groups[name];
+
+    if (!group) {
+      const available = Object.keys(config.groups).join(', ');
+      throw new ConfigError(`Unknown group: ${name}. Available: ${available}`);
+    }
+
+    // Resolve tool
+    let toolTemplate: string | null = null;
+    let tool: string | null = null;
+
+    if (config.tools && config.tools[group.tool]) {
+      toolTemplate = config.tools[group.tool].cmd;
+      tool = group.tool;
+    } else {
+      // Tool might be a direct executable
+      tool = null;
+      toolTemplate = null;
+    }
+
+    return { config: group, tool, toolTemplate };
+  }
+
+  listGroups(): string[] {
+    const config = this.load();
+    return Object.keys(config.groups);
+  }
+}

package/src/config/types.ts

@@ -0,0 +1,20 @@
+export interface ToolConfig {
+  cmd: string;
+}
+
+export interface GroupConfig {
+  tool: string;
+  restart: 'yes' | 'no' | 'unless-stopped';
+  items: string[];
+}
+
+export interface CliGrConfig {
+  tools?: Record<string, ToolConfig>;
+  groups: Record<string, GroupConfig>;
+}
+
+export interface ProcessItem {
+  name: string;
+  args: string[];
+  fullCmd: string;
+}

package/src/index.ts

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+
+import { upCommand } from './commands/up.js';
+import { lsCommand } from './commands/ls.js';
+import { downCommand } from './commands/down.js';
+import { configCommand } from './commands/config.js';
+import { groupsCommand } from './commands/groups.js';
+
+async function main(): Promise<void> {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    printUsage();
+    process.exit(1);
+    return;
+  }
+
+  const [command, ...rest] = args;
+  let groupName: string | undefined;
+  let verbose = false;
+
+  // Parse flags for commands that support them
+  if (command === 'groups') {
+    // groups command supports -v/--verbose flags
+    const flagIndex = rest.findIndex(arg => arg === '-v' || arg === '--verbose');
+    if (flagIndex !== -1) {
+      verbose = true;
+      // Remove the flag from rest so it's not treated as a group name
+      rest.splice(flagIndex, 1);
+    }
+  }
+  groupName = rest[0];
+
+  // config and groups commands don't require group name
+  if (command !== 'config' && command !== 'groups' && !groupName) {
+    console.error('Error: group name required');
+    printUsage();
+    process.exit(1);
+    return;
+  }
+
+  let exitCode = 0;
+
+  switch (command) {
+    case 'config':
+      exitCode = await configCommand();
+      break;
+    case 'up':
+      exitCode = await upCommand(groupName);
+      break;
+    case 'ls':
+      exitCode = await lsCommand(groupName);
+      break;
+    case 'down':
+      exitCode = await downCommand(groupName);
+      break;
+    case 'groups':
+      exitCode = await groupsCommand(verbose);
+      break;
+    default:
+      console.error(`Error: unknown command '${command}'`);
+      printUsage();
+      exitCode = 1;
+  }
+
+  process.exit(exitCode);
+}
+
+function printUsage(): void {
+  console.log(`
+Usage: cligr <command> [options] [group]
+
+Commands:
+  config              Open config file in editor
+  up <group>          Start all processes in the group
+  ls <group>          List all items in the group
+  down <group>        Stop the group (Ctrl+C also works)
+  groups [-v|--verbose]  List all groups
+
+Options:
+  -v, --verbose       Show detailed group information
+
+Examples:
+  cligr config
+  cligr up test1
+  cligr ls test1
+  cligr down test1
+  cligr groups
+  cligr groups -v
+`);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(2);
+});

package/src/process/manager.ts

@@ -0,0 +1,199 @@
+import { spawn, ChildProcess } from 'child_process';
+import type { GroupConfig, ProcessItem } from '../config/types.js';
+
+export type ProcessStatus = 'running' | 'stopped' | 'failed';
+
+export class ManagedProcess {
+  constructor(
+    public item: ProcessItem,
+    public process: ChildProcess,
+    public status: ProcessStatus = 'running'
+  ) {}
+}
+
+export class ProcessManager {
+  private groups = new Map<string, ManagedProcess[]>();
+  private restartTimestamps = new Map<string, number[]>();
+  private readonly maxRestarts = 3;
+  private readonly restartWindow = 10000; // 10 seconds
+
+  spawnGroup(groupName: string, items: ProcessItem[], restartPolicy: GroupConfig['restart']): void {
+    if (this.groups.has(groupName)) {
+      throw new Error(`Group ${groupName} is already running`);
+    }
+
+    const processes: ManagedProcess[] = [];
+
+    for (const item of items) {
+      const proc = this.spawnProcess(item, groupName, restartPolicy);
+      processes.push(new ManagedProcess(item, proc));
+    }
+
+    this.groups.set(groupName, processes);
+  }
+
+  private spawnProcess(item: ProcessItem, groupName: string, restartPolicy: GroupConfig['restart']): ChildProcess {
+    // Parse command into executable and args, handling quoted strings
+    const { cmd, args } = this.parseCommand(item.fullCmd);
+
+    const proc = spawn(cmd, args, {
+      stdio: ['inherit', 'pipe', 'pipe'],
+      shell: process.platform === 'win32' // Use shell on Windows for better path handling
+    });
+
+    // Prefix output with item name
+    if (proc.stdout) {
+      proc.stdout.on('data', (data) => {
+        process.stdout.write(`[${item.name}] ${data}`);
+      });
+    }
+
+    if (proc.stderr) {
+      proc.stderr.on('data', (data) => {
+        process.stderr.write(`[${item.name}] ${data}`);
+      });
+    }
+
+    // Handle exit and restart
+    proc.on('exit', (code, signal) => {
+      this.handleExit(groupName, item, restartPolicy, code, signal);
+    });
+
+    return proc;
+  }
+
+  private parseCommand(fullCmd: string): { cmd: string; args: string[] } {
+    // Handle quoted strings for Windows paths with spaces
+    const args: string[] = [];
+    let current = '';
+    let inQuote = false;
+    let quoteChar = '';
+
+    for (let i = 0; i < fullCmd.length; i++) {
+      const char = fullCmd[i];
+      const nextChar = fullCmd[i + 1];
+
+      if ((char === '"' || char === "'") && !inQuote) {
+        inQuote = true;
+        quoteChar = char;
+      } else if (char === quoteChar && inQuote) {
+        inQuote = false;
+        quoteChar = '';
+      } else if (char === ' ' && !inQuote) {
+        if (current) {
+          args.push(current);
+          current = '';
+        }
+      } else {
+        current += char;
+      }
+    }
+
+    if (current) {
+      args.push(current);
+    }
+
+    return { cmd: args[0] || '', args: args.slice(1) };
+  }
+
+  private handleExit(groupName: string, item: ProcessItem, restartPolicy: GroupConfig['restart'], code: number | null, signal: NodeJS.Signals | null): void {
+    // Check if killed by cligr (don't restart if unless-stopped)
+    // SIGTERM works on both Unix and Windows in Node.js
+    if (restartPolicy === 'unless-stopped' && signal === 'SIGTERM') {
+      return;
+    }
+
+    // Check restart policy
+    if (restartPolicy === 'no') {
+      return;
+    }
+
+    // Check for crash loop (within the restart window)
+    const key = `${groupName}-${item.name}`;
+    const now = Date.now();
+    const timestamps = this.restartTimestamps.get(key) || [];
+
+    // Filter out timestamps outside the restart window
+    const recentTimestamps = timestamps.filter(ts => now - ts < this.restartWindow);
+    recentTimestamps.push(now);
+    this.restartTimestamps.set(key, recentTimestamps);
+
+    if (recentTimestamps.length > this.maxRestarts) {
+      console.error(`[${item.name}] Crash loop detected. Stopping restarts.`);
+      return;
+    }
+
+    // Restart after delay
+    setTimeout(() => {
+      console.log(`[${item.name}] Restarting... (exit code: ${code})`);
+      const newProc = this.spawnProcess(item, groupName, restartPolicy);
+
+      // Update the ManagedProcess in the groups Map with the new process handle
+      const processes = this.groups.get(groupName);
+      if (processes) {
+        const managedProc = processes.find(mp => mp.item.name === item.name);
+        if (managedProc) {
+          managedProc.process = newProc;
+        }
+      }
+    }, 1000);
+  }
+
+  killGroup(groupName: string): Promise<void> {
+    const processes = this.groups.get(groupName);
+    if (!processes) return Promise.resolve();
+
+    const killPromises = processes.map(mp => this.killProcess(mp.process));
+
+    this.groups.delete(groupName);
+    return Promise.all(killPromises).then(() => {});
+  }
+
+  private killProcess(proc: ChildProcess): Promise<void> {
+    return new Promise((resolve) => {
+      // First try SIGTERM for graceful shutdown
+      proc.kill('SIGTERM');
+
+      // Force kill with SIGKILL after 5 seconds if still running
+      const timeout = setTimeout(() => {
+        if (!proc.killed) {
+          proc.kill('SIGKILL');
+        }
+      }, 5000);
+
+      proc.on('exit', () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+
+      // If already dead, resolve immediately
+      if (proc.killed || proc.exitCode !== null) {
+        clearTimeout(timeout);
+        resolve();
+      }
+    });
+  }
+
+  killAll(): Promise<void> {
+    const killPromises: Promise<void>[] = [];
+    for (const groupName of this.groups.keys()) {
+      killPromises.push(this.killGroup(groupName));
+    }
+    return Promise.all(killPromises).then(() => {});
+  }
+
+  getGroupStatus(groupName: string): ProcessStatus[] {
+    const processes = this.groups.get(groupName);
+    if (!processes) return [];
+
+    return processes.map(mp => mp.status);
+  }
+
+  isGroupRunning(groupName: string): boolean {
+    return this.groups.has(groupName);
+  }
+
+  getRunningGroups(): string[] {
+    return Array.from(this.groups.keys());
+  }
+}

package/src/process/template.ts

@@ -0,0 +1,72 @@
+import type { ProcessItem } from '../config/types.js';
+
+export class TemplateExpander {
+  /**
+   * Expands a command template with item arguments
+   * @param template - Command template with $1, $2, $3 etc.
+   * @param itemStr - Comma-separated item args (e.g., "service1,8080,80")
+   * @returns ProcessItem with expanded command
+   */
+  static expand(template: string, itemStr: string, index: number): ProcessItem {
+    const args = itemStr.split(',').map(s => s.trim());
+
+    // Generate name from first arg or use index
+    const name = args[0] || `item-${index}`;
+
+    // Replace $1, $2, $3 etc. with args
+    // Must replace in reverse order to avoid replacing $1 in $10, $11, etc.
+    let fullCmd = template;
+    for (let i = args.length - 1; i >= 0; i--) {
+      const placeholder = `$${i + 1}`;
+      fullCmd = fullCmd.replaceAll(placeholder, args[i]);
+    }
+
+    return { name, args, fullCmd };
+  }
+
+  /**
+   * Parses item string into command
+   * @param tool - Tool name or executable
+   * @param toolTemplate - Template from tools config (if registered tool)
+   * @param itemStr - Comma-separated args
+   * @param index - Item index in group
+   */
+  static parseItem(tool: string | null, toolTemplate: string | null, itemStr: string, index: number): ProcessItem {
+    if (toolTemplate) {
+      // Use registered tool template
+      const result = this.expand(toolTemplate, itemStr, index);
+
+      // If there are more args than placeholders in the template, append them
+      // Count unique placeholders in the ORIGINAL template (before replacement)
+      const placeholdersInTemplate = (toolTemplate.match(/\$\d+/g) || []);
+      // Find the highest placeholder number (e.g., $1, $2 -> highest is 2)
+      let maxPlaceholder = 0;
+      for (const p of placeholdersInTemplate) {
+        const num = parseInt(p.substring(1), 10);
+        if (num > maxPlaceholder) maxPlaceholder = num;
+      }
+
+      // Only append remaining args if there were placeholders in the template
+      // If there are no placeholders, the template is a complete command
+      if (maxPlaceholder > 0 && result.args.length > maxPlaceholder) {
+        const remainingArgs = result.args.slice(maxPlaceholder);
+        result.fullCmd = `${result.fullCmd} ${remainingArgs.join(' ')}`;
+      }
+
+      return result;
+    } else {
+      // Direct executable - use tool as command prefix
+      const args = itemStr.split(',').map(s => s.trim());
+      let name = args[0] || `item-${index}`;
+
+      // If no commas in itemStr, name should be first word only
+      if (!itemStr.includes(',') && args.length === 1) {
+        const words = args[0].split(/\s+/);
+        name = words[0] || `item-${index}`;
+      }
+
+      const fullCmd = tool ? `${tool} ${itemStr}` : itemStr;
+      return { name, args, fullCmd };
+    }
+  }
+}