@hartvig/developer-control-center 0.8.2

package/src/core/event-bus.ts

@@ -0,0 +1,34 @@
+import { ProkomCommand } from '../config/types.js';
+
+export interface EventMap {
+  'task:start': [command: ProkomCommand];
+  'task:complete': [id: string, exitCode: number | null];
+  'task:output': [id: string, text: string];
+  'task:error': [id: string, error: Error];
+  [event: string]: any[];
+}
+
+type Handler<A extends any[]> = (...args: A) => void;
+
+export class EventBus {
+  private listeners = new Map<string, Set<(...args: any[]) => void>>();
+
+  on<E extends keyof EventMap>(event: E, handler: Handler<EventMap[E]>): void {
+    if (!this.listeners.has(event as string)) {
+      this.listeners.set(event as string, new Set());
+    }
+    this.listeners.get(event as string)!.add(handler as (...args: any[]) => void);
+  }
+
+  off<E extends keyof EventMap>(event: E, handler: Handler<EventMap[E]>): void {
+    this.listeners.get(event as string)?.delete(handler as (...args: any[]) => void);
+  }
+
+  emit<E extends keyof EventMap>(event: E, ...args: EventMap[E]): void {
+    this.listeners.get(event as string)?.forEach((h) => h(...args));
+  }
+
+  removeAll(): void {
+    this.listeners.clear();
+  }
+}

package/src/core/index.ts

@@ -0,0 +1,8 @@
+export { Runtime } from './runtime.js';
+export { EventBus } from './event-bus.js';
+export { TaskRunner } from './task-runner.js';
+export type { WorkspacePackage } from './workspaces.js';
+export { detectWorkspaces } from './workspaces.js';
+export type { CIInfo } from './ci.js';
+export { detectCI } from './ci.js';
+export { sendNotification } from './notifier.js';

package/src/core/notifier.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+vi.mock('child_process', () => {
+  const spawn = vi.fn(() => {
+    const child = { on: vi.fn(), unref: vi.fn(), stdout: null, stderr: null };
+    child.on.mockReturnValue(child);
+    return child;
+  });
+  return { spawn, execSync: vi.fn() };
+});
+
+import { sendNotification } from './notifier.js';
+
+describe('sendNotification', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('does not throw when called', () => {
+    expect(() => sendNotification('Test', 'Hello')).not.toThrow();
+  });
+
+  it('handles special characters in title', () => {
+    expect(() => sendNotification('Test "quote"', 'Message')).not.toThrow();
+  });
+
+  it('handles special characters in message', () => {
+    expect(() => sendNotification('Test', 'Message with "quotes" and $ymbols')).not.toThrow();
+  });
+});

package/src/core/notifier.ts

@@ -0,0 +1,34 @@
+import { spawn, ChildProcess } from 'child_process';
+
+const children = new Set<ChildProcess>();
+
+export function sendNotification(
+  title: string,
+  message: string,
+): void {
+  let child: ChildProcess | undefined;
+
+  switch (process.platform) {
+    case 'linux':
+      child = spawn('notify-send', [title, message], {
+        stdio: 'ignore',
+      });
+      break;
+    case 'darwin': {
+      const escaped = (s: string) => s.replace(/"/g, '\\"');
+      child = spawn('osascript', ['-e',
+        `display notification "${escaped(message)}" with title "${escaped(title)}"`,
+      ], { stdio: 'ignore' });
+      break;
+    }
+  }
+
+  if (child) {
+    children.add(child);
+    child.on('error', () => { /* notification failed, non-critical */ });
+    child.on('close', () => {
+      children.delete(child!);
+    });
+    child.unref();
+  }
+}

package/src/core/runtime.ts

@@ -0,0 +1,99 @@
+import { execSync } from 'child_process';
+import { ProkomConfig } from '../config/index.js';
+import { StatusStore } from '../status/index.js';
+import { PluginManager } from '../plugins/index.js';
+import { EventBus } from './event-bus.js';
+import { TaskRunner } from './task-runner.js';
+import { detectWorkspaces, WorkspacePackage } from './workspaces.js';
+import { sendNotification } from './notifier.js';
+import { detectCI, CIInfo } from './ci.js';
+import { timerPlugin } from './timer-plugin.js';
+
+function getGitBranch(): string | undefined {
+  try {
+    return execSync('git rev-parse --abbrev-ref HEAD', {
+      encoding: 'utf-8',
+      timeout: 2000,
+      stdio: 'pipe',
+    }).trim();
+  } catch {
+    return undefined;
+  }
+}
+
+export class Runtime {
+  readonly eventBus = new EventBus();
+  readonly statusStore = new StatusStore();
+  readonly taskRunner: TaskRunner;
+  readonly pluginManager = new PluginManager();
+  readonly gitBranch: string | undefined;
+  readonly workspaces: WorkspacePackage[];
+  readonly ci: CIInfo;
+
+  private persistenceDir = '.developer-control-center';
+  private unsubPersistence?: () => void;
+  private unsubNotifier?: () => void;
+
+  constructor(readonly config: ProkomConfig) {
+    this.taskRunner = new TaskRunner(
+      this.statusStore,
+      this.eventBus,
+      this.pluginManager,
+      config.commands,
+    );
+    this.pluginManager.register(timerPlugin);
+    this.gitBranch = getGitBranch();
+    this.workspaces = detectWorkspaces(process.cwd());
+    this.ci = detectCI();
+  }
+
+  async start(): Promise<void> {
+    this.statusStore.loadDir(this.persistenceDir);
+    this.unsubPersistence = this.statusStore.subscribe(() => {
+      try {
+        this.statusStore.saveDir(this.persistenceDir);
+      } catch {
+        // non-critical
+      }
+    });
+
+    await this.pluginManager.loadFromConfig(this.config.plugins);
+
+    if (this.config.notifications !== false) {
+      this.unsubNotifier = this.startNotifier();
+    }
+  }
+
+  stop(): void {
+    this.taskRunner.abortAll();
+    this.eventBus.removeAll();
+    this.unsubPersistence?.();
+    this.unsubNotifier?.();
+  }
+
+  private startNotifier(): () => void {
+    const onComplete = (id: string, exitCode: number | null) => {
+      const task = this.statusStore.getTask(id);
+      if (!task) return;
+      const ok = exitCode === 0;
+      sendNotification(
+        ok ? 'Task completed' : 'Task failed',
+        `${task.label} — ${ok ? 'success' : `exit ${exitCode}`}`,
+      );
+    };
+
+    const onError = (id: string) => {
+      const task = this.statusStore.getTask(id);
+      if (!task) return;
+      sendNotification('Task error', `${task.label} — failed with error`);
+    };
+
+    this.eventBus.on('task:complete', onComplete);
+    this.eventBus.on('task:error', onError);
+
+    return () => {
+      this.eventBus.off('task:complete', onComplete);
+      this.eventBus.off('task:error', onError);
+    };
+  }
+}

package/src/core/task-runner.ts

@@ -0,0 +1,408 @@
+import { spawn, ChildProcess } from 'child_process';
+import fs from 'fs';
+import { ProkomCommand } from '../config/types.js';
+import { StatusStore } from '../status/store.js';
+import { PluginManager } from '../plugins/index.js';
+import { EventBus } from './event-bus.js';
+
+class FileWatcher {
+  private watcher?: fs.FSWatcher;
+  private debounceTimer?: ReturnType<typeof setTimeout>;
+
+  watch(dir: string, onChange: () => void): void {
+    this.stop();
+    try {
+      this.watcher = fs.watch(dir, { recursive: true }, () => {
+        if (this.debounceTimer) clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(onChange, 500);
+      });
+    } catch {
+      console.warn(`[dcc] watch mode: recursive file watching not supported on ${dir}`);
+    }
+  }
+
+  stop(): void {
+    if (this.debounceTimer) clearTimeout(this.debounceTimer);
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = undefined;
+    }
+  }
+}
+
+export class TaskRunner {
+  private running = new Map<string, ChildProcess>();
+  private watchers = new Map<string, FileWatcher>();
+
+  constructor(
+    private statusStore: StatusStore,
+    private eventBus: EventBus,
+    private pluginManager?: PluginManager,
+    private commands: ProkomCommand[] = [],
+  ) {}
+
+  setCommands(commands: ProkomCommand[]): void {
+    this.commands = commands;
+  }
+
+  async run(command: ProkomCommand, skipClear = false): Promise<void> {
+    if (command.toggle) {
+      command = { ...command, command: command.toggle.start };
+    }
+    if (command.pipelineSteps) {
+      return this.runPipeline(command);
+    }
+    if (command.parallelSteps) {
+      return this.runParallelSteps(command);
+    }
+
+    if (!command.command) return;
+
+    const existing = this.statusStore.getTask(command.id);
+    if (existing?.status === 'running') {
+      return;
+    }
+
+    await this.pluginManager?.executeHook('beforeRun', command);
+
+    this.stopWatcher(command.id);
+    this.statusStore.pruneCompleted();
+    this.statusStore.updateTask(command.id, {
+      id: command.id,
+      label: command.label,
+      status: 'running',
+      output: '',
+      startTime: Date.now(),
+      endTime: undefined,
+      exitCode: undefined,
+      watchMode: false,
+    });
+
+    this.eventBus.emit('task:start', command);
+
+    const child = spawn(command.command, [], {
+      shell: true,
+      detached: true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      cwd: command.cwd,
+    });
+
+    this.running.set(command.id, child);
+
+    let output = '';
+
+    child.stdout?.on('data', (data: Buffer) => {
+      const text = data.toString();
+      output += text;
+      this.statusStore.updateTask(command.id, { output });
+      this.eventBus.emit('task:output', command.id, text);
+      this.pluginManager?.executeHook('onOutput', command.id, text);
+    });
+
+    child.stderr?.on('data', (data: Buffer) => {
+      const text = data.toString();
+      output += text;
+      this.statusStore.updateTask(command.id, { output });
+      this.eventBus.emit('task:output', command.id, text);
+      this.pluginManager?.executeHook('onOutput', command.id, text);
+    });
+
+    child.on('close', (exitCode) => {
+      this.running.delete(command.id);
+
+      const resultStatus = exitCode === 0 ? 'success' as const : 'failure' as const;
+
+      const result = {
+        exitCode: exitCode ?? undefined,
+        status: resultStatus,
+      };
+
+      this.statusStore.updateTask(command.id, {
+        status: resultStatus,
+        exitCode: result.exitCode,
+        endTime: Date.now(),
+      });
+      this.eventBus.emit('task:complete', command.id, exitCode);
+      this.pluginManager?.executeHook('afterRun', command, result);
+
+      if (command.watch) {
+        this.startWatcher(command);
+      }
+    });
+
+    child.on('error', (error) => {
+      this.running.delete(command.id);
+
+      const result = {
+        exitCode: -1,
+        status: 'failure' as const,
+      };
+
+      this.statusStore.updateTask(command.id, {
+        status: 'failure',
+        output: (output || '') + `\nError: ${error.message}`,
+        exitCode: -1,
+        endTime: Date.now(),
+      });
+      this.eventBus.emit('task:error', command.id, error);
+      this.pluginManager?.executeHook('onError', command.id, error);
+      this.pluginManager?.executeHook('afterRun', command, {
+        exitCode: -1,
+        status: 'failure',
+      });
+    });
+  }
+
+  abort(id: string): void {
+    const child = this.running.get(id);
+    if (child) {
+      this.killChild(child);
+      this.running.delete(id);
+    }
+    this.stopWatcher(id);
+  }
+
+  abortAll(): void {
+    for (const [id, child] of this.running) {
+      this.killChild(child);
+      this.running.delete(id);
+    }
+    for (const [id] of this.watchers) {
+      this.stopWatcher(id);
+    }
+  }
+
+  stop(command: ProkomCommand): void {
+    const child = this.running.get(command.id);
+    if (child) {
+      child.removeAllListeners('close');
+      child.removeAllListeners('error');
+      this.killChild(child);
+      this.running.delete(command.id);
+    }
+    this.stopWatcher(command.id);
+    this.statusStore.updateTask(command.id, {
+      status: 'success',
+      endTime: Date.now(),
+    });
+    this.eventBus.emit('task:complete', command.id, 0);
+    if (command.toggle?.stop) {
+      spawn(command.toggle.stop, {
+        shell: true,
+        stdio: 'ignore',
+        cwd: command.cwd,
+      });
+    }
+  }
+
+  private async runPipeline(command: ProkomCommand): Promise<void> {
+    const existing = this.statusStore.getTask(command.id);
+    if (existing?.status === 'running') return;
+
+    await this.pluginManager?.executeHook('beforeRun', command);
+
+    this.statusStore.updateTask(command.id, {
+      id: command.id,
+      label: command.label,
+      status: 'running',
+      output: '',
+      startTime: Date.now(),
+      endTime: undefined,
+      exitCode: undefined,
+    });
+
+    this.eventBus.emit('task:start', command);
+
+    const steps = command.pipelineSteps!;
+    let fullOutput = '';
+
+    for (let i = 0; i < steps.length; i++) {
+      const stepId = steps[i];
+      const stepCmd = this.commands.find((c) => c.id === stepId);
+      if (!stepCmd) {
+        fullOutput += `✗ Step "${stepId}" not found\n`;
+        this.finishPipeline(command, fullOutput, -1);
+        return;
+      }
+
+      fullOutput += `▶ Step ${i + 1}/${steps.length}: ${stepCmd.label}\n`;
+      this.statusStore.updateTask(command.id, { output: fullOutput });
+
+      const result = await this.runAndWait(stepCmd);
+
+      if (result.exitCode !== 0) {
+        fullOutput += `✗ Pipeline failed at step ${i + 1} (${stepCmd.label})\n`;
+        this.finishPipeline(command, fullOutput, result.exitCode ?? -1);
+        return;
+      }
+
+      fullOutput += `✓ Step ${i + 1} passed\n`;
+      this.statusStore.updateTask(command.id, { output: fullOutput });
+    }
+
+    fullOutput += '✓ Pipeline completed successfully\n';
+    this.finishPipeline(command, fullOutput, 0);
+  }
+
+  private async runParallelSteps(command: ProkomCommand): Promise<void> {
+    const existing = this.statusStore.getTask(command.id);
+    if (existing?.status === 'running') return;
+
+    await this.pluginManager?.executeHook('beforeRun', command);
+
+    this.statusStore.updateTask(command.id, {
+      id: command.id,
+      label: command.label,
+      status: 'running',
+      output: '',
+      startTime: Date.now(),
+      endTime: undefined,
+      exitCode: undefined,
+    });
+
+    this.eventBus.emit('task:start', command);
+
+    const steps = command.parallelSteps!;
+    const stepCommands = steps.map((id) =>
+      this.commands.find((c) => c.id === id),
+    );
+
+    const missing = stepCommands.findIndex((c) => !c);
+    if (missing >= 0) {
+      this.statusStore.updateTask(command.id, {
+        status: 'failure',
+        output: `✗ Step "${steps[missing]}" not found\n`,
+        exitCode: -1,
+        endTime: Date.now(),
+      });
+      this.eventBus.emit('task:complete', command.id, -1);
+      return;
+    }
+
+    const validCmds = stepCommands as ProkomCommand[];
+    let fullOutput = `▶ Running ${validCmds.length} steps in parallel\n`;
+
+    for (const cmd of validCmds) {
+      fullOutput += `  ▶ ${cmd.label}\n`;
+    }
+    this.statusStore.updateTask(command.id, { output: fullOutput });
+
+    const results = await Promise.all(
+      validCmds.map((cmd) => this.runAndWait(cmd)),
+    );
+
+    const failed: number[] = [];
+    for (let i = 0; i < results.length; i++) {
+      const ok = results[i].exitCode === 0;
+      fullOutput += `${ok ? '✓' : '✗'} ${validCmds[i].label} (exit ${results[i].exitCode ?? -1})\n`;
+      if (!ok) failed.push(i);
+    }
+
+    if (failed.length === 0) {
+      fullOutput += '✓ All parallel steps passed\n';
+    } else {
+      fullOutput += `✗ ${failed.length} step(s) failed\n`;
+    }
+
+    this.statusStore.updateTask(command.id, {
+      status: failed.length === 0 ? 'success' : 'failure',
+      output: fullOutput,
+      exitCode: failed.length === 0 ? 0 : -1,
+      endTime: Date.now(),
+    });
+    this.eventBus.emit('task:complete', command.id, failed.length === 0 ? 0 : -1);
+    this.pluginManager?.executeHook('afterRun', command, {
+      exitCode: failed.length === 0 ? 0 : -1,
+      status: failed.length === 0 ? 'success' : 'failure',
+    });
+  }
+
+  private finishPipeline(
+    command: ProkomCommand,
+    output: string,
+    exitCode: number,
+  ): void {
+    const status = exitCode === 0 ? 'success' : 'failure';
+    this.statusStore.updateTask(command.id, {
+      status,
+      output,
+      exitCode,
+      endTime: Date.now(),
+    });
+    this.eventBus.emit('task:complete', command.id, exitCode);
+    this.pluginManager?.executeHook('afterRun', command, {
+      exitCode,
+      status,
+    });
+  }
+
+  private runAndWait(
+    stepCmd: ProkomCommand,
+  ): Promise<{ exitCode: number | undefined }> {
+    return new Promise((resolve) => {
+      const onComplete = (id: string, exitCode: number | null) => {
+        if (id === stepCmd.id) {
+          cleanup();
+          resolve({ exitCode: exitCode ?? undefined });
+        }
+      };
+      const onError = (id: string) => {
+        if (id === stepCmd.id) {
+          cleanup();
+          resolve({ exitCode: -1 });
+        }
+      };
+      const cleanup = () => {
+        if (safetyTimer) clearTimeout(safetyTimer);
+        this.eventBus.off('task:complete', onComplete);
+        this.eventBus.off('task:error', onError);
+      };
+      const stepTimeout = stepCmd.timeout ?? 30_000;
+      const safetyTimer = stepTimeout > 0
+        ? setTimeout(() => {
+            cleanup();
+            resolve({ exitCode: -1 });
+          }, stepTimeout)
+        : null;
+      this.eventBus.on('task:complete', onComplete);
+      this.eventBus.on('task:error', onError);
+      this.run(stepCmd, true).catch(() => {
+        cleanup();
+        resolve({ exitCode: -1 });
+      });
+    });
+  }
+
+  private startWatcher(command: ProkomCommand): void {
+    const watcher = new FileWatcher();
+    watcher.watch(process.cwd(), () => {
+      this.run(command);
+    });
+    this.watchers.set(command.id, watcher);
+    this.statusStore.updateTask(command.id, { watchMode: true });
+  }
+
+  private killChild(child: ChildProcess): void {
+    if (child.pid) {
+      try {
+        process.kill(-child.pid, 'SIGTERM');
+        return;
+      } catch {
+        // fall through to child.kill()
+      }
+    }
+    try {
+      child.kill('SIGTERM');
+    } catch {
+      // already dead
+    }
+  }
+
+  private stopWatcher(id: string): void {
+    const watcher = this.watchers.get(id);
+    if (watcher) {
+      watcher.stop();
+      this.watchers.delete(id);
+    }
+  }
+}

package/src/core/timer-plugin.ts

@@ -0,0 +1,34 @@
+import fs from 'fs';
+import path from 'path';
+import type { Plugin } from '../plugins/types.js';
+
+const startTimes = new Map<string, number>();
+const TIMINGS_FILE = path.join(process.cwd(), '.developer-control-center', 'timings.jsonl');
+
+export const timerPlugin: Plugin = {
+  id: 'timer',
+  name: 'Timer',
+  hooks: {
+    beforeRun: (command) => {
+      startTimes.set(command.id, Date.now());
+    },
+    afterRun: (command, result) => {
+      const start = startTimes.get(command.id);
+      if (!start) return;
+      startTimes.delete(command.id);
+      try {
+        fs.mkdirSync(path.dirname(TIMINGS_FILE), { recursive: true });
+        fs.appendFileSync(TIMINGS_FILE, JSON.stringify({
+          id: command.id,
+          label: command.label,
+          duration: Date.now() - start,
+          exitCode: result.exitCode,
+          status: result.status,
+          timestamp: new Date().toISOString(),
+        }) + '\n');
+      } catch {
+        // non-critical
+      }
+    },
+  },
+};