cligr 1.0.0 → 1.0.2

package/dist/process/manager.js

@@ -0,0 +1,226 @@
+import { spawn } from "child_process";
+import { PidStore } from "./pid-store.js";
+class ManagedProcess {
+  constructor(item, process2, status = "running") {
+    this.item = item;
+    this.process = process2;
+    this.status = status;
+  }
+}
+class ProcessManager {
+  groups = /* @__PURE__ */ new Map();
+  restartTimestamps = /* @__PURE__ */ new Map();
+  maxRestarts = 3;
+  restartWindow = 1e4;
+  // 10 seconds
+  pidStore = new PidStore();
+  spawnGroup(groupName, items, restartPolicy) {
+    if (this.groups.has(groupName)) {
+      throw new Error(`Group ${groupName} is already running`);
+    }
+    const processes = [];
+    for (const item of items) {
+      const proc = this.spawnProcess(item, groupName, restartPolicy);
+      processes.push(new ManagedProcess(item, proc));
+    }
+    this.groups.set(groupName, processes);
+  }
+  spawnProcess(item, groupName, restartPolicy) {
+    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
+    });
+    if (proc.pid) {
+      const pidEntry = {
+        pid: proc.pid,
+        groupName,
+        itemName: item.name,
+        startTime: Date.now(),
+        restartPolicy,
+        fullCmd: item.fullCmd
+      };
+      this.pidStore.writePid(pidEntry).catch((err) => {
+        console.error(`[${item.name}] Failed to write PID file:`, err);
+      });
+    }
+    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}`);
+      });
+    }
+    proc.on("exit", (code, signal) => {
+      this.handleExit(groupName, item, restartPolicy, code, signal);
+    });
+    return proc;
+  }
+  parseCommand(fullCmd) {
+    const args = [];
+    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) };
+  }
+  handleExit(groupName, item, restartPolicy, code, signal) {
+    if (restartPolicy === "unless-stopped" && signal === "SIGTERM") {
+      this.pidStore.deletePid(groupName, item.name).catch(() => {
+      });
+      return;
+    }
+    if (restartPolicy === "no") {
+      this.pidStore.deletePid(groupName, item.name).catch(() => {
+      });
+      return;
+    }
+    const key = `${groupName}-${item.name}`;
+    const now = Date.now();
+    const timestamps = this.restartTimestamps.get(key) || [];
+    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.`);
+      this.pidStore.deletePid(groupName, item.name).catch(() => {
+      });
+      return;
+    }
+    setTimeout(() => {
+      console.log(`[${item.name}] Restarting... (exit code: ${code})`);
+      const newProc = this.spawnProcess(item, groupName, restartPolicy);
+      const processes = this.groups.get(groupName);
+      if (processes) {
+        const managedProc = processes.find((mp) => mp.item.name === item.name);
+        if (managedProc) {
+          managedProc.process = newProc;
+        }
+      }
+    }, 1e3);
+  }
+  killGroup(groupName) {
+    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(async () => {
+      await this.pidStore.deleteGroupPids(groupName);
+    });
+  }
+  /**
+   * Kill processes for a group by reading from PID store.
+   * This is used by the 'down' command to stop processes that were
+   * started by a previous cligr instance.
+   */
+  async killGroupByPid(groupName) {
+    const entries = await this.pidStore.readPidsByGroup(groupName);
+    const result = { killed: 0, notRunning: 0, errors: [] };
+    for (const entry of entries) {
+      if (this.pidStore.isPidRunning(entry.pid)) {
+        try {
+          await this.killPid(entry.pid);
+          result.killed++;
+        } catch (err) {
+          result.errors.push(`[${entry.itemName}] ${err}`);
+        }
+      } else {
+        result.notRunning++;
+      }
+      await this.pidStore.deletePid(entry.groupName, entry.itemName);
+    }
+    return result;
+  }
+  killPid(pid) {
+    return new Promise((resolve, reject) => {
+      try {
+        process.kill(pid, "SIGTERM");
+        const timeout = setTimeout(() => {
+          try {
+            process.kill(pid, "SIGKILL");
+          } catch {
+          }
+        }, 5e3);
+        const checkInterval = setInterval(() => {
+          if (!this.pidStore.isPidRunning(pid)) {
+            clearTimeout(timeout);
+            clearInterval(checkInterval);
+            resolve();
+          }
+        }, 100);
+        if (!this.pidStore.isPidRunning(pid)) {
+          clearTimeout(timeout);
+          clearInterval(checkInterval);
+          resolve();
+        }
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+  killProcess(proc) {
+    return new Promise((resolve) => {
+      proc.kill("SIGTERM");
+      const timeout = setTimeout(() => {
+        if (!proc.killed) {
+          proc.kill("SIGKILL");
+        }
+      }, 5e3);
+      proc.on("exit", () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+      if (proc.killed || proc.exitCode !== null) {
+        clearTimeout(timeout);
+        resolve();
+      }
+    });
+  }
+  killAll() {
+    const killPromises = [];
+    for (const groupName of this.groups.keys()) {
+      killPromises.push(this.killGroup(groupName));
+    }
+    return Promise.all(killPromises).then(() => {
+    });
+  }
+  getGroupStatus(groupName) {
+    const processes = this.groups.get(groupName);
+    if (!processes) return [];
+    return processes.map((mp) => mp.status);
+  }
+  isGroupRunning(groupName) {
+    return this.groups.has(groupName);
+  }
+  getRunningGroups() {
+    return Array.from(this.groups.keys());
+  }
+}
+export {
+  ManagedProcess,
+  ProcessManager
+};

package/dist/process/pid-store.js

@@ -0,0 +1,141 @@
+import { promises as fs } from "fs";
+import path from "path";
+import os from "os";
+class PidStore {
+  pidsDir;
+  constructor() {
+    this.pidsDir = path.join(os.homedir(), ".cligr", "pids");
+  }
+  /**
+   * Initialize the PID directory
+   */
+  async ensureDir() {
+    try {
+      await fs.mkdir(this.pidsDir, { recursive: true });
+    } catch (err) {
+      if (err.code !== "EEXIST") {
+        throw err;
+      }
+    }
+  }
+  /**
+   * Get the PID file path for a specific group and item
+   */
+  getPidFilePath(groupName, itemName) {
+    return path.join(this.pidsDir, `${groupName}_${itemName}.pid`);
+  }
+  /**
+   * Write a PID file with metadata
+   */
+  async writePid(entry) {
+    await this.ensureDir();
+    const filePath = this.getPidFilePath(entry.groupName, entry.itemName);
+    await fs.writeFile(filePath, JSON.stringify(entry, null, 2), "utf-8");
+  }
+  /**
+   * Read all PID entries for a specific group
+   */
+  async readPidsByGroup(groupName) {
+    await this.ensureDir();
+    const entries = [];
+    try {
+      const files = await fs.readdir(this.pidsDir);
+      const prefix = `${groupName}_`;
+      for (const file of files) {
+        if (file.startsWith(prefix) && file.endsWith(".pid")) {
+          try {
+            const content = await fs.readFile(path.join(this.pidsDir, file), "utf-8");
+            entries.push(JSON.parse(content));
+          } catch {
+            continue;
+          }
+        }
+      }
+    } catch {
+      return [];
+    }
+    return entries;
+  }
+  /**
+   * Read all PID entries
+   */
+  async readAllPids() {
+    await this.ensureDir();
+    const entries = [];
+    try {
+      const files = await fs.readdir(this.pidsDir);
+      for (const file of files) {
+        if (file.endsWith(".pid")) {
+          try {
+            const content = await fs.readFile(path.join(this.pidsDir, file), "utf-8");
+            entries.push(JSON.parse(content));
+          } catch {
+            continue;
+          }
+        }
+      }
+    } catch {
+      return [];
+    }
+    return entries;
+  }
+  /**
+   * Delete a specific PID file
+   */
+  async deletePid(groupName, itemName) {
+    const filePath = this.getPidFilePath(groupName, itemName);
+    try {
+      await fs.unlink(filePath);
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        throw err;
+      }
+    }
+  }
+  /**
+   * Delete all PID files for a group
+   */
+  async deleteGroupPids(groupName) {
+    const entries = await this.readPidsByGroup(groupName);
+    for (const entry of entries) {
+      await this.deletePid(entry.groupName, entry.itemName);
+    }
+  }
+  /**
+   * Check if a PID is currently running (cross-platform)
+   */
+  isPidRunning(pid) {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Remove PID files for processes that are no longer running
+   * Returns the list of stale entries that were removed
+   */
+  async cleanupStalePids() {
+    const allEntries = await this.readAllPids();
+    const staleEntries = [];
+    for (const entry of allEntries) {
+      if (!this.isPidRunning(entry.pid)) {
+        staleEntries.push(entry);
+        await this.deletePid(entry.groupName, entry.itemName);
+      }
+    }
+    return staleEntries;
+  }
+  /**
+   * Get all unique group names that have PID files
+   */
+  async getRunningGroups() {
+    const allEntries = await this.readAllPids();
+    const groups = new Set(allEntries.map((e) => e.groupName));
+    return Array.from(groups);
+  }
+}
+export {
+  PidStore
+};

package/dist/process/template.js

@@ -0,0 +1,53 @@
+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, itemStr, index) {
+    const args = itemStr.split(",").map((s) => s.trim());
+    const name = args[0] || `item-${index}`;
+    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, toolTemplate, itemStr, index) {
+    if (toolTemplate) {
+      const result = this.expand(toolTemplate, itemStr, index);
+      const placeholdersInTemplate = toolTemplate.match(/\$\d+/g) || [];
+      let maxPlaceholder = 0;
+      for (const p of placeholdersInTemplate) {
+        const num = parseInt(p.substring(1), 10);
+        if (num > maxPlaceholder) maxPlaceholder = num;
+      }
+      if (maxPlaceholder > 0 && result.args.length > maxPlaceholder) {
+        const remainingArgs = result.args.slice(maxPlaceholder);
+        result.fullCmd = `${result.fullCmd} ${remainingArgs.join(" ")}`;
+      }
+      return result;
+    } else {
+      const args = itemStr.split(",").map((s) => s.trim());
+      let name = args[0] || `item-${index}`;
+      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 };
+    }
+  }
+}
+export {
+  TemplateExpander
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cligr",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "main": "dist/index.js",
   "bin": {
     "cligr": "./dist/index.js"
@@ -21,6 +21,7 @@
     "typescript": "^5.7.3"
   },
   "dependencies": {
+    "-": "^0.0.1",
     "js-yaml": "^4.1.1"
   }
 }

package/src/commands/down.ts

@@ -1,6 +1,31 @@
+import { ProcessManager } from '../process/manager.js';
+
 export async function downCommand(groupName: string): Promise<number> {
-  // Note: In single-process approach, down is only useful
-  // if we add persistent state later
-  console.log(`Command 'down ${groupName}' - group will stop when cligr exits`);
+  const manager = new ProcessManager();
+
+  // Check for PID files and kill processes
+  const result = await manager.killGroupByPid(groupName);
+
+  if (result.killed === 0 && result.notRunning === 0) {
+    console.log(`Group '${groupName}' is not running`);
+    return 0;
+  }
+
+  if (result.killed > 0) {
+    console.log(`Stopped ${result.killed} process(es) for group '${groupName}'`);
+  }
+
+  if (result.notRunning > 0) {
+    console.log(`Cleaned up ${result.notRunning} stale PID file(s) for group '${groupName}'`);
+  }
+
+  if (result.errors.length > 0) {
+    console.error('Errors while stopping processes:');
+    for (const err of result.errors) {
+      console.error(`  ${err}`);
+    }
+    return 1;
+  }
+
   return 0;
 }

package/src/commands/groups.ts

@@ -28,7 +28,7 @@ export async function groupsCommand(verbose: boolean): Promise<number> {
         details.push({
           name,
           tool: group.tool || '(none)',
-          restart: group.restart,
+          restart: group.restart || '(none)',
           itemCount: group.items.length,
         });
       }

package/src/commands/up.ts

@@ -1,12 +1,17 @@
 import { ConfigLoader } from '../config/loader.js';
 import { TemplateExpander } from '../process/template.js';
 import { ProcessManager } from '../process/manager.js';
+import { PidStore } from '../process/pid-store.js';
 
 export async function upCommand(groupName: string): Promise<number> {
   const loader = new ConfigLoader();
   const manager = new ProcessManager();
+  const pidStore = new PidStore();
 
   try {
+    // Clean up any stale PID files for this group on startup
+    await pidStore.cleanupStalePids();
+
     // Load group config
     const { config, tool, toolTemplate } = loader.getGroup(groupName);
 

package/src/process/manager.ts

@@ -1,5 +1,6 @@
 import { spawn, ChildProcess } from 'child_process';
 import type { GroupConfig, ProcessItem } from '../config/types.js';
+import { PidStore, type PidEntry } from './pid-store.js';
 
 export type ProcessStatus = 'running' | 'stopped' | 'failed';
 
@@ -16,6 +17,7 @@ export class ProcessManager {
   private restartTimestamps = new Map<string, number[]>();
   private readonly maxRestarts = 3;
   private readonly restartWindow = 10000; // 10 seconds
+  private readonly pidStore = new PidStore();
 
   spawnGroup(groupName: string, items: ProcessItem[], restartPolicy: GroupConfig['restart']): void {
     if (this.groups.has(groupName)) {
@@ -38,9 +40,32 @@ export class ProcessManager {
 
     const proc = spawn(cmd, args, {
       stdio: ['inherit', 'pipe', 'pipe'],
-      shell: process.platform === 'win32' // Use shell on Windows for better path handling
+      // On Windows, don't use shell to avoid PID mismatch
+      // The shell's PID would be stored instead of the actual process
+      // For commands that need shell, user should use cmd /c prefix
+      shell: false,
+      windowsHide: true // Hide console window on Windows
     });
 
+    // Write PID file when process is spawned
+    // First, clean up any stale PID file for this process
+    // This prevents issues with leftover PIDs from previous crashes
+    this.pidStore.deletePid(groupName, item.name).catch(() => {});
+
+    if (proc.pid) {
+      const pidEntry: PidEntry = {
+        pid: proc.pid,
+        groupName,
+        itemName: item.name,
+        startTime: Date.now(),
+        restartPolicy,
+        fullCmd: item.fullCmd
+      };
+      this.pidStore.writePid(pidEntry).catch(err => {
+        console.error(`[${item.name}] Failed to write PID file:`, err);
+      });
+    }
+
     // Prefix output with item name
     if (proc.stdout) {
       proc.stdout.on('data', (data) => {
@@ -100,11 +125,15 @@ export class ProcessManager {
     // 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') {
+      // Clean up PID file when killed by cligr
+      this.pidStore.deletePid(groupName, item.name).catch(() => {});
       return;
     }
 
     // Check restart policy
     if (restartPolicy === 'no') {
+      // Clean up PID file when not restarting
+      this.pidStore.deletePid(groupName, item.name).catch(() => {});
       return;
     }
 
@@ -120,6 +149,8 @@ export class ProcessManager {
 
     if (recentTimestamps.length > this.maxRestarts) {
       console.error(`[${item.name}] Crash loop detected. Stopping restarts.`);
+      // Clean up PID file when stopping due to crash loop
+      this.pidStore.deletePid(groupName, item.name).catch(() => {});
       return;
     }
 
@@ -146,7 +177,76 @@ export class ProcessManager {
     const killPromises = processes.map(mp => this.killProcess(mp.process));
 
     this.groups.delete(groupName);
-    return Promise.all(killPromises).then(() => {});
+
+    // Clean up PID files after killing
+    return Promise.all(killPromises).then(async () => {
+      await this.pidStore.deleteGroupPids(groupName);
+    });
+  }
+
+  /**
+   * Kill processes for a group by reading from PID store.
+   * This is used by the 'down' command to stop processes that were
+   * started by a previous cligr instance.
+   */
+  async killGroupByPid(groupName: string): Promise<{ killed: number; notRunning: number; errors: string[] }> {
+    const entries = await this.pidStore.readPidsByGroup(groupName);
+    const result = { killed: 0, notRunning: 0, errors: [] as string[] };
+
+    for (const entry of entries) {
+      // Check if PID entry is valid (running and recent)
+      // This prevents killing wrong processes if PID was reused by OS
+      if (this.pidStore.isPidEntryValid(entry)) {
+        try {
+          await this.killPid(entry.pid);
+          result.killed++;
+        } catch (err) {
+          result.errors.push(`[${entry.itemName}] ${err}`);
+        }
+      } else {
+        result.notRunning++;
+      }
+      // Clean up PID file regardless of whether process was running
+      await this.pidStore.deletePid(entry.groupName, entry.itemName);
+    }
+
+    return result;
+  }
+
+  private killPid(pid: number): Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        // First try SIGTERM for graceful shutdown
+        process.kill(pid, 'SIGTERM');
+
+        // Force kill with SIGKILL after 5 seconds if still running
+        const timeout = setTimeout(() => {
+          try {
+            process.kill(pid, 'SIGKILL');
+          } catch {
+            // Process might have already exited
+          }
+        }, 5000);
+
+        // Poll for process exit
+        const checkInterval = setInterval(() => {
+          if (!this.pidStore.isPidRunning(pid)) {
+            clearTimeout(timeout);
+            clearInterval(checkInterval);
+            resolve();
+          }
+        }, 100);
+
+        // If already dead, resolve quickly
+        if (!this.pidStore.isPidRunning(pid)) {
+          clearTimeout(timeout);
+          clearInterval(checkInterval);
+          resolve();
+        }
+      } catch (err) {
+        reject(err);
+      }
+    });
   }
 
   private killProcess(proc: ChildProcess): Promise<void> {