dev-cockpit 0.1.0 → 0.2.2

package/dist/health/scheduler.js

@@ -1,107 +0,0 @@
-import path from 'node:path';
-import { runChecks } from './runner.js';
-const DEFAULT_FSEVENT_DEBOUNCE_MS = 500;
-const DEFAULT_LOCKFILE_NAMES = ['composer.lock', 'package-lock.json', 'yarn.lock'];
-const DEFAULT_DOCKER_POLL_MS = 5000;
-export class HealthScheduler {
-    deps;
-    debounceMs;
-    lockfileNames;
-    dockerPollMs;
-    fsDebounceTimer = null;
-    dockerPollTimer = null;
-    running = false;
-    constructor(deps) {
-        this.deps = deps;
-        this.debounceMs = deps.fsEventDebounceMs ?? DEFAULT_FSEVENT_DEBOUNCE_MS;
-        this.lockfileNames = new Set(deps.lockfileNames ?? DEFAULT_LOCKFILE_NAMES);
-        this.dockerPollMs = deps.dockerPollIntervalMs ?? DEFAULT_DOCKER_POLL_MS;
-    }
-    async start() {
-        if (this.running)
-            return;
-        this.running = true;
-        await this.runTrigger(['startup']);
-        // Start the docker poll only if some check actually subscribes to it.
-        // Otherwise we'd waste a setInterval on a no-op. Disable entirely with
-        // dockerPollIntervalMs: 0.
-        const hasDockerChecks = this.deps.checks.some((c) => c.triggers.includes('docker'));
-        if (hasDockerChecks && this.dockerPollMs > 0) {
-            this.dockerPollTimer = setInterval(() => {
-                if (!this.running)
-                    return;
-                void this.runTrigger(['docker']);
-            }, this.dockerPollMs);
-        }
-    }
-    onFsEvent(filePath) {
-        if (!this.running)
-            return;
-        const fileName = path.basename(filePath);
-        const isLockfile = this.lockfileNames.has(fileName);
-        const triggers = ['fsevent'];
-        if (isLockfile) {
-            triggers.push('lockfile');
-        }
-        this.debounceRun(triggers);
-    }
-    onDockerEvent() {
-        if (!this.running)
-            return;
-        this.debounceRun(['docker']);
-    }
-    /**
-     * Force every registered check to re-run, regardless of triggers. Used
-     * after a remediation completes so the user gets immediate visual
-     * confirmation without waiting for an external fsevent.
-     */
-    async runAll() {
-        if (!this.running)
-            return;
-        const { checks, ctx, onHealthUpdate } = this.deps;
-        const results = await Promise.all(checks.map(async (check) => {
-            try {
-                return await check.predicate(ctx);
-            }
-            catch (err) {
-                return {
-                    id: check.id,
-                    label: check.label,
-                    severity: 'warn',
-                    detail: `check failed with error: ${String(err)}`,
-                    remediationKey: check.remediation.key,
-                };
-            }
-        }));
-        if (results.length > 0) {
-            onHealthUpdate(results);
-        }
-    }
-    stop() {
-        this.running = false;
-        if (this.fsDebounceTimer) {
-            clearTimeout(this.fsDebounceTimer);
-            this.fsDebounceTimer = null;
-        }
-        if (this.dockerPollTimer) {
-            clearInterval(this.dockerPollTimer);
-            this.dockerPollTimer = null;
-        }
-    }
-    debounceRun(triggers) {
-        if (this.fsDebounceTimer) {
-            clearTimeout(this.fsDebounceTimer);
-        }
-        this.fsDebounceTimer = setTimeout(() => {
-            this.fsDebounceTimer = null;
-            void this.runTrigger(triggers);
-        }, this.debounceMs);
-    }
-    async runTrigger(triggers) {
-        const { checks, ctx, onHealthUpdate } = this.deps;
-        const results = await runChecks(checks, triggers, ctx);
-        if (results.length > 0) {
-            onHealthUpdate(results);
-        }
-    }
-}

package/dist/health/types.js

@@ -1 +0,0 @@
-export {};

package/dist/health/useHealth.js

@@ -1,122 +0,0 @@
-import { useEffect, useMemo, useRef } from 'react';
-import { cockpitStore } from '../cockpit/state/store.js';
-import { detectTransitions, notify } from '../core/notifier.js';
-import { HealthScheduler } from './scheduler.js';
-import { runRemediation as dispatchRemediationKey } from './remediations.js';
-import { resolveNotify } from './notify-resolver.js';
-import { buildHealthRegistry } from './registry.js';
-import { buildHealthContext } from './context.js';
-export function useHealth(opts) {
-    const checks = useMemo(() => {
-        if (!opts)
-            return [];
-        return buildHealthRegistry({
-            profileChecks: opts.profileChecks,
-            configEntries: opts.configEntries,
-        });
-    }, [opts]);
-    const checksRef = useRef(checks);
-    const ctxRef = useRef(opts?.ctx);
-    const optsRef = useRef(opts);
-    const schedulerRef = useRef(null);
-    // Keep refs current so the orchestration loop sees latest options without
-    // requiring full teardown on prop churn.
-    useEffect(() => {
-        checksRef.current = checks;
-        ctxRef.current = opts?.ctx;
-        optsRef.current = opts;
-    }, [checks, opts]);
-    useEffect(() => {
-        if (!opts)
-            return;
-        if (checks.length === 0)
-            return;
-        const scheduler = new HealthScheduler({
-            checks,
-            ctx: opts.ctx ?? buildDefaultCtx(opts.workspaceRoot),
-            onHealthUpdate: (statuses) => {
-                // Trigger-scoped runs (fsevent, lockfile, docker) produce only the
-                // statuses for checks subscribed to that trigger. If we replaced the
-                // full array with the partial set, every other check's last-known
-                // state would be wiped on each poll. Merge by id, replacing any
-                // existing entry with the new value while preserving the rest.
-                const prev = cockpitStore.getState().health;
-                const merged = mergeHealthStatuses(prev, statuses);
-                const transitions = detectTransitions(prev, statuses);
-                const sessionEnabled = cockpitStore.getState().notificationsEnabledSession;
-                for (const t of transitions) {
-                    const owner = checksRef.current.find((c) => c.id === t.id);
-                    if (!resolveNotify(t, opts.notifications, owner?.notify))
-                        continue;
-                    notify(t, {
-                        config: opts.notifications,
-                        sessionEnabled,
-                        appName: opts.appName ?? 'cockpit',
-                        sender: opts.notificationSender,
-                    });
-                }
-                cockpitStore.getState().setHealth(merged);
-                opts.onResults?.(merged);
-            },
-        });
-        schedulerRef.current = scheduler;
-        void scheduler.start();
-        const unsub = opts.subscribeFsEvents?.((filePath) => scheduler.onFsEvent(filePath));
-        return () => {
-            unsub?.();
-            scheduler.stop();
-            schedulerRef.current = null;
-        };
-    }, [checks]);
-    if (!opts)
-        return null;
-    return {
-        runRemediation: (key) => {
-            const list = checksRef.current;
-            const ctx = ctxRef.current ?? buildDefaultCtx(optsRef.current?.workspaceRoot ?? '.');
-            const check = list.find((c) => c.remediation.key === key);
-            if (!check)
-                return null;
-            const promise = dispatchRemediationKey(key, list, ctx, optsRef.current?.workspaceRoot ?? '.').finally(() => {
-                // Re-run all checks after the remediation completes so the user sees
-                // the new state immediately, without waiting for an external fsevent.
-                void schedulerRef.current?.runAll();
-            });
-            return {
-                label: check.remediation.label,
-                promise,
-                healthId: check.id,
-                healthLabel: check.label,
-            };
-        },
-    };
-}
-function buildDefaultCtx(workspaceRoot) {
-    return buildHealthContext(workspaceRoot);
-}
-/**
- * Merge a partial set of fresh statuses into the previous full array,
- * preserving original order and updating any entry whose id matches.
- * Statuses present in `next` but not in `prev` are appended at the end —
- * shouldn't happen during normal operation (the registry is fixed) but
- * keeps the function total.
- */
-function mergeHealthStatuses(prev, next) {
-    if (next.length === 0)
-        return prev;
-    const byId = new Map();
-    for (const s of next)
-        byId.set(s.id, s);
-    const merged = [];
-    const seen = new Set();
-    for (const s of prev) {
-        const updated = byId.get(s.id);
-        merged.push(updated ?? s);
-        seen.add(s.id);
-    }
-    for (const s of next) {
-        if (!seen.has(s.id))
-            merged.push(s);
-    }
-    return merged;
-}

package/dist/lint/reactive.js

@@ -1,131 +0,0 @@
-/**
- * Reactive lint engine.
- *
- * Pure command-selection function: given a file extension and a repo's lint
- * config, returns the lint command (or undefined if none configured).
- *
- * The debounced runner lives here too, backed by spawnStream. Debounce is
- * per-file (keyed by absolute path), 300ms.
- *
- * Lint result is reported via `onLintResult` — this module never mutates
- * watcher status. Watcher lifecycle (idle/running/failing) is exclusively
- * owned by WatcherManager.
- */
-import path from 'node:path';
-import { spawnStream } from '../core/subprocess.js';
-const EXT_TO_LINT_KEY = {
-    '.js': 'js',
-    '.jsx': 'js',
-    '.ts': 'js',
-    '.tsx': 'js',
-    '.mjs': 'js',
-    '.cjs': 'js',
-    '.css': 'css',
-    '.scss': 'css',
-    '.sass': 'css',
-    '.less': 'css',
-    '.php': 'php',
-};
-/** Returns the lint command for a file, or undefined if none configured. Pure. */
-export function selectLintCommand(filePath, lintConfig) {
-    const ext = path.extname(filePath).toLowerCase();
-    const key = EXT_TO_LINT_KEY[ext];
-    if (!key)
-        return undefined;
-    return lintConfig[key];
-}
-const debounceTimers = new Map();
-const DEBOUNCE_MS = 300;
-/**
- * Schedule a lint run for `filePath`, debounced 300ms per file. Files with
- * no matching lint command are silently skipped.
- */
-export function scheduleLint(filePath, opts) {
-    const cmd = selectLintCommand(filePath, opts.lintConfig);
-    if (!cmd)
-        return;
-    const existing = debounceTimers.get(filePath);
-    if (existing !== undefined)
-        clearTimeout(existing);
-    const timer = setTimeout(() => {
-        debounceTimers.delete(filePath);
-        void runLintCmd(filePath, cmd, opts);
-    }, DEBOUNCE_MS);
-    debounceTimers.set(filePath, timer);
-}
-/**
- * Run all configured lint commands for a repo (js, css, php) in parallel.
- * Aggregates pass/fail — any failing kind → overall 'fail', all pass → 'pass'.
- */
-export async function runAllLints(opts) {
-    const { repoName, repoRootDir, lintConfig, appendOutput, onLintResult } = opts;
-    const spawnFn = opts.spawn ?? spawnStream;
-    const kinds = ['js', 'css', 'php'];
-    const toRun = [];
-    for (const kind of kinds) {
-        const cmd = lintConfig[kind];
-        if (cmd)
-            toRun.push({ kind, cmd });
-    }
-    if (toRun.length === 0) {
-        appendOutput({
-            ts: Date.now(),
-            source: repoName,
-            severity: 'info',
-            text: 'lint: no linters configured for this repo',
-        });
-        return;
-    }
-    const results = await Promise.all(toRun.map(async ({ kind, cmd }) => {
-        const [exe, ...args] = cmd.split(/\s+/);
-        if (!exe)
-            return { kind, passed: false };
-        const handle = spawnFn(exe, args, {
-            cwd: repoRootDir,
-            onStdout: (line) => appendOutput({ ts: Date.now(), source: repoName, severity: 'info', text: line }),
-            onStderr: (line) => appendOutput({ ts: Date.now(), source: repoName, severity: 'warn', text: line }),
-        });
-        const code = await handle.exitCode;
-        const passed = code === 0;
-        appendOutput({
-            ts: Date.now(),
-            source: repoName,
-            severity: passed ? 'info' : 'error',
-            text: `lint [${kind}]: ${passed ? 'passed' : `FAILED (exit ${code})`}`,
-        });
-        return { kind, passed };
-    }));
-    const allPassed = results.every((r) => r.passed);
-    onLintResult(allPassed ? 'pass' : 'fail');
-}
-async function runLintCmd(filePath, cmd, opts) {
-    const { repoName, repoRootDir, appendOutput, onLintResult } = opts;
-    const spawnFn = opts.spawn ?? spawnStream;
-    const [exe, ...args] = cmd.split(/\s+/);
-    if (!exe)
-        return;
-    const handle = spawnFn(exe, args, {
-        cwd: repoRootDir,
-        onStdout: (line) => appendOutput({ ts: Date.now(), source: repoName, severity: 'info', text: line }),
-        onStderr: (line) => appendOutput({ ts: Date.now(), source: repoName, severity: 'warn', text: line }),
-    });
-    const code = await handle.exitCode;
-    if (code === 0) {
-        appendOutput({
-            ts: Date.now(),
-            source: repoName,
-            severity: 'info',
-            text: `lint passed for ${path.basename(filePath)}`,
-        });
-        onLintResult('pass');
-    }
-    else {
-        appendOutput({
-            ts: Date.now(),
-            source: repoName,
-            severity: 'error',
-            text: `lint FAILED for ${path.basename(filePath)} (exit ${code})`,
-        });
-        onLintResult('fail');
-    }
-}

package/dist/runCockpit.js

@@ -1,75 +0,0 @@
-/**
- * runCockpit — boot the cockpit TUI.
- *
- * Responsibilities (Phase 3, shell-only):
- *  - Switch the terminal into the alternate-screen buffer (so the cockpit fills
- *    the window without scrolling shell history out of view; restored on exit
- *    or uncaughtException).
- *  - Seed `cockpitStore.helpConfig` from `profile.helpSources` + `profile.defaultHelpPage`.
- *  - Render `<Cockpit>` with the caller-supplied handlers via `ink.render`.
- *  - Return `waitUntilExit` and `restore` for the caller to await + clean up.
- *
- * Domain-specific boot (loading config, building watchers, scheduling health
- * checks, docker tailers) lives in the consumer's `dev` command; this entry
- * stays narrow and reusable.
- */
-import React from 'react';
-import { render } from 'ink';
-import { Cockpit } from './cockpit/Cockpit.js';
-import { cockpitStore } from './cockpit/state/store.js';
-const ENTER_ALT_SCREEN = '\x1b[?1049h\x1b[H';
-const EXIT_ALT_SCREEN = '\x1b[?1049l';
-export function runCockpit(opts = {}) {
-    const { profile, noAltScreen, ...cockpitProps } = opts;
-    // Seed helpConfig from profile.
-    if (profile) {
-        const sources = (profile.helpSources ?? []).map((src) => ({
-            page: src.path == null && src.content != null
-                ? {
-                    slug: src.id,
-                    title: src.title ?? src.id,
-                    path: '',
-                    body: src.content,
-                }
-                : undefined,
-            path: src.path,
-            id: src.id,
-            omit: src.omit,
-        }));
-        cockpitStore.getState().setHelpConfig({
-            sources,
-            defaultPage: profile.defaultHelpPage,
-        });
-    }
-    // Alternate-screen buffer.
-    let restored = false;
-    const restore = () => {
-        if (restored)
-            return;
-        restored = true;
-        if (!noAltScreen) {
-            process.stdout.write(EXIT_ALT_SCREEN);
-        }
-    };
-    if (!noAltScreen) {
-        process.stdout.write(ENTER_ALT_SCREEN);
-        process.once('exit', restore);
-        process.once('uncaughtException', (err) => {
-            restore();
-            throw err;
-        });
-    }
-    const ink = render(React.createElement(Cockpit, cockpitProps), { exitOnCtrlC: true });
-    return {
-        waitUntilExit: async () => {
-            try {
-                await ink.waitUntilExit();
-            }
-            finally {
-                restore();
-            }
-        },
-        restore,
-        ink,
-    };
-}

package/dist/watchers/manager.js

@@ -1,239 +0,0 @@
-/**
- * WatcherManager — orchestrates chokidar filesystem watchers and per-repo
- * watcher subprocesses.
- *
- * Responsibilities:
- *  - Subscribe to chokidar for the union of all repo discover globs.
- *  - On file change in an idle repo → spawn the repo's watch command.
- *  - On watcher exit (code 0) → mark repo idle; non-zero → failing.
- *  - Trigger reactive lint via scheduleLint on each change.
- *
- * Public API: start(), stop(), toggle(repoName), rebuild(repoName), lint(repoName).
- *
- * All subprocess work goes through `core/subprocess.spawnStream` (DRY).
- */
-import fs from 'node:fs';
-import path from 'node:path';
-import chokidar from 'chokidar';
-import { spawnStream } from '../core/subprocess.js';
-import { mapPathToRepo } from './path-mapper.js';
-import { scheduleLint, runAllLints } from '../lint/reactive.js';
-/**
- * Detect WSL2 by reading /proc/version (Linux-only).
- * Native Linux + macOS don't need polling. Set DEV_COCKPIT_CHOKIDAR_POLLING=1
- * to force polling as an escape hatch.
- */
-function detectUsePolling() {
-    if (process.env['DEV_COCKPIT_CHOKIDAR_POLLING'] === '1')
-        return true;
-    try {
-        const version = fs.readFileSync('/proc/version', 'utf8');
-        return /microsoft|wsl/i.test(version);
-    }
-    catch {
-        return false;
-    }
-}
-export class WatcherManager {
-    repos = new Map();
-    prefixEntries = [];
-    handles = new Map();
-    fsWatcher = null;
-    deps;
-    buildOutcomes = new Map();
-    fsEventListeners = new Set();
-    constructor(repos, deps) {
-        this.deps = {
-            appendOutput: deps.appendOutput,
-            setRepoStatus: deps.setRepoStatus,
-            setLintStatus: deps.setLintStatus,
-            spawn: deps.spawn ?? spawnStream,
-            onBuildOutcome: deps.onBuildOutcome ?? null,
-        };
-        for (const repo of repos) {
-            this.repos.set(repo.config.name, repo);
-            this.prefixEntries.push({ name: repo.config.name, rootDir: repo.rootDir });
-        }
-    }
-    start() {
-        if (this.fsWatcher)
-            return;
-        const globs = [];
-        for (const [, managed] of this.repos) {
-            for (const pattern of managed.config.discover) {
-                globs.push(path.join(managed.rootDir, pattern));
-            }
-        }
-        if (globs.length === 0)
-            return;
-        const usePolling = detectUsePolling();
-        this.fsWatcher = chokidar.watch(globs, {
-            usePolling,
-            ignoreInitial: true,
-            ignored: /(^|[/\\])\../,
-        });
-        this.fsWatcher.on('change', (filePath) => this.handleChange(filePath));
-        this.fsWatcher.on('add', (filePath) => this.handleChange(filePath));
-        this.fsWatcher.on('error', (err) => {
-            this.deps.appendOutput({
-                ts: Date.now(),
-                source: 'watcher',
-                severity: 'error',
-                text: `chokidar error: ${String(err)}`,
-            });
-        });
-    }
-    async stop() {
-        // Snapshot exitCode promises before killing so we can await reap after
-        // SIGTERM is delivered. Without awaiting, Node's event loop keeps the
-        // ChildProcess + stdio socket handles alive, which blocks process exit
-        // on the consumer side.
-        const reaps = [];
-        for (const [name, handle] of this.handles) {
-            reaps.push(handle.exitCode.catch(() => undefined));
-            this.killHandle(name);
-        }
-        await Promise.all(reaps);
-        if (this.fsWatcher) {
-            await this.fsWatcher.close();
-            this.fsWatcher = null;
-        }
-    }
-    toggle(repoName) {
-        const handle = this.handles.get(repoName);
-        if (handle) {
-            this.killHandle(repoName);
-            this.deps.setRepoStatus(repoName, 'idle');
-        }
-        else {
-            void this.spawnWatcher(repoName);
-        }
-    }
-    rebuild(repoName) {
-        this.killHandle(repoName);
-        void this.spawnWatcher(repoName);
-    }
-    lint(repoName) {
-        const managed = this.repos.get(repoName);
-        if (!managed)
-            return;
-        void runAllLints({
-            repoName,
-            repoRootDir: managed.rootDir,
-            lintConfig: managed.config.lint,
-            appendOutput: this.deps.appendOutput,
-            onLintResult: (result) => this.deps.setLintStatus(repoName, result),
-            spawn: this.deps.spawn,
-        });
-    }
-    /**
-     * Subscribe to filesystem-event notifications. The listener is called for
-     * every detected change before the watcher-launch logic. Returns an
-     * unsubscribe function.
-     */
-    subscribeFsEvents(listener) {
-        this.fsEventListeners.add(listener);
-        return () => {
-            this.fsEventListeners.delete(listener);
-        };
-    }
-    // ─── Private ────────────────────────────────────────────────────────────
-    handleChange(filePath) {
-        const repoName = mapPathToRepo(filePath, this.prefixEntries);
-        if (!repoName)
-            return;
-        const managed = this.repos.get(repoName);
-        if (!managed)
-            return;
-        for (const listener of this.fsEventListeners) {
-            listener(filePath);
-        }
-        scheduleLint(filePath, {
-            repoName,
-            repoRootDir: managed.rootDir,
-            lintConfig: managed.config.lint,
-            appendOutput: this.deps.appendOutput,
-            onLintResult: (result) => this.deps.setLintStatus(repoName, result),
-            spawn: this.deps.spawn,
-        });
-        if (!this.handles.has(repoName)) {
-            void this.spawnWatcher(repoName);
-        }
-    }
-    async spawnWatcher(repoName) {
-        const managed = this.repos.get(repoName);
-        if (!managed || !managed.config.watch) {
-            return;
-        }
-        const cmd = managed.config.watch;
-        const [exe, ...args] = cmd.split(/\s+/);
-        if (!exe)
-            return;
-        this.deps.setRepoStatus(repoName, 'running');
-        this.deps.appendOutput({
-            ts: Date.now(),
-            source: repoName,
-            severity: 'info',
-            text: `starting watcher: ${cmd}`,
-        });
-        const handle = this.deps.spawn(exe, args, {
-            cwd: managed.rootDir,
-            onStdout: (line) => this.deps.appendOutput({
-                ts: Date.now(),
-                source: repoName,
-                severity: 'info',
-                text: line,
-            }),
-            onStderr: (line) => this.deps.appendOutput({
-                ts: Date.now(),
-                source: repoName,
-                severity: 'warn',
-                text: line,
-            }),
-        });
-        this.handles.set(repoName, handle);
-        // Capture this spawn's handle identity. If rebuild() replaces the handle
-        // before exitCode resolves, the stale exit handler must not clobber the
-        // new watcher's status.
-        const thisHandle = handle;
-        const code = await handle.exitCode;
-        if (this.handles.get(repoName) !== thisHandle)
-            return;
-        this.handles.delete(repoName);
-        if (code === 0) {
-            this.deps.setRepoStatus(repoName, 'idle');
-            this.deps.appendOutput({
-                ts: Date.now(),
-                source: repoName,
-                severity: 'info',
-                text: `watcher exited cleanly`,
-            });
-            // Transition: fail→clean only (not on first-ever clean exit).
-            if (this.deps.onBuildOutcome && this.buildOutcomes.get(repoName) === 'fail') {
-                this.deps.onBuildOutcome(repoName, 'build-recovered');
-            }
-            this.buildOutcomes.set(repoName, 'success');
-        }
-        else {
-            this.deps.setRepoStatus(repoName, 'failing');
-            this.deps.appendOutput({
-                ts: Date.now(),
-                source: repoName,
-                severity: 'error',
-                text: `watcher exited with code ${code}`,
-            });
-            // Transition: clean→fail only (not on repeated failures).
-            if (this.deps.onBuildOutcome && this.buildOutcomes.get(repoName) !== 'fail') {
-                this.deps.onBuildOutcome(repoName, 'build-failed');
-            }
-            this.buildOutcomes.set(repoName, 'fail');
-        }
-    }
-    killHandle(repoName) {
-        const handle = this.handles.get(repoName);
-        if (handle) {
-            handle.kill('SIGTERM');
-            this.handles.delete(repoName);
-        }
-    }
-}