cligr 1.0.7 → 1.0.8

package/.claude/worktrees/agent-ac25cfb2/src/process/manager.ts

@@ -0,0 +1,270 @@
+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';
+
+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
+  private readonly pidStore = new PidStore();
+
+  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'],
+      // 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) => {
+        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') {
+      // 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;
+    }
+
+    // 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.`);
+      // Clean up PID file when stopping due to crash loop
+      this.pidStore.deletePid(groupName, item.name).catch(() => {});
+      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);
+
+    // Clean up PID files after killing
+    return Promise.all(killPromises).then(async () => {
+      await this.pidStore.deleteGroupPids(groupName);
+    });
+  }
+
+  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> {
+    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/.claude/worktrees/agent-ac25cfb2/src/process/pid-store.ts

@@ -0,0 +1,203 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+
+export interface PidEntry {
+  pid: number;
+  groupName: string;
+  itemName: string;
+  startTime: number;
+  restartPolicy: 'yes' | 'no' | 'unless-stopped';
+  fullCmd: string;
+}
+
+export class PidStore {
+  private readonly pidsDir: string;
+
+  constructor() {
+    this.pidsDir = path.join(os.homedir(), '.cligr', 'pids');
+  }
+
+  /**
+   * Initialize the PID directory
+   */
+  async ensureDir(): Promise<void> {
+    try {
+      await fs.mkdir(this.pidsDir, { recursive: true });
+    } catch (err) {
+      // Ignore if already exists
+      if ((err as NodeJS.ErrnoException).code !== 'EEXIST') {
+        throw err;
+      }
+    }
+  }
+
+  /**
+   * Sanitize item name for use in file path
+   * Replaces characters invalid on Windows (like colons in paths)
+   */
+  private sanitizeItemName(itemName: string): string {
+    // Replace characters that are invalid in Windows filenames
+    // < > : " / \ | ? *
+    return itemName.replace(/[<>:"/\\|?*]/g, '_');
+  }
+
+  /**
+   * Get the PID file path for a specific group and item
+   */
+  private getPidFilePath(groupName: string, itemName: string): string {
+    const sanitizedName = this.sanitizeItemName(itemName);
+    return path.join(this.pidsDir, `${groupName}_${sanitizedName}.pid`);
+  }
+
+  /**
+   * Write a PID file with metadata
+   */
+  async writePid(entry: PidEntry): Promise<void> {
+    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: string): Promise<PidEntry[]> {
+    await this.ensureDir();
+    const entries: PidEntry[] = [];
+
+    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) as PidEntry);
+          } catch {
+            // Skip invalid files
+            continue;
+          }
+        }
+      }
+    } catch {
+      // Directory doesn't exist or can't be read
+      return [];
+    }
+
+    return entries;
+  }
+
+  /**
+   * Read all PID entries
+   */
+  async readAllPids(): Promise<PidEntry[]> {
+    await this.ensureDir();
+    const entries: PidEntry[] = [];
+
+    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) as PidEntry);
+          } catch {
+            // Skip invalid files
+            continue;
+          }
+        }
+      }
+    } catch {
+      // Directory doesn't exist or can't be read
+      return [];
+    }
+
+    return entries;
+  }
+
+  /**
+   * Delete a specific PID file
+   */
+  async deletePid(groupName: string, itemName: string): Promise<void> {
+    const filePath = this.getPidFilePath(groupName, itemName);
+    try {
+      await fs.unlink(filePath);
+    } catch (err) {
+      // Ignore if file doesn't exist
+      if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {
+        throw err;
+      }
+    }
+  }
+
+  /**
+   * Delete all PID files for a group
+   */
+  async deleteGroupPids(groupName: string): Promise<void> {
+    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: number): boolean {
+    try {
+      // Sending signal 0 checks if process exists without killing it
+      process.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check if a PID entry is still valid and running.
+   * This helps prevent killing wrong processes if PID is reused by the OS.
+   * A PID is considered valid if it's running AND started recently (within last 5 minutes).
+   */
+  isPidEntryValid(entry: PidEntry): boolean {
+    if (!this.isPidRunning(entry.pid)) {
+      return false;
+    }
+
+    // Check if the process start time is recent (within 5 minutes)
+    // This prevents killing a wrong process if PID was reused
+    const fiveMinutesAgo = Date.now() - 5 * 60 * 1000;
+    return entry.startTime > fiveMinutesAgo;
+  }
+
+  /**
+   * Remove PID files for processes that are no longer running
+   * Returns the list of stale entries that were removed
+   */
+  async cleanupStalePids(): Promise<PidEntry[]> {
+    const allEntries = await this.readAllPids();
+    const staleEntries: PidEntry[] = [];
+
+    for (const entry of allEntries) {
+      // Check if PID is no longer running OR if entry is too old (> 5 minutes)
+      // This helps prevent PID reuse issues
+      if (!this.isPidEntryValid(entry)) {
+        staleEntries.push(entry);
+        await this.deletePid(entry.groupName, entry.itemName);
+      }
+    }
+
+    return staleEntries;
+  }
+
+  /**
+   * Get all unique group names that have PID files
+   */
+  async getRunningGroups(): Promise<string[]> {
+    const allEntries = await this.readAllPids();
+    const groups = new Set(allEntries.map(e => e.groupName));
+    return Array.from(groups);
+  }
+}

package/.claude/worktrees/agent-ac25cfb2/src/process/template.ts

@@ -0,0 +1,87 @@
+import type { ProcessItem, ItemEntry } from '../config/types.js';
+
+export class TemplateExpander {
+  /**
+   * Replaces named params in template ($name, $env, etc.)
+   * @param template - Command template with $paramName placeholders
+   * @param params - Key-value pairs for substitution
+   * @returns Template with named params replaced
+   */
+  private static expandNamedParams(template: string, params: Record<string, string>): string {
+    let result = template;
+    for (const [key, value] of Object.entries(params)) {
+      const placeholder = `$${key}`;
+      result = result.replaceAll(placeholder, value);
+    }
+    return result;
+  }
+
+  /**
+   * Expands a command template with item arguments
+   * @param template - Command template with $1, $2, $3 etc.
+   * @param item - ItemEntry with name and value
+   * @param index - Item index in group
+   * @param params - Optional named params for substitution ($name, $env, etc.)
+   * @returns ProcessItem with expanded command
+   */
+  static expand(template: string, item: ItemEntry, index: number, params: Record<string, string> = {}): ProcessItem {
+    const args = item.value.split(',').map(s => s.trim());
+
+    // Use explicit name from ItemEntry
+    const name = item.name;
+
+    // Replace $1, $2, $3 etc. with args (positional params)
+    let fullCmd = template;
+    for (let i = args.length - 1; i >= 0; i--) {
+      const placeholder = `$${i + 1}`;
+      fullCmd = fullCmd.replaceAll(placeholder, args[i]);
+    }
+
+    // Replace named params ($name, $env, etc.) AFTER positional params
+    fullCmd = this.expandNamedParams(fullCmd, params);
+
+    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 item - ItemEntry with name and value
+   * @param index - Item index in group
+   * @param params - Optional named params for substitution
+   */
+  static parseItem(
+    tool: string | null,
+    toolTemplate: string | null,
+    item: ItemEntry,
+    index: number,
+    params: Record<string, string> = {}
+  ): ProcessItem {
+    if (toolTemplate) {
+      // Use registered tool template
+      const result = this.expand(toolTemplate, item, index, params);
+
+      // If there are more args than placeholders in the template, append them
+      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 {
+      // Direct executable - use tool as command prefix
+      const args = item.value.split(',').map(s => s.trim());
+      const name = item.name;
+      const fullCmd = tool ? `${tool} ${item.value}` : item.value;
+      return { name, args, fullCmd };
+    }
+  }
+}