@hartvig/developer-control-center 0.8.6 → 0.8.8

package/src/core/task-runner.ts

@@ -1,4 +1,4 @@
-import { spawn, execSync, ChildProcess } from 'child_process';
+import { spawn, exec, ChildProcess } from 'child_process';
 import fs from 'fs';
 import { ProkomCommand } from '../config/types.js';
 import { StatusStore } from '../status/store.js';
@@ -8,16 +8,19 @@ import { EventBus } from './event-bus.js';
 class FileWatcher {
   private watcher?: fs.FSWatcher;
   private debounceTimer?: ReturnType<typeof setTimeout>;
+  private exclude = /[/\\](node_modules|\.git)[/\\]/;
 
-  watch(dir: string, onChange: () => void): void {
+  watch(dir: string, onChange: () => void): boolean {
     this.stop();
     try {
-      this.watcher = fs.watch(dir, { recursive: true }, () => {
+      this.watcher = fs.watch(dir, { recursive: true }, (event, filename) => {
+        if (filename && this.exclude.test(filename.toString())) return;
         if (this.debounceTimer) clearTimeout(this.debounceTimer);
         this.debounceTimer = setTimeout(onChange, 500);
       });
+      return true;
     } catch {
-      console.warn(`[dcc] watch mode: recursive file watching not supported on ${dir}`);
+      return false;
     }
   }
 
@@ -62,7 +65,8 @@ export class TaskRunner {
 
     const existing = this.statusStore.getTask(command.id);
     if (existing?.status === 'running') {
-      return;
+      if (!command.parallel) return;
+      this.abort(command.id);
     }
 
     await this.pluginManager?.executeHook('beforeRun', command);
@@ -82,12 +86,26 @@ export class TaskRunner {
 
     this.eventBus.emit('task:start', command);
 
-    const child = spawn(command.command, [], {
-      shell: true,
-      detached: true,
-      stdio: ['ignore', 'pipe', 'pipe'],
-      cwd: command.cwd,
-    });
+    let child: ChildProcess;
+    try {
+      child = spawn(command.command, [], {
+        shell: true,
+        detached: true,
+        windowsHide: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        cwd: command.cwd,
+      });
+    } catch (err) {
+      this.statusStore.updateTask(command.id, {
+        status: 'failure',
+        output: `Failed to spawn: ${err instanceof Error ? err.message : String(err)}\n`,
+        exitCode: -1,
+        endTime: Date.now(),
+      });
+      this.eventBus.emit('task:error', command.id, err instanceof Error ? err : new Error(String(err)));
+      this.pluginManager?.executeHook('onError', command.id, err instanceof Error ? err : new Error(String(err)));
+      return;
+    }
 
     this.running.set(command.id, child);
 
@@ -95,6 +113,16 @@ export class TaskRunner {
       this.startCheck(command);
     }
 
+    let timedOut = false;
+    const timeoutMs = command.timeout ?? 0;
+    let timeoutTimer: ReturnType<typeof setTimeout> | null = null;
+    if (timeoutMs > 0) {
+      timeoutTimer = setTimeout(() => {
+        timedOut = true;
+        this.abort(command.id);
+      }, timeoutMs);
+    }
+
     let output = '';
 
     child.stdout?.on('data', (data: Buffer) => {
@@ -114,6 +142,7 @@ export class TaskRunner {
     });
 
     child.on('close', (exitCode) => {
+      if (timeoutTimer) clearTimeout(timeoutTimer);
       this.running.delete(command.id);
 
       if (command.toggle?.check) return;
@@ -169,6 +198,14 @@ export class TaskRunner {
     }
     this.stopWatcher(id);
     this.stopCheck(id);
+    const existing = this.statusStore.getTask(id);
+    if (existing?.status === 'running') {
+      this.statusStore.updateTask(id, {
+        status: 'failure',
+        endTime: Date.now(),
+      });
+      this.eventBus.emit('task:complete', id, -1);
+    }
   }
 
   abortAll(): void {
@@ -200,12 +237,27 @@ export class TaskRunner {
     });
     this.eventBus.emit('task:complete', command.id, 0);
     if (command.toggle?.stop) {
-      spawn(command.toggle.stop, {
+      const stopCmd = process.platform === 'win32'
+        ? this.windowsStopCommand(command.toggle.stop)
+        : command.toggle.stop;
+      spawn(stopCmd, {
         shell: true,
         stdio: 'ignore',
         cwd: command.cwd,
-      });
+      }).unref();
+    }
+  }
+
+  private windowsStopCommand(cmd: string): string {
+    const pkillMatch = cmd.match(/^pkill\s+-f\s+(.+)$/);
+    if (pkillMatch) {
+      return `taskkill /F /IM ${pkillMatch[1]}* 2>nul`;
     }
+    const killMatch = cmd.match(/^kill\s+-?\d*\s+(\d+)$/);
+    if (killMatch) {
+      return `taskkill /F /PID ${killMatch[1]} 2>nul`;
+    }
+    return cmd;
   }
 
   private async runPipeline(command: ProkomCommand): Promise<void> {
@@ -388,9 +440,13 @@ export class TaskRunner {
 
   private startWatcher(command: ProkomCommand): void {
     const watcher = new FileWatcher();
-    watcher.watch(process.cwd(), () => {
+    const ok = watcher.watch(process.cwd(), () => {
       this.run(command);
     });
+    if (!ok) {
+      this.eventBus.emit('task:output', command.id, `watch mode: recursive file watching not supported\n`);
+      return;
+    }
     this.watchers.set(command.id, watcher);
     this.statusStore.updateTask(command.id, { watchMode: true });
   }
@@ -425,16 +481,16 @@ export class TaskRunner {
 
     const checkCmd = command.toggle!.check!;
     const interval = setInterval(() => {
-      try {
-        execSync(checkCmd, { encoding: 'utf-8', timeout: 3000, stdio: 'pipe' });
-      } catch {
-        this.statusStore.updateTask(id, {
-          status: 'failure',
-          endTime: Date.now(),
-        });
-        this.eventBus.emit('task:complete', id, -1);
-        this.stopCheck(id);
-      }
+      exec(checkCmd, { encoding: 'utf-8', timeout: 3000 }, (err) => {
+        if (err) {
+          this.statusStore.updateTask(id, {
+            status: 'failure',
+            endTime: Date.now(),
+          });
+          this.eventBus.emit('task:complete', id, -1);
+          this.stopCheck(id);
+        }
+      });
     }, this.CHECK_INTERVAL);
 
     this.checkIntervals.set(id, interval);

package/src/core/timer-plugin.ts

@@ -1,9 +1,10 @@
 import fs from 'fs';
 import path from 'path';
 import type { Plugin } from '../plugins/types.js';
+import { PERSISTENCE_DIR } from './persistence.js';
 
 const startTimes = new Map<string, number>();
-const TIMINGS_FILE = path.join(process.cwd(), '.developer-control-center', 'timings.jsonl');
+const TIMINGS_FILE = path.join(process.cwd(), PERSISTENCE_DIR, 'timings.jsonl');
 
 export const timerPlugin: Plugin = {
   id: 'timer',

package/src/plugins/manager.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { describe, it, expect, beforeEach } from 'vitest';
 import { PluginManager } from './manager.js';
 import type { Plugin } from './types.js';
 
@@ -68,7 +68,8 @@ describe('PluginManager', () => {
   });
 
   it('does not throw when a hook fails', async () => {
-    vi.spyOn(console, 'error').mockImplementation(() => {});
+    const errors: string[] = [];
+    pm = new PluginManager((msg) => errors.push(msg));
     pm.register({
       id: 'bad',
       name: 'Bad',
@@ -77,6 +78,8 @@ describe('PluginManager', () => {
     await expect(
       pm.executeHook('beforeRun', { id: 'x', label: 'X', command: 'x' }),
     ).resolves.toBeUndefined();
+    expect(errors.length).toBe(1);
+    expect(errors[0]).toContain('bad');
   });
 
   it('skips plugin with no hooks for the requested hook', async () => {

package/src/plugins/manager.ts

@@ -5,6 +5,10 @@ type HookName = keyof PluginHooks;
 export class PluginManager {
   private plugins = new Map<string, Plugin>();
 
+  constructor(
+    private onError?: (msg: string, err: unknown) => void,
+  ) {}
+
   register(plugin: Plugin): void {
     this.plugins.set(plugin.id, plugin);
   }
@@ -33,7 +37,7 @@ export class PluginManager {
         try {
           await Promise.resolve(fn(...args));
         } catch (e) {
-          console.error(`Plugin ${plugin.id} ${hook} error:`, e);
+          this.onError?.(`Plugin ${plugin.id} ${hook} error`, e);
         }
       }
     }
@@ -47,7 +51,7 @@ export class PluginManager {
         const p: Plugin = mod.default || mod;
         this.register(p);
       } catch (e) {
-        console.error(`Failed to load plugin "${name}":`, e);
+        this.onError?.(`Failed to load plugin "${name}"`, e);
       }
     }
   }

package/src/ui/app.test.tsx

@@ -0,0 +1,177 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import React, { act } from 'react';
+import { render } from 'ink-testing-library';
+import { App } from './app.js';
+import { EventBus } from '../core/event-bus.js';
+import { StatusStore } from '../status/store.js';
+
+function createMockRuntime() {
+  const eventBus = new EventBus();
+  const statusStore = new StatusStore();
+  const taskRunner = {
+    run: vi.fn().mockResolvedValue(undefined),
+    stop: vi.fn(),
+    abortAll: vi.fn(),
+    setCommands: vi.fn(),
+    abort: vi.fn(),
+  };
+  return {
+    eventBus,
+    statusStore,
+    taskRunner,
+    pluginManager: { register: vi.fn(), executeHook: vi.fn(), loadFromConfig: vi.fn() },
+    gitBranch: 'main',
+    workspaces: [] as { name: string; path: string }[],
+    ci: { isCI: false, name: undefined as string | undefined },
+    stop: vi.fn(),
+  };
+}
+
+const baseConfig = {
+  name: 'test-project',
+  commands: [
+    { id: 'build', label: 'Build', command: 'npm run build', description: 'Build the project' },
+    { id: 'test', label: 'Test', command: 'npm test' },
+  ],
+};
+
+describe('App', () => {
+  let runtime: ReturnType<typeof createMockRuntime>;
+
+  beforeEach(() => {
+    runtime = createMockRuntime() as any;
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('renders the project name in the header', () => {
+    const { lastFrame } = render(<App config={baseConfig} runtime={runtime as any} />);
+    expect(lastFrame()).toContain('test-project');
+  });
+
+  it('shows the git branch', () => {
+    const { lastFrame } = render(<App config={baseConfig} runtime={runtime as any} />);
+    expect(lastFrame()).toContain('⎇ main');
+  });
+
+  it('renders command items', () => {
+    const { lastFrame } = render(<App config={baseConfig} runtime={runtime as any} />);
+    const frame = lastFrame();
+    expect(frame).toContain('Build');
+    expect(frame).toContain('Test');
+  });
+
+  it('shows no tasks yet in output panel', () => {
+    const { lastFrame } = render(<App config={baseConfig} runtime={runtime as any} />);
+    expect(lastFrame()).toContain('No tasks yet');
+  });
+
+  it('shows selected command description in footer', () => {
+    const { lastFrame } = render(<App config={baseConfig} runtime={runtime as any} />);
+    expect(lastFrame()).toContain('Build the project');
+  });
+
+  it('renders with groups', () => {
+    const config = {
+      name: 'test',
+      commands: [
+        { id: 'build', label: 'Build', command: 'npm run build', group: 'Build' },
+        { id: 'test', label: 'Test', command: 'npm test', group: 'Test' },
+      ],
+    };
+    const { lastFrame } = render(<App config={config} runtime={runtime as any} />);
+    expect(lastFrame()).toContain('▶ Build');
+    expect(lastFrame()).toContain('▶ Test');
+  });
+
+  it('shows active profile in header', () => {
+    const config = {
+      name: 'test',
+      commands: [{ id: 'build', label: 'Build', command: 'npm run build' }],
+      profiles: { prod: { commands: [] } },
+      profile: 'prod',
+    };
+    const { lastFrame } = render(<App config={config} runtime={runtime as any} />);
+    expect(lastFrame()).toContain('⚙ prod');
+  });
+
+  it('shows workspace count when present', () => {
+    runtime.workspaces = [{ name: 'pkg-a', path: '/pkg-a' }];
+    const { lastFrame } = render(<App config={baseConfig} runtime={runtime as any} />);
+    expect(lastFrame()).toContain('⊞ 1');
+  });
+
+  it('handles status store updates', () => {
+    const { lastFrame } = render(<App config={baseConfig} runtime={runtime as any} />);
+    act(() => {
+      runtime.statusStore.updateTask('build', {
+        id: 'build',
+        label: 'Build',
+        status: 'running',
+        output: 'compiling...',
+      });
+    });
+    const frame = lastFrame();
+    expect(frame).toContain('compiling...');
+  });
+
+  it('shows confirm prompt for confirm commands', () => {
+    const config = {
+      name: 'test',
+      commands: [
+        { id: 'deploy', label: 'Deploy', command: 'npm run deploy', confirm: true },
+      ],
+    };
+    const { lastFrame, stdin } = render(<App config={config} runtime={runtime as any} />);
+    act(() => { stdin.write('\r'); });
+    const frame = lastFrame();
+    expect(frame).toContain('⚠');
+  });
+
+  it('shows DCC in header', () => {
+    const { lastFrame } = render(<App config={baseConfig} runtime={runtime as any} />);
+    expect(lastFrame()).toContain('DCC');
+  });
+
+  it('shows status pane (middle panel)', () => {
+    const { lastFrame } = render(<App config={baseConfig} runtime={runtime as any} />);
+    expect(lastFrame()).toContain('Status');
+  });
+
+  it('shows output pane (right panel)', () => {
+    const { lastFrame } = render(<App config={baseConfig} runtime={runtime as any} />);
+    expect(lastFrame()).toContain('Output');
+  });
+
+  it('shows CI badge when in CI environment', () => {
+    runtime.ci = { isCI: true, name: 'GitHub Actions' };
+    const { lastFrame } = render(<App config={baseConfig} runtime={runtime as any} />);
+    expect(lastFrame()).toContain('⊡ GitHub Actions');
+  });
+
+  it('switches pane focus on Tab', () => {
+    const { lastFrame, stdin } = render(<App config={baseConfig} runtime={runtime as any} />);
+    act(() => { stdin.write('\t'); });
+    const frame = lastFrame();
+    expect(frame).toContain('Output');
+  });
+
+  it('enters search mode on / key', () => {
+    const { lastFrame, stdin } = render(<App config={baseConfig} runtime={runtime as any} />);
+    act(() => { stdin.write('/'); });
+    expect(lastFrame()).toContain('🔍');
+  });
+
+  it('shows default footer hint for command without description', () => {
+    const config = {
+      name: 'test',
+      commands: [
+        { id: 'foo', label: 'Foo', command: 'echo foo' },
+      ],
+    };
+    const { lastFrame } = render(<App config={config} runtime={runtime as any} />);
+    expect(lastFrame()).toContain('Enter to run');
+  });
+});