cligr 1.0.6 → 1.0.8

package/src/config/types.ts

@@ -11,6 +11,7 @@ export interface GroupConfig {
   tool: string;
   restart?: 'yes' | 'no' | 'unless-stopped';
   params?: Record<string, string>;
+  disabledItems?: string[];
   items: Record<string, string>;
 }
 

package/src/index.ts

@@ -4,6 +4,7 @@ import { upCommand } from './commands/up.js';
 import { lsCommand } from './commands/ls.js';
 import { configCommand } from './commands/config.js';
 import { groupsCommand } from './commands/groups.js';
+import { serveCommand } from './commands/serve.js';
 
 async function main(): Promise<void> {
   const args = process.argv.slice(2);
@@ -18,7 +19,7 @@ async function main(): Promise<void> {
   let verbose = false;
 
   // Check if this is a known command
-  const knownCommands = ['config', 'up', 'ls', 'groups'];
+  const knownCommands = ['config', 'up', 'ls', 'groups', 'serve'];
 
   if (knownCommands.includes(firstArg)) {
     // It's a command
@@ -38,7 +39,7 @@ async function main(): Promise<void> {
     groupName = rest[0];
 
     // config and groups commands don't require group name
-    if (command !== 'config' && command !== 'groups' && !groupName) {
+    if (command !== 'config' && command !== 'groups' && command !== 'serve' && !groupName) {
       console.error('Error: group name required');
       printUsage();
       process.exit(1);
@@ -60,6 +61,9 @@ async function main(): Promise<void> {
       case 'groups':
         exitCode = await groupsCommand(verbose);
         break;
+      case 'serve':
+        exitCode = await serveCommand(rest[0]);
+        break;
     }
 
     process.exit(exitCode);
@@ -77,7 +81,8 @@ Usage: cligr <group> | <command> [options]
 Commands:
   config              Open config file in editor
   ls <group>          List all items in the group
-  groups [-v|--verbose]  List all groups
+  groups [-v|--verbose]   List all groups
+  serve [port]        Start web UI server (default port 7373)
 
 Options:
   -v, --verbose       Show detailed group information
@@ -88,6 +93,8 @@ Examples:
   cligr ls test1
   cligr groups
   cligr groups -v
+  cligr serve
+  cligr serve 8080
 `);
 }
 

package/src/process/manager.ts

@@ -1,4 +1,5 @@
 import { spawn, ChildProcess } from 'child_process';
+import { EventEmitter } from 'events';
 import type { GroupConfig, ProcessItem } from '../config/types.js';
 import { PidStore, type PidEntry } from './pid-store.js';
 
@@ -12,7 +13,7 @@ export class ManagedProcess {
   ) {}
 }
 
-export class ProcessManager {
+export class ProcessManager extends EventEmitter {
   private groups = new Map<string, ManagedProcess[]>();
   private restartTimestamps = new Map<string, number[]>();
   private readonly maxRestarts = 3;
@@ -32,6 +33,14 @@ export class ProcessManager {
     }
 
     this.groups.set(groupName, processes);
+    this.emit('group-started', groupName);
+  }
+
+  async restartGroup(groupName: string, items: ProcessItem[], restartPolicy: GroupConfig['restart']): Promise<void> {
+    if (this.isGroupRunning(groupName)) {
+      await this.killGroup(groupName);
+    }
+    this.spawnGroup(groupName, items, restartPolicy);
   }
 
   private spawnProcess(item: ProcessItem, groupName: string, restartPolicy: GroupConfig['restart']): ChildProcess {
@@ -66,16 +75,28 @@ export class ProcessManager {
       });
     }
 
-    // Prefix output with item name
+    // Prefix output with item name and emit events
+    const emitLines = (data: Buffer, isError: boolean) => {
+      const text = data.toString('utf-8');
+      const lines = text.split('\n');
+      for (const line of lines) {
+        if (line.length > 0) {
+          this.emit('process-log', groupName, item.name, line, isError);
+        }
+      }
+    };
+
     if (proc.stdout) {
       proc.stdout.on('data', (data) => {
         process.stdout.write(`[${item.name}] ${data}`);
+        emitLines(data, false);
       });
     }
 
     if (proc.stderr) {
       proc.stderr.on('data', (data) => {
         process.stderr.write(`[${item.name}] ${data}`);
+        emitLines(data, true);
       });
     }
 
@@ -122,6 +143,13 @@ export class ProcessManager {
   }
 
   private handleExit(groupName: string, item: ProcessItem, restartPolicy: GroupConfig['restart'], code: number | null, signal: NodeJS.Signals | null): void {
+    // If killed by cligr via killGroup, the group is removed from the map before SIGTERM is sent.
+    // Don't restart processes that were intentionally stopped.
+    if (signal === 'SIGTERM' && !this.groups.has(groupName)) {
+      this.pidStore.deletePid(groupName, item.name).catch(() => {});
+      return;
+    }
+
     // 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') {
@@ -158,6 +186,7 @@ export class ProcessManager {
     setTimeout(() => {
       console.log(`[${item.name}] Restarting... (exit code: ${code})`);
       const newProc = this.spawnProcess(item, groupName, restartPolicy);
+      this.emit('item-restarted', groupName, item.name);
 
       // Update the ManagedProcess in the groups Map with the new process handle
       const processes = this.groups.get(groupName);
@@ -181,6 +210,7 @@ export class ProcessManager {
     // Clean up PID files after killing
     return Promise.all(killPromises).then(async () => {
       await this.pidStore.deleteGroupPids(groupName);
+      this.emit('group-stopped', groupName);
     });
   }
 
@@ -253,6 +283,10 @@ export class ProcessManager {
     return Promise.all(killPromises).then(() => {});
   }
 
+  async cleanupStalePids(): Promise<void> {
+    await this.pidStore.cleanupStalePids();
+  }
+
   getGroupStatus(groupName: string): ProcessStatus[] {
     const processes = this.groups.get(groupName);
     if (!processes) return [];

package/tests/integration/commands.test.ts

@@ -292,6 +292,30 @@ groups:
       const output = getLogOutput();
       assert.ok(output.includes('Tool: node'));
     });
+
+    it('should mark disabled items in ls output', async () => {
+      const configContent = `
+groups:
+  mixed:
+    tool: echo
+    restart: no
+    disabledItems:
+      - service2
+    items:
+      service1: service1
+      service2: service2
+`;
+      fs.writeFileSync(testConfigPath, configContent);
+      resetOutput();
+
+      const exitCode = await lsCommand('mixed');
+
+      assert.strictEqual(exitCode, 0);
+      const output = getLogOutput();
+      assert.ok(output.includes('service1: service1'));
+      assert.ok(!output.includes('service1: service1 [disabled]'));
+      assert.ok(output.includes('service2: service2 [disabled]'));
+    });
   });
 
   describe('Command integration scenarios', () => {

package/tests/integration/config-loader.test.ts

@@ -14,6 +14,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import { ConfigLoader, ConfigError } from '../../src/config/loader.js';
+import yaml from 'js-yaml';
 
 describe('ConfigLoader Integration Tests', () => {
   let testConfigDir: string;
@@ -311,6 +312,115 @@ groups:
     });
   });
 
+  describe('saveConfig()', () => {
+    it('should save config back to file', () => {
+      const configContent = `
+groups:
+  test1:
+    tool: echo
+    restart: no
+    items:
+      hello: hello
+`;
+      fs.writeFileSync(testConfigPath, configContent);
+
+      const loader = new ConfigLoader();
+      const config = loader.load();
+      config.groups.test1.restart = 'yes';
+
+      loader.saveConfig(config);
+
+      const saved = fs.readFileSync(testConfigPath, 'utf-8');
+      const parsed = yaml.load(saved) as any;
+      assert.strictEqual(parsed.groups.test1.restart, 'yes');
+    });
+  });
+
+  describe('toggleItem()', () => {
+    it('should add item to disabledItems when disabling', () => {
+      const configContent = `
+groups:
+  test1:
+    tool: echo
+    restart: no
+    items:
+      hello: hello
+      world: world
+`;
+      fs.writeFileSync(testConfigPath, configContent);
+
+      const loader = new ConfigLoader();
+      loader.toggleItem('test1', 'hello', false);
+
+      const reloaded = new ConfigLoader().load();
+      assert.deepStrictEqual(reloaded.groups.test1.disabledItems, ['hello']);
+    });
+
+    it('should remove item from disabledItems when enabling', () => {
+      const configContent = `
+groups:
+  test1:
+    tool: echo
+    restart: no
+    disabledItems:
+      - hello
+    items:
+      hello: hello
+      world: world
+`;
+      fs.writeFileSync(testConfigPath, configContent);
+
+      const loader = new ConfigLoader();
+      loader.toggleItem('test1', 'hello', true);
+
+      const reloaded = new ConfigLoader().load();
+      assert.strictEqual(reloaded.groups.test1.disabledItems, undefined);
+    });
+  });
+
+  describe('disabledItems filtering', () => {
+    it('should filter disabled items from getGroup result', () => {
+      const configContent = `
+groups:
+  test1:
+    tool: echo
+    restart: no
+    disabledItems:
+      - hello
+    items:
+      hello: hello
+      world: world
+`;
+      fs.writeFileSync(testConfigPath, configContent);
+
+      const loader = new ConfigLoader();
+      const result = loader.getGroup('test1');
+
+      assert.strictEqual(result.items.length, 1);
+      assert.strictEqual(result.items[0].name, 'world');
+      assert.strictEqual(result.config.disabledItems?.length, 1);
+    });
+
+    it('should include all items when disabledItems is empty', () => {
+      const configContent = `
+groups:
+  test1:
+    tool: echo
+    restart: no
+    disabledItems: []
+    items:
+      hello: hello
+      world: world
+`;
+      fs.writeFileSync(testConfigPath, configContent);
+
+      const loader = new ConfigLoader();
+      const result = loader.getGroup('test1');
+
+      assert.strictEqual(result.items.length, 2);
+    });
+  });
+
   describe('Config precedence', () => {
     it('should prefer home directory config over current directory', () => {
       const homeConfigPath = path.join(testConfigDir, '.cligr.yml');

package/tests/integration/process-manager.test.ts

@@ -391,4 +391,107 @@ describe('ProcessManager Integration Tests', () => {
       await manager.killGroup('unix-test');
     });
   });
+
+  describe('restartGroup()', () => {
+    it('should restart a running group', async () => {
+      const sleepCmd = process.platform === 'win32' ? 'timeout' : 'sleep';
+      const sleepFlag = process.platform === 'win32' ? '/t' : '';
+
+      const items: ProcessItem[] = [
+        { name: 'p1', args: ['5'], fullCmd: `${sleepCmd} ${sleepFlag} 5` }
+      ];
+
+      manager.spawnGroup('restart-group', items, 'no');
+      assert.strictEqual(manager.isGroupRunning('restart-group'), true);
+
+      await manager.restartGroup('restart-group', items, 'no');
+      assert.strictEqual(manager.isGroupRunning('restart-group'), true);
+
+      await manager.killGroup('restart-group');
+    });
+  });
+
+  describe('events', () => {
+    it('should emit group-started when spawning', async () => {
+      let emitted = false;
+      manager.once('group-started', (name) => {
+        assert.strictEqual(name, 'event-group');
+        emitted = true;
+      });
+
+      const items: ProcessItem[] = [
+        { name: 'p1', args: [], fullCmd: 'echo hello' }
+      ];
+
+      manager.spawnGroup('event-group', items, 'no');
+      assert.strictEqual(emitted, true);
+
+      await manager.killGroup('event-group');
+    });
+
+    it('should emit group-stopped when killing', async () => {
+      const items: ProcessItem[] = [
+        { name: 'p1', args: ['5'], fullCmd: process.platform === 'win32' ? 'timeout /t 5' : 'sleep 5' }
+      ];
+
+      manager.spawnGroup('stop-group', items, 'no');
+
+      let emitted = false;
+      manager.once('group-stopped', (name) => {
+        assert.strictEqual(name, 'stop-group');
+        emitted = true;
+      });
+
+      await manager.killGroup('stop-group');
+      assert.strictEqual(emitted, true);
+    });
+
+    it('should emit process-log events', async () => {
+      const items: ProcessItem[] = [
+        { name: 'logger', args: [], fullCmd: 'echo test-log' }
+      ];
+
+      const logs: Array<{ group: string; item: string; line: string; isError: boolean }> = [];
+      const handler = (group: string, item: string, line: string, isError: boolean) => {
+        logs.push({ group, item, line, isError });
+      };
+      manager.once('process-log', handler);
+
+      manager.spawnGroup('log-group', items, 'no');
+
+      // Wait for process-log event or a small timeout
+      await Promise.race([
+        new Promise<void>(resolve => manager.once('process-log', () => resolve())),
+        new Promise<void>(resolve => setTimeout(resolve, 200))
+      ]);
+
+      assert.ok(logs.some(l => l.group === 'log-group' && l.item === 'logger' && l.line.includes('test-log')));
+
+      manager.off('process-log', handler);
+      await manager.killGroup('log-group');
+    });
+
+    it('should emit item-restarted when a process restarts', { timeout: 3000 }, async () => {
+      const items: ProcessItem[] = [
+        { name: 'quick-exit', args: [], fullCmd: 'node -e "process.exit(0)"' }
+      ];
+
+      let restartedGroup = '';
+      let restartedItem = '';
+      manager.once('item-restarted', (groupName, itemName) => {
+        restartedGroup = groupName;
+        restartedItem = itemName;
+      });
+
+      manager.spawnGroup('restart-event-group', items, 'yes');
+
+      // Wait for the process to exit and restart (1-second delay + margin)
+      await new Promise(resolve => setTimeout(resolve, 2500));
+
+      assert.strictEqual(restartedGroup, 'restart-event-group');
+      assert.strictEqual(restartedItem, 'quick-exit');
+
+      await manager.killGroup('restart-event-group');
+    });
+  });
 });

package/tests/integration/serve.test.ts

@@ -0,0 +1,245 @@
+import { describe, it, before, after, afterEach, mock } from 'node:test';
+import assert from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import http from 'node:http';
+import net from 'node:net';
+
+let serverProcess: import('child_process').ChildProcess | null = null;
+
+describe('serve command integration tests', () => {
+  let testConfigDir: string;
+  let testConfigPath: string;
+  let originalHomeDir: string;
+
+  before(async () => {
+    testConfigDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cligr-serve-test-'));
+    testConfigPath = path.join(testConfigDir, '.cligr.yml');
+    originalHomeDir = os.homedir();
+    mock.method(os, 'homedir', () => testConfigDir);
+
+    // Build dist/index.js
+    const { spawnSync } = await import('child_process');
+    const result = spawnSync('npm', ['run', 'build'], { cwd: process.cwd(), stdio: 'pipe', shell: true });
+    if (result.status !== 0) {
+      throw new Error('Build failed: ' + result.stderr?.toString());
+    }
+  });
+
+  after(async () => {
+    mock.method(os, 'homedir', () => originalHomeDir);
+    if (fs.existsSync(testConfigDir)) {
+      fs.rmSync(testConfigDir, { recursive: true, force: true });
+    }
+    await stopServer();
+  });
+
+  afterEach(async () => {
+    await stopServer();
+  });
+
+  async function stopServer() {
+    const proc = serverProcess;
+    if (!proc) return;
+    serverProcess = null;
+    await new Promise<void>((resolve) => {
+      proc.once('exit', () => resolve());
+      proc.kill();
+      const timeout = setTimeout(() => {
+        if (!proc.killed) {
+          proc.kill('SIGKILL');
+        }
+        resolve();
+      }, 500);
+      proc.once('exit', () => clearTimeout(timeout));
+    });
+  }
+
+  async function getFreePort(): Promise<number> {
+    return new Promise((resolve, reject) => {
+      const srv = net.createServer();
+      srv.listen(0, () => {
+        const addr = srv.address() as net.AddressInfo;
+        srv.close(() => resolve(addr.port));
+      });
+      srv.on('error', reject);
+    });
+  }
+
+  function writeConfig() {
+    const configContent = `
+tools:
+  node:
+    cmd: node -e "console.log('$1')"
+groups:
+  web:
+    tool: node
+    restart: no
+    disabledItems:
+      - worker
+    items:
+      server: server
+      worker: worker
+`;
+    fs.writeFileSync(testConfigPath, configContent);
+  }
+
+  async function startServer(port: number) {
+    const { spawn } = await import('child_process');
+    const env = { ...process.env, USERPROFILE: testConfigDir, HOME: testConfigDir };
+    serverProcess = spawn('node', ['dist/index.js', 'serve', String(port)], {
+      cwd: process.cwd(),
+      stdio: 'pipe',
+      env
+    });
+
+    // Wait for server to be ready
+    await new Promise<void>((resolve, reject) => {
+      let output = '';
+      const onData = (data: Buffer) => {
+        output += data.toString();
+        if (output.includes('cligr serve running at')) {
+          cleanup();
+          resolve();
+        }
+      };
+      const onError = (data: Buffer) => {
+        output += data.toString();
+      };
+      serverProcess!.stdout!.on('data', onData);
+      serverProcess!.stderr!.on('data', onError);
+
+      const timeout = setTimeout(() => {
+        cleanup();
+        reject(new Error('Server startup timeout. Output: ' + output));
+      }, 5000);
+
+      const cleanup = () => {
+        clearTimeout(timeout);
+        serverProcess!.stdout!.off('data', onData);
+        serverProcess!.stderr!.off('data', onError);
+      };
+    });
+  }
+
+  async function httpGet(url: string): Promise<{ status: number; body: string }> {
+    return new Promise((resolve, reject) => {
+      const req = http.get(url, (res) => {
+        let body = '';
+        res.on('data', (chunk) => body += chunk);
+        res.on('end', () => resolve({ status: res.statusCode || 0, body }));
+      });
+      req.on('error', reject);
+      req.setTimeout(2000, () => reject(new Error('HTTP timeout')));
+    });
+  }
+
+  async function httpPost(url: string, body: object): Promise<{ status: number; body: string }> {
+    return new Promise((resolve, reject) => {
+      const data = JSON.stringify(body);
+      const req = http.request(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) }
+      }, (res) => {
+        let responseBody = '';
+        res.on('data', (chunk) => responseBody += chunk);
+        res.on('end', () => resolve({ status: res.statusCode || 0, body: responseBody }));
+      });
+      req.on('error', reject);
+      req.write(data);
+      req.end();
+    });
+  }
+
+  it('should serve the HTML UI', { timeout: 15000 }, async () => {
+    writeConfig();
+    const port = await getFreePort();
+    await startServer(port);
+
+    const res = await httpGet(`http://localhost:${port}/`);
+    assert.strictEqual(res.status, 200);
+    assert.ok(res.body.includes('cligr serve'));
+  });
+
+  it('should return groups via API', { timeout: 15000 }, async () => {
+    writeConfig();
+    const port = await getFreePort();
+    await startServer(port);
+
+    const res = await httpGet(`http://localhost:${port}/api/groups`);
+    assert.strictEqual(res.status, 200);
+    const data = JSON.parse(res.body);
+    assert.ok(Array.isArray(data.groups));
+    assert.strictEqual(data.groups.length, 1);
+    assert.strictEqual(data.groups[0].name, 'web');
+    assert.strictEqual(data.groups[0].running, false);
+    assert.strictEqual(data.groups[0].items.length, 2);
+    const serverItem = data.groups[0].items.find((i: any) => i.name === 'server');
+    const workerItem = data.groups[0].items.find((i: any) => i.name === 'worker');
+    assert.strictEqual(serverItem.enabled, true);
+    assert.strictEqual(workerItem.enabled, false);
+  });
+
+  it('should toggle group via API', { timeout: 15000 }, async () => {
+    writeConfig();
+    const port = await getFreePort();
+    await startServer(port);
+
+    const postRes = await httpPost(`http://localhost:${port}/api/groups/web/toggle`, { enabled: true });
+    assert.strictEqual(postRes.status, 200);
+
+    await new Promise(r => setTimeout(r, 300));
+
+    const getRes = await httpGet(`http://localhost:${port}/api/groups`);
+    const data = JSON.parse(getRes.body);
+    const web = data.groups.find((g: any) => g.name === 'web');
+    assert.strictEqual(web.running, true);
+
+    await httpPost(`http://localhost:${port}/api/groups/web/toggle`, { enabled: false });
+  });
+
+  it('should toggle item via API', { timeout: 15000 }, async () => {
+    writeConfig();
+    const port = await getFreePort();
+    await startServer(port);
+
+    const postRes = await httpPost(`http://localhost:${port}/api/groups/web/items/worker/toggle`, { enabled: true });
+    assert.strictEqual(postRes.status, 200);
+
+    const getRes = await httpGet(`http://localhost:${port}/api/groups`);
+    const data = JSON.parse(getRes.body);
+    const web = data.groups.find((g: any) => g.name === 'web');
+    const worker = web.items.find((i: any) => i.name === 'worker');
+    assert.strictEqual(worker.enabled, true);
+  });
+
+  it('should stream SSE events', { timeout: 15000 }, async () => {
+    writeConfig();
+    const port = await getFreePort();
+    await startServer(port);
+
+    return new Promise<void>((resolve, reject) => {
+      const req = http.get(`http://localhost:${port}/api/events`, (res) => {
+        let buffer = '';
+        res.on('data', (chunk) => {
+          buffer += chunk.toString();
+          if (buffer.includes('event: status')) {
+            req.destroy();
+            resolve();
+          }
+        });
+      });
+      req.on('error', reject);
+
+      setTimeout(() => {
+        httpPost(`http://localhost:${port}/api/groups/web/toggle`, { enabled: true }).catch(() => {});
+      }, 200);
+
+      setTimeout(() => {
+        req.destroy();
+        reject(new Error('SSE timeout'));
+      }, 3000);
+    });
+  });
+});