cligr 1.0.5 → 1.0.7

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;
@@ -53,15 +54,15 @@ groups:
     tool: docker
     restart: yes
     items:
-      - alpine,sh
-      - nginx,nginx,-p,80:80
+      alpine: alpine,sh
+      nginx: nginx,nginx,-p,80:80
 
   test2:
     tool: node
     restart: no
     items:
-      - server.js
-      - worker.js
+      server: server.js
+      worker: worker.js
 `;
 
       fs.writeFileSync(testConfigPath, configContent);
@@ -74,9 +75,9 @@ groups:
       assert.strictEqual(Object.keys(config.groups).length, 2);
       assert.strictEqual(config.groups.test1.tool, 'docker');
       assert.strictEqual(config.groups.test1.restart, 'yes');
-      assert.strictEqual(config.groups.test1.items.length, 2);
+      assert.strictEqual(Object.keys(config.groups.test1.items).length, 2);
       assert.strictEqual(config.groups.test2.tool, 'node');
-      assert.strictEqual(config.groups.test2.items.length, 2);
+      assert.strictEqual(Object.keys(config.groups.test2.items).length, 2);
     });
 
     it('should throw ConfigError when config file does not exist', () => {
@@ -149,8 +150,8 @@ groups:
     tool: echo
     restart: no
     items:
-      - hello
-      - world
+      hello: hello
+      world: world
 `;
 
       fs.writeFileSync(testConfigPath, configContent);
@@ -176,15 +177,15 @@ groups:
     tool: docker
     restart: unless-stopped
     items:
-      - nginx,nginx,-p,80:80
-      - redis,redis
+      nginx: nginx,nginx,-p,80:80
+      redis: redis,redis
 
   api:
     tool: node
     restart: yes
     items:
-      - server.js,3000
-      - worker.js
+      server: server.js,3000
+      worker: worker.js
 `;
 
       fs.writeFileSync(testConfigPath, configContent);
@@ -198,7 +199,7 @@ groups:
       assert.strictEqual(result.config.restart, 'unless-stopped');
       assert.strictEqual(result.tool, 'docker');
       assert.strictEqual(result.toolTemplate, 'docker run -it --rm');
-      assert.strictEqual(result.config.items.length, 2);
+      assert.strictEqual(result.items.length, 2);
     });
 
     it('should retrieve an existing group without registered tool', () => {
@@ -209,7 +210,7 @@ groups:
       assert.strictEqual(result.config.restart, 'yes');
       assert.strictEqual(result.tool, null); // No registered tool
       assert.strictEqual(result.toolTemplate, null);
-      assert.strictEqual(result.config.items.length, 2);
+      assert.strictEqual(result.items.length, 2);
     });
 
     it('should throw ConfigError for unknown group', () => {
@@ -235,19 +236,19 @@ groups:
     tool: echo
     restart: no
     items:
-      - test1
+      test1: test1
 
   group2:
     tool: echo
     restart: no
     items:
-      - test2
+      test2: test2
 
   group3:
     tool: echo
     restart: no
     items:
-      - test3
+      test3: test3
 `;
 
       fs.writeFileSync(testConfigPath, configContent);
@@ -284,7 +285,7 @@ groups:
     tool: echo
     restart: no
     items:
-      - test
+      test: test
 `;
 
       fs.writeFileSync(customConfigPath, configContent);
@@ -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');
@@ -322,7 +432,7 @@ groups:
     tool: echo
     restart: no
     items:
-      - from-home
+      fromHome: from-home
 `;
 
       const currentContent = `
@@ -331,7 +441,7 @@ groups:
     tool: echo
     restart: no
     items:
-      - from-current
+      fromCurrent: from-current
 `;
 
       // Write home config (mocked to testConfigDir)
@@ -353,21 +463,21 @@ groups:
   });
 
   describe('Edge cases', () => {
-    it('should handle empty items array', () => {
+    it('should handle empty items object', () => {
       const configContent = `
 groups:
   empty:
     tool: echo
     restart: no
-    items: []
+    items: {}
 `;
 
       fs.writeFileSync(testConfigPath, configContent);
 
       const loader = new ConfigLoader();
-      const config = loader.load();
+      const result = loader.getGroup('empty');
 
-      assert.strictEqual(config.groups.empty.items.length, 0);
+      assert.strictEqual(result.items.length, 0);
     });
 
     it('should handle special characters in item strings', () => {
@@ -377,9 +487,9 @@ groups:
     tool: echo
     restart: no
     items:
-      - "hello, world"
-      - "test,with,commas"
-      - "spaces test"
+      hello: "hello, world"
+      test: "test,with,commas"
+      spaces: "spaces test"
 `;
 
       fs.writeFileSync(testConfigPath, configContent);
@@ -387,9 +497,9 @@ groups:
       const loader = new ConfigLoader();
       const result = loader.getGroup('special');
 
-      assert.strictEqual(result.config.items.length, 3);
-      assert.strictEqual(result.config.items[0], 'hello, world');
-      assert.strictEqual(result.config.items[1], 'test,with,commas');
+      assert.strictEqual(result.items.length, 3);
+      assert.strictEqual(result.items[0].value, 'hello, world');
+      assert.strictEqual(result.items[1].value, 'test,with,commas');
     });
 
     it('should handle all restart policy values', () => {
@@ -399,19 +509,19 @@ groups:
     tool: echo
     restart: yes
     items:
-      - test
+      test: test
 
   restart-no:
     tool: echo
     restart: no
     items:
-      - test
+      test: test
 
   restart-unless-stopped:
     tool: echo
     restart: unless-stopped
     items:
-      - test
+      test: test
 `;
 
       fs.writeFileSync(testConfigPath, configContent);

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

@@ -263,8 +263,9 @@ describe('ProcessManager Integration Tests', () => {
   describe('Restart policies', () => {
     it('should not restart processes with restart=no', async () => {
       // Create a process that exits immediately
+      // Use node -e "process.exit(0)" for cross-platform compatibility
       const items: ProcessItem[] = [
-        { name: 'no-restart', args: [], fullCmd: process.platform === 'win32' ? 'exit 0' : 'true' }
+        { name: 'no-restart', args: [], fullCmd: 'node -e "process.exit(0)"' }
       ];
 
       manager.spawnGroup('no-restart-group', items, 'no');
@@ -359,6 +360,7 @@ describe('ProcessManager Integration Tests', () => {
     it('should work with Windows-specific commands', async function skipOnNonWindows() {
       if (process.platform !== 'win32') {
         this.skip();
+        return; // Ensure we don't continue execution after skip
       }
 
       const items: ProcessItem[] = [
@@ -375,6 +377,7 @@ describe('ProcessManager Integration Tests', () => {
     it('should work with Unix-specific commands', async function skipOnWindows() {
       if (process.platform === 'win32') {
         this.skip();
+        return; // Ensure we don't continue execution after skip
       }
 
       const items: ProcessItem[] = [
@@ -388,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);
+    });
+  });
+});