npm - dev-cockpit - Versions diffs - 0.1.0 - Mend

dev-cockpit 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (169) hide show

package/CHANGELOG.md +36 -0
package/LICENSE +21 -0
package/README.md +131 -0
package/bin/dev-cockpit.mjs +20 -0
package/dist/buildCli.d.ts +17 -0
package/dist/buildCli.d.ts.map +1 -0
package/dist/buildCli.js +107 -0
package/dist/cli.d.ts +2 -0
package/dist/cli.d.ts.map +1 -0
package/dist/cli.js +2 -0
package/dist/cockpit/Cockpit.d.ts +33 -0
package/dist/cockpit/Cockpit.d.ts.map +1 -0
package/dist/cockpit/Cockpit.js +73 -0
package/dist/cockpit/Footer.d.ts +22 -0
package/dist/cockpit/Footer.d.ts.map +1 -0
package/dist/cockpit/Footer.js +33 -0
package/dist/cockpit/TabBar.d.ts +3 -0
package/dist/cockpit/TabBar.d.ts.map +1 -0
package/dist/cockpit/TabBar.js +12 -0
package/dist/cockpit/help/content.d.ts +12 -0
package/dist/cockpit/help/content.d.ts.map +1 -0
package/dist/cockpit/help/content.js +22 -0
package/dist/cockpit/help/loader.d.ts +65 -0
package/dist/cockpit/help/loader.d.ts.map +1 -0
package/dist/cockpit/help/loader.js +118 -0
package/dist/cockpit/help/renderer.d.ts +16 -0
package/dist/cockpit/help/renderer.d.ts.map +1 -0
package/dist/cockpit/help/renderer.js +35 -0
package/dist/cockpit/help/types.d.ts +12 -0
package/dist/cockpit/help/types.d.ts.map +1 -0
package/dist/cockpit/help/types.js +1 -0
package/dist/cockpit/hooks/useCockpitStore.d.ts +3 -0
package/dist/cockpit/hooks/useCockpitStore.d.ts.map +1 -0
package/dist/cockpit/hooks/useCockpitStore.js +5 -0
package/dist/cockpit/hooks/useGlobalKeys.d.ts +56 -0
package/dist/cockpit/hooks/useGlobalKeys.d.ts.map +1 -0
package/dist/cockpit/hooks/useGlobalKeys.js +173 -0
package/dist/cockpit/panes/FilterModal.d.ts +3 -0
package/dist/cockpit/panes/FilterModal.d.ts.map +1 -0
package/dist/cockpit/panes/FilterModal.js +22 -0
package/dist/cockpit/panes/Health.d.ts +13 -0
package/dist/cockpit/panes/Health.d.ts.map +1 -0
package/dist/cockpit/panes/Health.js +30 -0
package/dist/cockpit/panes/Help.d.ts +14 -0
package/dist/cockpit/panes/Help.d.ts.map +1 -0
package/dist/cockpit/panes/Help.js +81 -0
package/dist/cockpit/panes/Output.d.ts +14 -0
package/dist/cockpit/panes/Output.d.ts.map +1 -0
package/dist/cockpit/panes/Output.js +108 -0
package/dist/cockpit/panes/Repos.d.ts +3 -0
package/dist/cockpit/panes/Repos.d.ts.map +1 -0
package/dist/cockpit/panes/Repos.js +48 -0
package/dist/cockpit/panes/SearchModal.d.ts +3 -0
package/dist/cockpit/panes/SearchModal.d.ts.map +1 -0
package/dist/cockpit/panes/SearchModal.js +31 -0
package/dist/cockpit/state/store.d.ts +93 -0
package/dist/cockpit/state/store.d.ts.map +1 -0
package/dist/cockpit/state/store.js +111 -0
package/dist/cockpit/tab-state.d.ts +4 -0
package/dist/cockpit/tab-state.d.ts.map +1 -0
package/dist/cockpit/tab-state.js +7 -0
package/dist/commands/dev.d.ts +20 -0
package/dist/commands/dev.d.ts.map +1 -0
package/dist/commands/dev.js +158 -0
package/dist/commands/doctor.d.ts +20 -0
package/dist/commands/doctor.d.ts.map +1 -0
package/dist/commands/doctor.js +66 -0
package/dist/commands/init-config-wizard.d.ts +84 -0
package/dist/commands/init-config-wizard.d.ts.map +1 -0
package/dist/commands/init-config-wizard.js +818 -0
package/dist/commands/init-config.d.ts +35 -0
package/dist/commands/init-config.d.ts.map +1 -0
package/dist/commands/init-config.js +131 -0
package/dist/commands/mount.d.ts +48 -0
package/dist/commands/mount.d.ts.map +1 -0
package/dist/commands/mount.js +150 -0
package/dist/core/config.d.ts +391 -0
package/dist/core/config.d.ts.map +1 -0
package/dist/core/config.js +152 -0
package/dist/core/logger.d.ts +6 -0
package/dist/core/logger.d.ts.map +1 -0
package/dist/core/logger.js +38 -0
package/dist/core/notifier.d.ts +23 -0
package/dist/core/notifier.d.ts.map +1 -0
package/dist/core/notifier.js +100 -0
package/dist/core/paths.d.ts +15 -0
package/dist/core/paths.d.ts.map +1 -0
package/dist/core/paths.js +18 -0
package/dist/core/subprocess.d.ts +20 -0
package/dist/core/subprocess.d.ts.map +1 -0
package/dist/core/subprocess.js +82 -0
package/dist/core/types.d.ts +125 -0
package/dist/core/types.d.ts.map +1 -0
package/dist/core/types.js +1 -0
package/dist/docker/highlights.d.ts +48 -0
package/dist/docker/highlights.d.ts.map +1 -0
package/dist/docker/highlights.js +79 -0
package/dist/docker/logs.d.ts +84 -0
package/dist/docker/logs.d.ts.map +1 -0
package/dist/docker/logs.js +172 -0
package/dist/docker/restart.d.ts +26 -0
package/dist/docker/restart.d.ts.map +1 -0
package/dist/docker/restart.js +45 -0
package/dist/docker/stack-trace.d.ts +25 -0
package/dist/docker/stack-trace.d.ts.map +1 -0
package/dist/docker/stack-trace.js +44 -0
package/dist/health/builtin.d.ts +8 -0
package/dist/health/builtin.d.ts.map +1 -0
package/dist/health/builtin.js +144 -0
package/dist/health/context.d.ts +3 -0
package/dist/health/context.d.ts.map +1 -0
package/dist/health/context.js +31 -0
package/dist/health/notify-resolver.d.ts +18 -0
package/dist/health/notify-resolver.d.ts.map +1 -0
package/dist/health/notify-resolver.js +28 -0
package/dist/health/registry.d.ts +20 -0
package/dist/health/registry.d.ts.map +1 -0
package/dist/health/registry.js +64 -0
package/dist/health/remediations.d.ts +6 -0
package/dist/health/remediations.d.ts.map +1 -0
package/dist/health/remediations.js +41 -0
package/dist/health/runner.d.ts +4 -0
package/dist/health/runner.d.ts.map +1 -0
package/dist/health/runner.js +22 -0
package/dist/health/scheduler.d.ts +41 -0
package/dist/health/scheduler.d.ts.map +1 -0
package/dist/health/scheduler.js +107 -0
package/dist/health/types.d.ts +73 -0
package/dist/health/types.d.ts.map +1 -0
package/dist/health/types.js +1 -0
package/dist/health/useHealth.d.ts +40 -0
package/dist/health/useHealth.d.ts.map +1 -0
package/dist/health/useHealth.js +122 -0
package/dist/index.d.ts +50 -0
package/dist/index.d.ts.map +1 -0
package/dist/index.js +53 -0
package/dist/ink.d.ts +3 -0
package/dist/ink.d.ts.map +1 -0
package/dist/ink.js +1 -0
package/dist/lint/reactive.d.ts +38 -0
package/dist/lint/reactive.d.ts.map +1 -0
package/dist/lint/reactive.js +131 -0
package/dist/react.d.ts +3 -0
package/dist/react.d.ts.map +1 -0
package/dist/react.js +1 -0
package/dist/runCockpit.d.ts +34 -0
package/dist/runCockpit.d.ts.map +1 -0
package/dist/runCockpit.js +75 -0
package/dist/watchers/manager.d.ts +63 -0
package/dist/watchers/manager.d.ts.map +1 -0
package/dist/watchers/manager.js +239 -0
package/dist/watchers/path-mapper.d.ts +23 -0
package/dist/watchers/path-mapper.d.ts.map +1 -0
package/dist/watchers/path-mapper.js +29 -0
package/dist/watchers/types.d.ts +22 -0
package/dist/watchers/types.d.ts.map +1 -0
package/dist/watchers/types.js +9 -0
package/docs/commands.md +71 -0
package/docs/config-reference.md +20 -0
package/docs/getting-started.md +39 -0
package/docs/health.md +120 -0
package/docs/index.md +13 -0
package/docs/init-config.md +46 -0
package/docs/mount.md +55 -0
package/docs/notifications.md +39 -0
package/docs/panes.md +45 -0
package/docs/watchers.md +27 -0
package/examples/cockpit.yaml +116 -0
package/package.json +91 -0

package/dist/docker/logs.js ADDED Viewed

@@ -0,0 +1,172 @@
+/**
+ * DockerLogTailer — tails `docker compose logs -f` for configured services,
+ * routes lines into the Output pane, surfaces highlight matches into the
+ * Recent Errors ring buffer, and emits OS notifications via the shared
+ * notifier.
+ *
+ * Discipline:
+ *   - Subprocess goes through `core/subprocess.spawnStream` (DRY).
+ *   - Notifications go through `core/notifier.emitEvent` (DRY).
+ *   - Notification debounce: identical errors (same file:line OR same text
+ *     fingerprint) within `DEBOUNCE_MS` produce ONE notification, not N.
+ *
+ * Line format: `docker compose logs --no-color` emits `<service>  | <body>`
+ * (variable spaces). The leading service token is parsed; the rest is the
+ * line body.
+ */
+import path from 'node:path';
+import fs from 'node:fs';
+import { spawnStream } from '../core/subprocess.js';
+import { emitEvent } from '../core/notifier.js';
+import { compileHighlights } from './highlights.js';
+import { extractFileLine } from './stack-trace.js';
+/** Debounce window for identical errors (default 30s). */
+export const DEBOUNCE_MS = 30_000;
+/** Liveness threshold — a service silent for this long is treated as down. */
+export const SILENT_THRESHOLD_MS = 90_000;
+export class DockerLogTailer {
+    opts;
+    handle = null;
+    compiled;
+    spawn;
+    now;
+    /** fingerprint → timestamp of last notify. Used for debounce. */
+    lastNotified = new Map();
+    serviceState = new Map();
+    liveCheckInterval = null;
+    constructor(opts) {
+        this.opts = opts;
+        this.compiled = compileHighlights(opts.highlightPatterns);
+        this.spawn = opts.spawn ?? spawnStream;
+        this.now = opts.now ?? Date.now;
+        for (const svc of opts.services) {
+            this.serviceState.set(svc, { lastSeen: this.now(), notifiedDown: false });
+        }
+    }
+    /**
+     * Resolve the docker-compose file path. If `opts.composeFile` is set
+     * and exists, use it. Otherwise return null and let docker auto-discover.
+     */
+    resolveComposeFile() {
+        if (this.opts.composeFile) {
+            const abs = path.isAbsolute(this.opts.composeFile)
+                ? this.opts.composeFile
+                : path.join(this.opts.workspaceRoot, this.opts.composeFile);
+            return fs.existsSync(abs) ? abs : null;
+        }
+        return null;
+    }
+    start() {
+        if (this.handle)
+            return;
+        const composeFile = this.resolveComposeFile();
+        const args = [
+            'compose',
+            ...(composeFile ? ['-f', composeFile] : []),
+            'logs',
+            '-f',
+            '--no-color',
+            '--tail=0',
+            ...this.opts.services,
+        ];
+        this.handle = this.spawn('docker', args, {
+            cwd: this.opts.workspaceRoot,
+            onStdout: (line) => this.handleLine(line),
+            onStderr: (line) => this.handleLine(line),
+        });
+        // Periodic liveness watch — docker doesn't push container-stop events
+        // through `logs -f`; we infer from silence.
+        this.liveCheckInterval = setInterval(() => this.checkLiveness(), 30_000);
+    }
+    async stop() {
+        if (this.liveCheckInterval) {
+            clearInterval(this.liveCheckInterval);
+            this.liveCheckInterval = null;
+        }
+        if (this.handle) {
+            const handle = this.handle;
+            this.handle = null;
+            handle.kill();
+            // Await the child's exit so the ChildProcess + stdio sockets are reaped
+            // before we resolve. Without this, the Node event loop still tracks
+            // those handles, blocking process exit on the consumer side.
+            try {
+                await handle.exitCode;
+            }
+            catch {
+                // execa is reject:false but swallow defensively just in case.
+            }
+        }
+    }
+    /**
+     * Parse a single docker-compose log line: `<service>  | <body>`.
+     * Returns null if the line doesn't match (e.g. compose preamble).
+     */
+    parseLine(raw) {
+        const m = /^([a-zA-Z0-9_.\-]+)\s*\|\s?(.*)$/.exec(raw);
+        if (!m || !m[1])
+            return null;
+        return { service: m[1], body: m[2] ?? '' };
+    }
+    /** Public for testing — exercise per-line logic without a real subprocess. */
+    handleLine(raw) {
+        const parsed = this.parseLine(raw);
+        if (!parsed)
+            return;
+        const { service, body } = parsed;
+        const tracked = this.serviceState.get(service);
+        if (tracked) {
+            tracked.lastSeen = this.now();
+            if (tracked.notifiedDown)
+                tracked.notifiedDown = false;
+        }
+        const match = this.compiled.match(body);
+        const severity = match.severity;
+        this.opts.appendOutput({
+            ts: this.now(),
+            source: `docker:${service}`,
+            severity,
+            text: body,
+        });
+        if (!match.matched)
+            return;
+        // Highlight match → recent-errors + (debounced) notify.
+        const fileLine = extractFileLine(body);
+        const recentErr = {
+            ts: this.now(),
+            service,
+            severity: severity === 'info' ? 'warn' : severity,
+            text: body,
+            ...(fileLine ? { file: fileLine.file, line: fileLine.line } : {}),
+        };
+        this.opts.pushRecentError(recentErr);
+        // Initiators (new error event) notify; continuations (Stack trace) don't.
+        if (severity === 'error' && match.isInitiator) {
+            this.maybeNotifyError(service, body, fileLine);
+        }
+    }
+    maybeNotifyError(service, body, fileLine) {
+        const fingerprint = fileLine
+            ? `${service}:${fileLine.file}:${fileLine.line}`
+            : `${service}:${body}`;
+        const last = this.lastNotified.get(fingerprint);
+        const now = this.now();
+        if (last !== undefined && now - last < DEBOUNCE_MS)
+            return;
+        this.lastNotified.set(fingerprint, now);
+        const eventName = this.opts.errorEventName ?? 'docker-error';
+        emitEvent(eventName, `docker:${service}`, fileLine ? `${body}\n  ↳ ${fileLine.file}:${fileLine.line}` : body, this.opts.notifyOpts());
+    }
+    /** If a tracked service has been silent past the threshold, notify once. */
+    checkLiveness() {
+        const now = this.now();
+        for (const [service, state] of this.serviceState) {
+            if (state.notifiedDown)
+                continue;
+            if (now - state.lastSeen > SILENT_THRESHOLD_MS) {
+                state.notifiedDown = true;
+                emitEvent('container-down', `docker:${service}`, `Service ${service} has been silent for ${Math.round((now - state.lastSeen) / 1000)}s`, this.opts.notifyOpts());
+            }
+        }
+    }
+}

package/dist/docker/restart.d.ts ADDED Viewed

@@ -0,0 +1,26 @@
+/**
+ * Docker service restart helper.
+ *
+ * Wraps `docker compose restart <service>` and streams stdout/stderr to
+ * the Output pane via the supplied appendOutput callback.
+ *
+ * Used by the Repos pane when the user presses `r` on a docker entry.
+ */
+import { spawnStream } from '../core/subprocess.js';
+import type { OutputLine } from '../cockpit/state/store.js';
+export interface RestartDockerDeps {
+    /** Workspace root — passed as `cwd` to `docker compose`. */
+    workspaceRoot: string;
+    /** Service name (e.g. "web", "db"). */
+    service: string;
+    /** Pushes a line to the Output pane. */
+    appendOutput: (line: OutputLine) => void;
+    /** Inject a custom spawner for tests. Defaults to spawnStream. */
+    spawn?: typeof spawnStream;
+}
+/**
+ * Restart one docker compose service. Resolves with the exit code.
+ * Errors do not throw — they're surfaced as warn-level Output lines.
+ */
+export declare function restartDockerService(deps: RestartDockerDeps): Promise<number>;
+//# sourceMappingURL=restart.d.ts.map

package/dist/docker/restart.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"restart.d.ts","sourceRoot":"","sources":["../../src/docker/restart.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAE5D,MAAM,WAAW,iBAAiB;IAChC,4DAA4D;IAC5D,aAAa,EAAE,MAAM,CAAC;IACtB,uCAAuC;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,wCAAwC;IACxC,YAAY,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,CAAC;IACzC,kEAAkE;IAClE,KAAK,CAAC,EAAE,OAAO,WAAW,CAAC;CAC5B;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC,CAmCnF"}

package/dist/docker/restart.js ADDED Viewed

@@ -0,0 +1,45 @@
+/**
+ * Docker service restart helper.
+ *
+ * Wraps `docker compose restart <service>` and streams stdout/stderr to
+ * the Output pane via the supplied appendOutput callback.
+ *
+ * Used by the Repos pane when the user presses `r` on a docker entry.
+ */
+import { spawnStream } from '../core/subprocess.js';
+/**
+ * Restart one docker compose service. Resolves with the exit code.
+ * Errors do not throw — they're surfaced as warn-level Output lines.
+ */
+export async function restartDockerService(deps) {
+    const spawn = deps.spawn ?? spawnStream;
+    deps.appendOutput({
+        ts: Date.now(),
+        source: `docker:${deps.service}`,
+        severity: 'info',
+        text: `restart ${deps.service} requested`,
+    });
+    const handle = spawn('docker', ['compose', 'restart', deps.service], {
+        cwd: deps.workspaceRoot,
+        onStdout: (line) => deps.appendOutput({
+            ts: Date.now(),
+            source: `docker:${deps.service}`,
+            severity: 'info',
+            text: line,
+        }),
+        onStderr: (line) => deps.appendOutput({
+            ts: Date.now(),
+            source: `docker:${deps.service}`,
+            severity: 'warn',
+            text: line,
+        }),
+    });
+    const code = await handle.exitCode;
+    deps.appendOutput({
+        ts: Date.now(),
+        source: `docker:${deps.service}`,
+        severity: code === 0 ? 'info' : 'warn',
+        text: `restart ${deps.service} exited with code ${code}`,
+    });
+    return code;
+}

package/dist/docker/stack-trace.d.ts ADDED Viewed

@@ -0,0 +1,25 @@
+/**
+ * Extract `file:line` from stack-trace-style log lines.
+ *
+ * Pure. No I/O. Recognizes two common shapes:
+ *
+ *   in /path/to/File.<ext>:42
+ *   /path/to/File.<ext>(42)
+ *
+ * The path matcher captures any absolute path ending in a code-file
+ * extension (`.<letters/digits>`), so it works across languages. Container
+ * paths are returned as-is; container ↔ host mapping is the caller's job.
+ *
+ * When multiple references appear, the first wins — typically the most
+ * specific (the throw site rather than framework internals).
+ */
+export interface FileLine {
+    file: string;
+    line: number;
+}
+/**
+ * Try to extract the first `file:line` reference from a single log line or
+ * a multi-line trace. Returns null if no plausible reference is found.
+ */
+export declare function extractFileLine(text: string): FileLine | null;
+//# sourceMappingURL=stack-trace.d.ts.map

package/dist/docker/stack-trace.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"stack-trace.d.ts","sourceRoot":"","sources":["../../src/docker/stack-trace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAgBD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CAc7D"}

package/dist/docker/stack-trace.js ADDED Viewed

@@ -0,0 +1,44 @@
+/**
+ * Extract `file:line` from stack-trace-style log lines.
+ *
+ * Pure. No I/O. Recognizes two common shapes:
+ *
+ *   in /path/to/File.<ext>:42
+ *   /path/to/File.<ext>(42)
+ *
+ * The path matcher captures any absolute path ending in a code-file
+ * extension (`.<letters/digits>`), so it works across languages. Container
+ * paths are returned as-is; container ↔ host mapping is the caller's job.
+ *
+ * When multiple references appear, the first wins — typically the most
+ * specific (the throw site rather than framework internals).
+ */
+// Anchored to capture absolute paths only — avoids false-matching log
+// timestamps, IDs, or arbitrary numbers. Preceded by start-of-string,
+// whitespace, or common opening punctuation (quote / paren / bracket).
+//
+// The extension allow-list is a curated set of common code-file extensions
+// (broad enough to cover most real stacks; tight enough to skip log files,
+// sockets, pid files, and other non-code artifacts).
+const PRE = `(?:^|[\\s'"(\\[])`;
+const EXT = '(?:js|jsx|ts|tsx|mjs|cjs|py|rb|go|rs|java|kt|swift|scala|php|c|h|cpp|hpp|hh|cc|cs|fs|sh|bash|zsh|lua|dart|ex|exs|erl|clj|cljs|sql|css|scss|sass|less|html|htm|vue|svelte|elm|hs|ml|nim|zig|jl|r|pl|pm|tcl|groovy|gradle|kts)';
+const PATH = `(\\/(?:[^\\s:()'"\\[\\]]+\\/)*[^\\s:()'"\\[\\]]+\\.${EXT})`;
+const RE_COLON = new RegExp(`${PRE}${PATH}:(\\d+)`, 'i');
+const RE_PAREN = new RegExp(`${PRE}${PATH}\\((\\d+)\\)`, 'i');
+/**
+ * Try to extract the first `file:line` reference from a single log line or
+ * a multi-line trace. Returns null if no plausible reference is found.
+ */
+export function extractFileLine(text) {
+    if (!text)
+        return null;
+    const colonMatch = RE_COLON.exec(text);
+    if (colonMatch?.[1] && colonMatch[2]) {
+        return { file: colonMatch[1], line: Number(colonMatch[2]) };
+    }
+    const parenMatch = RE_PAREN.exec(text);
+    if (parenMatch?.[1] && parenMatch[2]) {
+        return { file: parenMatch[1], line: Number(parenMatch[2]) };
+    }
+    return null;
+}

package/dist/health/builtin.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+import type { HealthCheck, HealthCheckConfig, BuiltinCheckType } from './types.js';
+import type { Severity } from '../core/types.js';
+type BuiltinFactory = (entry: HealthCheckConfig) => HealthCheck['predicate'];
+export declare const BUILTIN_CHECK_FACTORIES: Record<BuiltinCheckType, BuiltinFactory>;
+export declare const BUILTIN_DEFAULT_TRIGGERS: Record<BuiltinCheckType, HealthCheck['triggers']>;
+export declare const BUILTIN_DEFAULT_SEVERITY: Record<BuiltinCheckType, Severity>;
+export {};
+//# sourceMappingURL=builtin.d.ts.map

package/dist/health/builtin.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"builtin.d.ts","sourceRoot":"","sources":["../../src/health/builtin.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAiB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAClG,OAAO,KAAK,EAAgB,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE/D,KAAK,cAAc,GAAG,CAAC,KAAK,EAAE,iBAAiB,KAAK,WAAW,CAAC,WAAW,CAAC,CAAC;AA+H7E,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,gBAAgB,EAAE,cAAc,CAM5E,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,gBAAgB,EAAE,WAAW,CAAC,UAAU,CAAC,CAMtF,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,gBAAgB,EAAE,QAAQ,CAMvE,CAAC"}

package/dist/health/builtin.js ADDED Viewed

@@ -0,0 +1,144 @@
+import net from 'node:net';
+import path from 'node:path';
+const containerRunning = (entry) => {
+    const container = entry.container;
+    if (!container) {
+        throw new Error(`health[${entry.id}]: type 'container-running' requires 'container'`);
+    }
+    return async (ctx) => {
+        const { stdout, exitCode } = await ctx.exec('docker', [
+            'inspect',
+            '--format',
+            '{{.State.Running}}',
+            container,
+        ]);
+        const running = exitCode === 0 && stdout.trim() === 'true';
+        return {
+            id: entry.id,
+            label: entry.label,
+            severity: running ? 'ok' : (entry.severity ?? 'error'),
+            detail: running
+                ? `container '${container}' is running`
+                : `container '${container}' is not running`,
+            remediationKey: entry.remediation.key,
+        };
+    };
+};
+const portOpen = (entry) => {
+    const port = entry.port;
+    if (typeof port !== 'number') {
+        throw new Error(`health[${entry.id}]: type 'port-open' requires numeric 'port'`);
+    }
+    const host = entry.host ?? '127.0.0.1';
+    return async () => {
+        const open = await new Promise((resolve) => {
+            const sock = new net.Socket();
+            const done = (ok) => {
+                sock.destroy();
+                resolve(ok);
+            };
+            sock.setTimeout(2000);
+            sock.once('connect', () => done(true));
+            sock.once('error', () => done(false));
+            sock.once('timeout', () => done(false));
+            sock.connect(port, host);
+        });
+        return {
+            id: entry.id,
+            label: entry.label,
+            severity: open ? 'ok' : (entry.severity ?? 'error'),
+            detail: open ? `${host}:${port} is reachable` : `${host}:${port} is not reachable`,
+            remediationKey: entry.remediation.key,
+        };
+    };
+};
+const httpOk = (entry) => {
+    const url = entry.url;
+    if (!url) {
+        throw new Error(`health[${entry.id}]: type 'http-ok' requires 'url'`);
+    }
+    const expect = entry.expectStatus ?? 200;
+    return async () => {
+        let status = 0;
+        let detail = '';
+        try {
+            const ac = new AbortController();
+            const t = setTimeout(() => ac.abort(), 5000);
+            const res = await fetch(url, { signal: ac.signal });
+            clearTimeout(t);
+            status = res.status;
+        }
+        catch (err) {
+            detail = `fetch failed: ${String(err.message ?? err)}`;
+        }
+        const ok = status === expect;
+        return {
+            id: entry.id,
+            label: entry.label,
+            severity: ok ? 'ok' : (entry.severity ?? 'error'),
+            detail: ok
+                ? `${url} returned ${status}`
+                : detail || `${url} returned ${status} (expected ${expect})`,
+            remediationKey: entry.remediation.key,
+        };
+    };
+};
+const fileExists = (entry) => {
+    const target = entry.path;
+    if (!target) {
+        throw new Error(`health[${entry.id}]: type 'file-exists' requires 'path'`);
+    }
+    return async (ctx) => {
+        const resolved = path.isAbsolute(target) ? target : path.join(ctx.workspaceRoot, target);
+        const exists = ctx.fs.existsSync(resolved);
+        return {
+            id: entry.id,
+            label: entry.label,
+            severity: exists ? 'ok' : (entry.severity ?? 'error'),
+            detail: exists ? `${resolved} exists` : `${resolved} is missing`,
+            remediationKey: entry.remediation.key,
+        };
+    };
+};
+const execZero = (entry) => {
+    const command = entry.command;
+    if (!command) {
+        throw new Error(`health[${entry.id}]: type 'exec-zero' requires 'command'`);
+    }
+    const args = entry.args ?? [];
+    return async (ctx) => {
+        const cwd = entry.cwd ?? ctx.workspaceRoot;
+        const { exitCode } = await ctx.exec(command, args, cwd);
+        const ok = exitCode === 0;
+        return {
+            id: entry.id,
+            label: entry.label,
+            severity: ok ? 'ok' : (entry.severity ?? 'error'),
+            detail: ok
+                ? `${command} ${args.join(' ')} exited 0`
+                : `${command} ${args.join(' ')} exited ${exitCode}`,
+            remediationKey: entry.remediation.key,
+        };
+    };
+};
+export const BUILTIN_CHECK_FACTORIES = {
+    'container-running': containerRunning,
+    'port-open': portOpen,
+    'http-ok': httpOk,
+    'file-exists': fileExists,
+    'exec-zero': execZero,
+};
+export const BUILTIN_DEFAULT_TRIGGERS = {
+    'container-running': ['startup', 'docker'],
+    'port-open': ['startup'],
+    'http-ok': ['startup'],
+    'file-exists': ['startup', 'fsevent'],
+    'exec-zero': ['startup'],
+};
+export const BUILTIN_DEFAULT_SEVERITY = {
+    'container-running': 'error',
+    'port-open': 'error',
+    'http-ok': 'error',
+    'file-exists': 'error',
+    'exec-zero': 'error',
+};

package/dist/health/context.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import type { HealthContext } from './types.js';
+export declare function buildHealthContext(workspaceRoot: string, appendOutput?: HealthContext['appendOutput']): HealthContext;
+//# sourceMappingURL=context.d.ts.map

package/dist/health/context.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/health/context.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AA4BhD,wBAAgB,kBAAkB,CAChC,aAAa,EAAE,MAAM,EACrB,YAAY,CAAC,EAAE,aAAa,CAAC,cAAc,CAAC,GAC3C,aAAa,CAOf"}

package/dist/health/context.js ADDED Viewed

@@ -0,0 +1,31 @@
+import fs from 'node:fs';
+import { spawnStream } from '../core/subprocess.js';
+const defaultExec = async (cmd, args, cwd) => {
+    let stdout = '';
+    const handle = spawnStream(cmd, args, {
+        cwd,
+        onStdout: (line) => {
+            stdout += line + '\n';
+        },
+    });
+    const exitCode = await handle.exitCode;
+    return { stdout, exitCode };
+};
+const defaultFs = {
+    existsSync: (p) => fs.existsSync(p),
+    statSync: (p) => fs.statSync(p),
+    readdirSync: (p, opts) => {
+        if (opts?.withFileTypes) {
+            return fs.readdirSync(p, { withFileTypes: true });
+        }
+        return fs.readdirSync(p);
+    },
+};
+export function buildHealthContext(workspaceRoot, appendOutput) {
+    return {
+        workspaceRoot,
+        fs: defaultFs,
+        exec: defaultExec,
+        appendOutput,
+    };
+}

package/dist/health/notify-resolver.d.ts ADDED Viewed

@@ -0,0 +1,18 @@
+import type { NotificationsConfig } from '../core/notifier.js';
+import type { Transition } from '../core/types.js';
+import type { NotifyPolicy } from './types.js';
+/**
+ * Resolves whether a single transition should fire a notification given the
+ * global notifications policy and an optional per-item override.
+ *
+ * Precedence (per-item beats global):
+ *   - per-item === false        → silent, no matter what global says
+ *   - per-item === { onTransitionTo: [...] } → fire only if transition.event ∈ list
+ *   - per-item === undefined    → defer to global (config.enabled + config.exclude)
+ *
+ * The global config is still consulted for `enabled` and `exclude` even when
+ * per-item is set to `{ onTransitionTo }`. That keeps the global session toggle
+ * (`n` keystroke at the global level) authoritative.
+ */
+export declare function resolveNotify(transition: Transition, globalConfig: NotificationsConfig, perItem?: NotifyPolicy): boolean;
+//# sourceMappingURL=notify-resolver.d.ts.map

package/dist/health/notify-resolver.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"notify-resolver.d.ts","sourceRoot":"","sources":["../../src/health/notify-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,KAAK,EAAmB,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,mBAAmB,EACjC,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAcT"}

package/dist/health/notify-resolver.js ADDED Viewed

@@ -0,0 +1,28 @@
+/**
+ * Resolves whether a single transition should fire a notification given the
+ * global notifications policy and an optional per-item override.
+ *
+ * Precedence (per-item beats global):
+ *   - per-item === false        → silent, no matter what global says
+ *   - per-item === { onTransitionTo: [...] } → fire only if transition.event ∈ list
+ *   - per-item === undefined    → defer to global (config.enabled + config.exclude)
+ *
+ * The global config is still consulted for `enabled` and `exclude` even when
+ * per-item is set to `{ onTransitionTo }`. That keeps the global session toggle
+ * (`n` keystroke at the global level) authoritative.
+ */
+export function resolveNotify(transition, globalConfig, perItem) {
+    if (perItem === false)
+        return false;
+    if (!globalConfig.enabled)
+        return false;
+    if (globalConfig.exclude.includes(transition.event))
+        return false;
+    if (perItem && typeof perItem === 'object') {
+        const allowed = perItem.onTransitionTo;
+        if (allowed && allowed.length > 0) {
+            return allowed.includes(transition.event);
+        }
+    }
+    return true;
+}

package/dist/health/registry.d.ts ADDED Viewed

@@ -0,0 +1,20 @@
+import type { HealthCheck, HealthCheckConfig } from './types.js';
+export interface BuildHealthRegistryOptions {
+    /** Pre-built checks contributed by the active profile. */
+    profileChecks?: HealthCheck[];
+    /** Config-driven entries from cockpit.yaml `health[]`. */
+    configEntries?: HealthCheckConfig[];
+}
+/**
+ * Resolves the final ordered list of HealthCheck definitions:
+ *   1. Built-in factory entries from cockpit.yaml are materialised first.
+ *   2. Profile-contributed checks come next.
+ *
+ * Collisions are detected on either `id` or `type` (where applicable):
+ *   - If a profile check declares a built-in `type`, it is rejected (built-ins win).
+ *   - If two checks share an `id`, the second is rejected.
+ *
+ * Profiles MAY register checks with novel `type` ids (or no `type`) — those are allowed.
+ */
+export declare function buildHealthRegistry(opts?: BuildHealthRegistryOptions): HealthCheck[];
+//# sourceMappingURL=registry.d.ts.map

package/dist/health/registry.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/health/registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,iBAAiB,EAAoB,MAAM,YAAY,CAAC;AAUnF,MAAM,WAAW,0BAA0B;IACzC,0DAA0D;IAC1D,aAAa,CAAC,EAAE,WAAW,EAAE,CAAC;IAC9B,0DAA0D;IAC1D,aAAa,CAAC,EAAE,iBAAiB,EAAE,CAAC;CACrC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,GAAE,0BAA+B,GAAG,WAAW,EAAE,CAkDxF"}

package/dist/health/registry.js ADDED Viewed

@@ -0,0 +1,64 @@
+import { BUILTIN_CHECK_FACTORIES, BUILTIN_DEFAULT_TRIGGERS, BUILTIN_DEFAULT_SEVERITY, } from './builtin.js';
+import { getLogger } from '../core/logger.js';
+const BUILTIN_TYPES = new Set(Object.keys(BUILTIN_CHECK_FACTORIES));
+/**
+ * Resolves the final ordered list of HealthCheck definitions:
+ *   1. Built-in factory entries from cockpit.yaml are materialised first.
+ *   2. Profile-contributed checks come next.
+ *
+ * Collisions are detected on either `id` or `type` (where applicable):
+ *   - If a profile check declares a built-in `type`, it is rejected (built-ins win).
+ *   - If two checks share an `id`, the second is rejected.
+ *
+ * Profiles MAY register checks with novel `type` ids (or no `type`) — those are allowed.
+ */
+export function buildHealthRegistry(opts = {}) {
+    const log = safeLogger();
+    const seenIds = new Set();
+    const out = [];
+    for (const entry of opts.configEntries ?? []) {
+        if (seenIds.has(entry.id)) {
+            log?.warn?.({ id: entry.id }, 'health: duplicate id from config; skipping');
+            continue;
+        }
+        if (!BUILTIN_TYPES.has(entry.type)) {
+            log?.warn?.({ id: entry.id, type: entry.type }, 'health: unknown built-in type in config; skipping');
+            continue;
+        }
+        const type = entry.type;
+        const factory = BUILTIN_CHECK_FACTORIES[type];
+        const check = {
+            id: entry.id,
+            label: entry.label,
+            severity: entry.severity ?? BUILTIN_DEFAULT_SEVERITY[type],
+            triggers: entry.triggers ?? BUILTIN_DEFAULT_TRIGGERS[type],
+            predicate: factory(entry),
+            remediation: entry.remediation,
+            notify: entry.notify,
+        };
+        seenIds.add(entry.id);
+        out.push(check);
+    }
+    for (const check of opts.profileChecks ?? []) {
+        if (seenIds.has(check.id)) {
+            log?.warn?.({ id: check.id }, 'health: profile check id collides with config; skipping');
+            continue;
+        }
+        const profileType = check.type;
+        if (profileType && BUILTIN_TYPES.has(profileType)) {
+            log?.warn?.({ id: check.id, type: profileType }, 'health: profile attempted to override built-in type; skipping');
+            continue;
+        }
+        seenIds.add(check.id);
+        out.push(check);
+    }
+    return out;
+}
+function safeLogger() {
+    try {
+        return getLogger();
+    }
+    catch {
+        return null;
+    }
+}

package/dist/health/remediations.d.ts ADDED Viewed

@@ -0,0 +1,6 @@
+import type { HealthCheck, HealthContext, Remediation } from './types.js';
+export type RemediationKey = string;
+export declare function runRemediation(key: RemediationKey, checks: HealthCheck[], ctx: HealthContext, workspaceRoot: string): Promise<void>;
+export declare function findRemediation(key: RemediationKey, checks: HealthCheck[]): HealthCheck | undefined;
+export declare function dispatchRemediation(remediation: Remediation, ctx: HealthContext, workspaceRoot: string, sourceId: string): Promise<void>;
+//# sourceMappingURL=remediations.d.ts.map