dev-cockpit 0.1.0 → 0.2.2

package/CHANGELOG.md

@@ -2,6 +2,64 @@
 
 All notable changes to `dev-cockpit` are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.2] — 2026-05-12
+
+External `cockpit.yaml` — the config can now live anywhere, with a per-machine registry mapping workspaces to their YAML file.
+
+### Added
+
+- **`cockpit.yaml` discovery chain.** Resolves in this order: `--config <path>` CLI flag → `DEV_COCKPIT_CONFIG` env var → `<cwd>/cockpit.yaml` → `$XDG_DATA_HOME/dev-cockpit/manifest.json` lookup keyed by canonical `cwd` → friendly error pointing at `dev-cockpit link`. Lets the config live outside the workspace without losing the "just run from the workspace root" UX.
+- **`dev-cockpit link` subcommand tree.** `link <config-path>` registers the current directory in the manifest; `link list` prints all mappings sorted by workspace; `link remove` unregisters the current directory. Atomic write (`.tmp` + rename), symlink-canonical keys (so `~/work` and `/Volumes/.../work` hash to the same entry).
+- **`init-config -o, --output <path>`.** Write the starter config anywhere, not just `<cwd>/cockpit.yaml`. Honours the existing `cwd` parameter as the anchor when `--output` is relative.
+- **`DEV_COCKPIT_CONFIG` env var** picked up by all commands as the second-precedence fallback.
+- **`src/core/manifest.ts`** — read / lookup / atomic write of the project→config map. Defensive: returns `null` for missing / malformed / wrong-version files (treated as "not registered yet" rather than an error).
+- **`src/core/config-discovery.ts`** — pure resolver returning `{ configPath, workspaceRoot, source }`. Profile `discoverer` hook still overrides `workspaceRoot` (e.g. awc-cockpit walks up to find the wrapper); generic users get `canonical(cwd)`.
+
+### Changed
+
+- **`dev` / `doctor` / `mount` (+ `status`, `clear`) now derive workspace from `canonical(cwd)`**, not `path.dirname(configPath)`. So `--config /tmp/x.yaml` from inside a wrapper keeps the workspace as the wrapper — the whole point of external configs.
+- **`-c, --config` no longer defaults to `'cockpit.yaml'`** at the Commander level. Default is `undefined` so the discovery chain sees the "no explicit flag" signal and walks the precedence list. Help text describes the fallback chain.
+
+### Fixed
+
+- **CI publish workflow.** `npm install -g npm@latest` on Node 22's bundled npm could leave global state where `Cannot find module 'promise-retry'` fires from the half-installed npm. Switched the publish workflow to Node 24, which ships npm 11.x natively (satisfies the npm Trusted Publishing >= 11.5.1 requirement without a self-upgrade).
+
+## [0.2.1] — 2026-05-11
+
+Post-1.0 roadmap landing: action registry, processes (renamed from watchers), repos pane redesign, profile wizardSteps, accessibility (severity glyph + NO_COLOR), narrow-terminal responsiveness, lift-mount + bundled dist, plus a wave of fit-and-finish.
+
+### Added
+
+- **Action registry** with `:` command palette. `ActionConfig` has `id`, `label`, `scope` (`global` | `repos` | `repos:<id>`), `key` (single char), and a programmatic `invoke` callback. Replaces the legacy Repos `r/w/l` hardcoding — the Footer derives its legend from the registry, so profile-defined actions show up automatically.
+- **`Profile.wizardSteps` extension point.** Profiles inject custom steps into `init-config -i` (e.g. awc-cockpit asks for `gitlab.host` + `gitlab.topic` during the wizard).
+- **`defaultPane` config field** (`repos | output | health | help`). Profile-overridable.
+- **Processes (renamed from watchers).** `config.processes[]` is the new spelling; old `config.watchers[]` is auto-migrated via the new schema migration tooling on load. `CONFIG_VERSION` bumped 1 → 2.
+- **`dev-cockpit migrate-config`** persists the in-memory v1 → v2 migration to disk.
+- **Repos pane redesign.** Split layout: row list on the left, per-row action panel on the right. Process-kind rows with built-in `r → restart` actions wired through the action registry. Grouped list (Repos / Docker / Processes subheadings) for navigability.
+- **`dev-cockpit doctor --paths`** prints state-dir paths in `KEY=PATH` form (eval-friendly).
+- **`subprocess` tag lookup.** `spawnStream({ tag })` registers the handle in a `BY_TAG` map; `findSpawnedByTag(tag)` / `killSpawnedByTag(tag)` look it up. Used by per-process restart actions.
+- **`spawnStream` stdin option.** Opt-in `stdin?: 'pipe' | 'ignore' | 'inherit'` on `SpawnOptions` — pass `'ignore'` for non-interactive subprocesses so any `read`/prompt in the child gets EOF instead of blocking forever on an unwritten pipe.
+- **Severity glyph** at the start of every Output line — accessibility for users who run with `NO_COLOR=1`.
+- **`NO_COLOR` full-strip** — every ANSI escape is filtered when the env var is set.
+- **Narrow-terminal responsiveness.** `useTerminalWidth` hook; TabBar / Help / Repos collapse cleanly under ~200 cols (legend says `j/k` instead of arrows when collapsed).
+- **Wizard auto-seeds `actions[]`** from `package.json` scripts during `init-config -i`.
+- **Smart defaults** for health-check `id` + `label` in the wizard (derived from check type + target).
+- **Container-running health predicate uses `docker ps --filter name=<value> --format {{.State}}`** — compose-aware naming, so `name: laravel.test` matches `crossroads-laravel.test-1`.
+- **Engine guard.** Friendly error message when Node < 20.12.
+
+### Changed
+
+- **`Repos` pane label → `Targets`** (display only; internal enum stays `repos`).
+- **Mount machinery lifted into dev-cockpit core.** `mountCandidatesProvider` + `mountSymlinks` + `onMountApply` / `onMountClear` hooks on `Profile`; awc-cockpit kept its own `mount` command for its richer interactive UX (composer-aware clear semantics).
+- **Bundled dist.** esbuild produces a single self-contained `dist/index.js` + helpers; consumer installs no longer need to resolve dev-cockpit's full source tree.
+- **OIDC trusted publishing** on the publish workflow. No more `NODE_AUTH_TOKEN` — npm verifies the GitHub OIDC token issued by the workflow's `id-token: write` permission.
+
+### Fixed
+
+- **`killSpawnedByTag` race.** Promise.race against the exitCode + a SIGKILL guard could return before the `BY_TAG` finalizer ran on slower CI runners. Now awaits `exitCode` unconditionally after the race so the finalizer completes before return.
+- **Repos pane title duplication** — dropped the redundant pane title; TabBar already labels the tab.
+- **Wizard Repos step copy** — reflects the post-redesign reality (action panel + grouped list).
+
 ## [0.1.0] — 2026-05-10
 
 First pre-1.0 release. The public surface (`Profile` interface with `boot` lifecycle hook, `buildCli`, the four core commands `dev / doctor / init-config / mount`, the `cockpit.yaml` schema with `version: 1`) is stable enough for first consumers to depend on. Expect minor churn until the post-1.0 roadmap items land.

package/README.md

@@ -3,26 +3,29 @@
 A reusable, domain-neutral terminal UI dev cockpit. One window for the long-running processes you babysit during development: code, logs, health, and the keystrokes to fix things when they break.
 
 ```
-┌── Repos ── Output ── Health ── Help ────────────────── [↔ / tab] cycle ──┐
-│ Repos                                                                     │
-│   web      docker     idle                                               │
-│   db       docker     idle                                               │
-│   cache    docker     idle                                               │
-│                                                                           │
-│ Recent errors:                                                            │
-│   web │ Stack trace at /srv/app/handler.ts:42                            │
-└───────────────────────────────────────────────────────────────────────────┘
+┌── Targets ── Output ── Health ── Help ────────────────────────────────────┐
+│ Targets                         │ Actions for `web` (docker)             │
+│   ▸ web      [docker]          │   [r] Restart web      (default)       │
+│     ticker   [process]         │   [L] Tail logs                        │
+│     api                        │                                        │
+│                                │                                        │
+│                                │                                        │
+└────────────────────────────────┴────────────────────────────────────────┘
+                                              [↑↓] select  [r] restart  [L] tail
 ```
 
 ## What's in the box
 
-- **Four-pane TUI** — Repos / Output / Health / Help, tab-cycle nav, filter + search modals.
-- **Watchers** — long-running processes spawned once on boot; their stdout streams into Output, tagged by id.
-- **Docker log tailing** — stream `docker compose logs -f <services>` into the same Output pane with regex-driven highlights for errors / stack traces.
-- **Health framework** — five built-in check types (`container-running`, `port-open`, `http-ok`, `file-exists`, `exec-zero`) plus profile-contributed ones; each gets a row on the Health pane and a single-keystroke remediation.
-- **Profile interface** — drop-in adapter so a domain-specific tool can wire its own discoverer / repos / health / commands / cockpit handlers without forking the shell.
+- **Four-pane TUI** — Targets / Output / Health / Help, tab-cycle navigation, filter + search modals, narrow-terminal layouts.
+- **Processes** — long-running commands spawned once on boot; stdout/stderr streamed into Output, tagged by id, with shell-out execution so pipes/redirects/quoted args just work.
+- **Docker log tailing** — stream `docker compose logs -f <services>` into Output with regex-driven highlights (configurable severity per pattern).
+- **Health framework** — five built-in check types (`container-running`, `port-open`, `http-ok`, `file-exists`, `exec-zero`) plus profile-contributed ones; each gets a row + a single-keystroke remediation.
+- **Mount overlay manager** — `dev-cockpit mount` writes a docker-compose overlay + manifest, with an interactive picker, branch / dirty / broken-symlink status table, and profile hooks for restart + dependency-restore on clear.
+- **Actions library** — `config.actions[]` + `Profile.actions` (declarative shell-out OR programmatic `invoke` callbacks). Reach via the vim-style `:` palette or single-keystroke binding scoped to a Targets row.
+- **Profile interface** — drop-in adapter so a domain-specific tool plugs in its discoverer / repos / health / actions / commands / cockpit handlers without forking the shell.
 - **Live markdown Help** — pages render inside the cockpit; profiles can layer their own docs over the generic ones.
 - **Native OS notifications** — fire on state transitions only (no spam). Detached helper, never blocks process exit.
+- **A11y** — `NO_COLOR` strips all styles; semantic glyphs (`✓` `⚠` `✗` `●` `○`) carry severity / status info without color.
 
 ## Install
 
@@ -32,29 +35,41 @@ npm install -g dev-cockpit
 
 Or `npm link` from a checkout for development.
 
+Requires Node ≥ 20.12 (chalk + inquirer use `node:util.styleText`). The bin guards this at startup with a friendly error message.
+
 ## Quick start
 
 ```sh
 cd your-project
-dev-cockpit init-config -i    # interactive wizard, 7 steps with auto-detection
+dev-cockpit init-config -i    # interactive wizard, 8 steps with auto-detection
 dev-cockpit doctor             # validate + print initial health
 dev-cockpit dev                # boot the cockpit
 ```
 
-The wizard sniffs your project: if there's a `compose.yaml` it suggests services to tail, if `package.json` has a `dev` script it offers it as a watcher, if there are workspaces it surfaces them as repo entries. Most prompts just need an enter.
+The wizard sniffs your project: docker compose services from `compose.yaml`, long-running processes from `package.json` (`dev`, `watch`), one-shot actions from the rest of your scripts (`test`, `build`, `lint`, `format`), workspaces as repo entries. Most prompts just need an enter.
 
 ## Configuration
 
-Single file, `cockpit.yaml` at your project root. Schema enforced by zod (`version: 1`). Full reference: [`docs/config-reference.md`](./docs/config-reference.md). Minimal example:
+Single file, `cockpit.yaml` at your project root. Schema enforced by zod (`version: 2`). Full reference: [`docs/config-reference.md`](./docs/config-reference.md). Minimal example:
 
 ```yaml
-version: 1
+version: 2
 appName: my-app
 
-watchers:
+processes:
   - id: vite
     command: npm run dev
 
+actions:
+  - id: test
+    label: Run tests
+    command: npm test
+    key: t                 # `:` palette + single-keystroke binding
+  - id: lint
+    label: Lint
+    command: npm run lint
+    key: l
+
 docker:
   composeFile: compose.yaml
   services:
@@ -76,20 +91,51 @@ notifications:
   enabled: true
 ```
 
+Wrappers upgrading from v1 (pre-rename) configs run `dev-cockpit migrate-config` to persist the v1 → v2 migration (auto-applied in memory on load with a stderr warning).
+
+## Config discovery
+
+dev-cockpit resolves cockpit.yaml in this order:
+
+1. `--config <path>` CLI flag
+2. `DEV_COCKPIT_CONFIG` env var
+3. `<cwd>/cockpit.yaml`
+4. `$XDG_DATA_HOME/dev-cockpit/manifest.json` lookup keyed by canonical `cwd`
+
+All paths inside cockpit.yaml resolve against the **workspace** (your cwd, or whatever a profile's `discoverer`
+returns) — never against the config file's directory. Lets one config serve multiple wrappers without rewriting
+paths.
+
+To use a config that lives outside your project:
+
+	cd ~/code/my-wrapper
+	dev-cockpit link ~/configs/my-wrapper.cockpit.yaml
+	dev-cockpit dev            # picks up the mapping
+
+	dev-cockpit link list      # show all mappings
+	dev-cockpit link remove    # unregister the current cwd
+
 ## Profiles
 
 A profile is a domain-specific bundle that plugs into dev-cockpit's lifecycle. It contributes any combination of:
 
 - `discoverer`        — workspace root resolution
-- `reposProvider`     — Repos-pane entries
+- `reposProvider`     — Targets-pane entries (kind: `repo`)
 - `healthChecks`      — pre-built `HealthCheck[]` (programmatic, beyond the five built-ins)
 - `setupCli`          — extra CLI commands (the profile's own `select`, `release`, etc.)
 - `helpSources`       — markdown docs that layer over the generic Help
+- `defaultHelpPage`   — landing page slug for the Help tab
+- `defaultPane`       — which tab the cockpit lands on (overrides `config.defaultPane`)
 - `configSchemaExt`   — zod schema validating the profile's `profile.<appName>` namespace
+- `actions`           — static action defaults merged into the registry
+- `wizardSteps`       — extra `init-config -i` steps; output lands under `profile.<appName>:`
 - `mountCandidatesProvider` — auto-detected bind-mount candidates
-- `boot`              — async lifecycle hook returning Cockpit pane handlers + `subscribeFsEvents` + `cleanup`
+- `mountSymlinks`     — IDE-facing symlink strategy for mount apply / clear
+- `onMountApply` / `onMountClear` — post-mount lifecycle hooks (restart docker, run installer, etc.)
+- `mountStatusEnricher` — extra columns in `mount status`
+- `boot`              — async lifecycle hook returning Cockpit pane handlers + dynamic `actions` (per-row invoke callbacks) + `subscribeFsEvents` + `cleanup`
 
-A profile is its own npm package — its bin entry composes `buildCli({ profile })` and that's it. The skeleton:
+A profile is its own npm package — its bin entry composes `buildCli({ profile })` and that's it.
 
 ```ts
 import type { Profile } from 'dev-cockpit';
@@ -97,11 +143,22 @@ import type { Profile } from 'dev-cockpit';
 export const myProfile: Profile = {
   appName: 'my-app',
   healthChecks: [...],
-  boot: ({ config, workspaceRoot }) => ({
-    cockpitHandlers: { runRepoAction, onWatchToggle, onLint, onOpenError },
-    subscribeFsEvents: (listener) => watcherManager.subscribeFsEvents(listener),
-    cleanup: () => watcherManager.stop(),
-  }),
+  boot: ({ config, workspaceRoot }) => {
+    const manager = new WatcherManager(...);
+    manager.start();
+    return {
+      // Per-repo programmatic actions: closure over the live WatcherManager.
+      actions: managedRepos.map((repo) => ({
+        id: `repo-rebuild:${repo.name}`,
+        label: `Rebuild ${repo.name}`,
+        scope: `repos:${repo.name}`,
+        key: 'r',
+        invoke: () => manager.rebuild(repo.name),
+      })),
+      subscribeFsEvents: (listener) => manager.subscribeFsEvents(listener),
+      cleanup: () => manager.stop(),
+    };
+  },
 };
 
 // Bin entry — that's it.
@@ -117,7 +174,7 @@ buildCli({ profile: myProfile }).parse(process.argv);
 | Commands | [`docs/commands.md`](./docs/commands.md) |
 | `init-config` wizard | [`docs/init-config.md`](./docs/init-config.md) |
 | Panes | [`docs/panes.md`](./docs/panes.md) |
-| Watchers | [`docs/watchers.md`](./docs/watchers.md) |
+| Processes | [`docs/processes.md`](./docs/processes.md) |
 | Health | [`docs/health.md`](./docs/health.md) |
 | Mounts | [`docs/mount.md`](./docs/mount.md) |
 | Notifications | [`docs/notifications.md`](./docs/notifications.md) |
@@ -128,4 +185,4 @@ buildCli({ profile: myProfile }).parse(process.argv);
 
 ## Status
 
-Pre-1.0. The public surface (`Profile` interface, `buildCli`, the four core commands, `cockpit.yaml` schema with `version: 1`) is stable enough for first consumers to depend on; expect minor churn until the post-1.0 roadmap items land. See `CHANGELOG.md` for what's shipped.
+Pre-1.0. The public surface (`Profile` interface, `buildCli`, the four core commands plus `migrate-config`, `cockpit.yaml` schema with `version: 2`) is stable enough for first consumers to depend on; expect minor churn until the rest of the post-1.0 roadmap items land. See `CHANGELOG.md` for what's shipped.

package/bin/dev-cockpit.mjs

@@ -1,4 +1,30 @@
 #!/usr/bin/env node
+
+// Engine guard. dev-cockpit's import graph (inquirer, ink/@inquirer/core
+// transitives) uses `node:util.styleText` — added in Node 20.12 — at parse
+// time, so older Node fails with a cryptic `SyntaxError: ... does not
+// provide an export named 'styleText'`. Catch it here with a friendly
+// message before any heavy import resolves.
+{
+  const [major, minor] = process.versions.node.split('.').map(Number);
+  if (major < 20 || (major === 20 && minor < 12)) {
+    process.stderr.write(
+      `\ndev-cockpit: Node 20.12+ required (you are on ${process.versions.node}).\n` +
+      `  Run \`nvm use 22\` (or install Node >= 20.12) and retry.\n\n`,
+    );
+    process.exit(1);
+  }
+}
+
+// A11y: honour NO_COLOR strictly. chalk reads NO_COLOR at module-load time
+// and disables foreground/background colours, but it keeps "style" modifiers
+// (bold, inverse, dim) intact. Some terminals still render those visibly.
+// Forcing FORCE_COLOR=0 before any import ensures chalk's level drops to 0,
+// stripping styles too — true monochrome under NO_COLOR.
+if (process.env.NO_COLOR !== undefined && process.env.NO_COLOR !== '') {
+  process.env.FORCE_COLOR = '0';
+}
+
 // Filter Node 22's ExperimentalWarning about JSON modules. The warning fires
 // from a transitive dep (cli-boxes uses `import boxes from './boxes.json' with
 // {type: 'json'}`) the moment the cockpit shell's import graph resolves. It's
@@ -7,10 +33,6 @@
 // before cli-boxes loads.
 const orig = process.emitWarning.bind(process);
 process.emitWarning = (w, ...rest) => {
-  // The JSON-modules warning fires as a plain string with the type passed
-  // separately (`process.emitWarning(text, 'ExperimentalWarning')`), so we
-  // match on the message text directly. The `.name` check from earlier
-  // only worked when the caller handed us an Error object.
   const msg = typeof w === 'string' ? w : (w?.message ?? '');
   if (/JSON modules/i.test(msg)) return;
   return orig(w, ...rest);

package/dist/actions/builtin.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Built-in action synthesis.
+ *
+ * Generates default ActionConfig entries for kinds that have a natural
+ * single-keystroke action — docker services and processes both get `r` to
+ * restart by default. Users can shadow them by declaring an action with
+ * the same scope + key (declared wins during dispatch).
+ *
+ * Built-in ids are prefixed with `__builtin:` so the executor can detect
+ * them and run the right programmatic handler instead of shelling out.
+ */
+import type { BaseCockpitConfig } from '../core/config.js';
+import type { ActionConfig } from './types.js';
+export declare const BUILTIN_PREFIX = "__builtin:";
+export declare const BUILTIN_RESTART_DOCKER = "__builtin:restart-docker:";
+export declare const BUILTIN_RESTART_PROCESS = "__builtin:restart-process:";
+/**
+ * Synthesize built-in restart actions for every docker service and process
+ * declared in the config. Each action lives at `scope: repos:<id>` with
+ * `key: 'r'`. Commands carry a sentinel string only; the executor branches
+ * on the action's id, not its command.
+ */
+export declare function buildBuiltinActions(config: BaseCockpitConfig): ActionConfig[];
+export declare function isBuiltinAction(action: ActionConfig): boolean;
+//# sourceMappingURL=builtin.d.ts.map

package/dist/actions/builtin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin.d.ts","sourceRoot":"","sources":["../../src/actions/builtin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,eAAO,MAAM,cAAc,eAAe,CAAC;AAC3C,eAAO,MAAM,sBAAsB,8BAAqC,CAAC;AACzE,eAAO,MAAM,uBAAuB,+BAAsC,CAAC;AAE3E;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,iBAAiB,GAAG,YAAY,EAAE,CA0B7E;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAE7D"}

package/dist/actions/dispatch.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Action dispatch helpers — pure lookup functions used by pane keystroke
+ * handlers and the right-hand Repos action panel.
+ *
+ * Precedence rule: user-declared (non-builtin) wins over built-in on
+ * matching (scope, key) collisions. This lets a user shadow the default
+ * `r` on a docker/process row with their own command.
+ */
+import type { ActionConfig } from './types.js';
+/**
+ * Actions that apply when the given row key is selected in Repos. Matches:
+ *   - scope === `repos:${rowKey}`  (row-specific)
+ *   - scope === 'repos'            (any row)
+ *
+ * Built-ins are placed AFTER declared so callers that take the first match
+ * get the user override automatically.
+ */
+export declare function actionsForRepoRow(actions: readonly ActionConfig[], rowKey: string): ActionConfig[];
+/** First action in scope matching the keypress, or undefined. */
+export declare function findActionByKey(actions: readonly ActionConfig[], rowKey: string, keypress: string): ActionConfig | undefined;
+//# sourceMappingURL=dispatch.d.ts.map

package/dist/actions/dispatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../../src/actions/dispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,MAAM,EAAE,MAAM,GACb,YAAY,EAAE,CAehB;AAED,iEAAiE;AACjE,wBAAgB,eAAe,CAC7B,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,YAAY,GAAG,SAAS,CAE1B"}

package/dist/actions/registry.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Build the action registry from config + profile sources.
+ *
+ * Merge rule: config entries win on `id` collision. Profile actions act
+ * as defaults the wrapper can override or remove (by re-declaring with
+ * the same id and a different command, or by omitting from config to
+ * keep the profile default).
+ */
+import type { ActionConfig } from './types.js';
+export declare function buildActionRegistry(configActions: readonly ActionConfig[], profileActions?: readonly ActionConfig[]): ActionConfig[];
+//# sourceMappingURL=registry.d.ts.map

package/dist/actions/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/actions/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,wBAAgB,mBAAmB,CACjC,aAAa,EAAE,SAAS,YAAY,EAAE,EACtC,cAAc,GAAE,SAAS,YAAY,EAAO,GAC3C,YAAY,EAAE,CAKhB"}

package/dist/actions/types.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Action subsystem types.
+ *
+ * An "action" is a named, optionally keystroke-bound shell command surfaced
+ * through the cockpit's `:` command palette and/or via direct keypress in a
+ * pane (when `key` + `scope` are set). Actions land via two sources merged
+ * at boot:
+ *   1. config.actions[] in cockpit.yaml — user/wrapper declarations
+ *   2. profile.actions   — profile-bundle defaults
+ *
+ * Config entries win on `id` collision.
+ *
+ * Scope semantics:
+ *   - 'global'        — appears in the `:` palette regardless of focus
+ *   - 'repos'         — appears in `:` AND fires on Repos pane regardless of
+ *                       which row is selected (key dispatch applies to any
+ *                       Repos selection)
+ *   - 'repos:<id>'    — only fires on Repos pane when that specific row is
+ *                       selected; appears in the right-hand action panel
+ *
+ * If `key` is set, the action is dispatchable by a single keypress in the
+ * matching scope. Without `key`, the action is only reachable via `:`.
+ */
+/**
+ * Action scope string. Runtime values:
+ *   - 'global'
+ *   - 'repos'
+ *   - 'repos:<id>' where <id> matches /^[\w-]+$/
+ * Validated at the schema boundary; expressed as plain string in TS to keep
+ * the zod inference aligned with the runtime type (template-literal types
+ * can't be produced by `.regex()`).
+ */
+export type ActionScope = string;
+/** Per-invocation context passed to programmatic action handlers. */
+export interface ActionInvokeContext {
+    /** Workspace root resolved by the cockpit's discoverer / config path. */
+    workspaceRoot: string;
+    /** Action that was matched (the same object the executor received). */
+    action: ActionConfig;
+    /** The Repos row id that was selected when the action fired, if any. */
+    rowKey?: string;
+    /** Push a line into the Output pane, tagged by the action's id. */
+    log: (line: string) => void;
+    /** Push a stderr-shaped warn line into the Output pane. */
+    errLog: (line: string) => void;
+}
+export interface ActionConfig {
+    /** Stable identifier — used by config-vs-profile dedup. */
+    id: string;
+    /** Display label in the `:` palette and the Repos action panel. */
+    label: string;
+    /**
+     * Shell command. Executed via `sh -c <command>` (cmd /c on Windows) so
+     * users can write pipes, redirects, env-prefixes, and quoted args. Mutually
+     * exclusive with `invoke`.
+     */
+    command?: string;
+    /**
+     * Programmatic handler — fires instead of shelling out. Profile-only:
+     * functions don't survive a YAML round-trip, so `config.actions[]` entries
+     * never carry this. Use for actions that mutate in-memory cockpit / profile
+     * state (rebuild via WatcherManager, toggle a chokidar watcher, etc.).
+     */
+    invoke?: (ctx: ActionInvokeContext) => void | Promise<void>;
+    /** Working directory; relative paths resolve against workspaceRoot. */
+    cwd?: string;
+    /** Action visibility / dispatch context. Default: 'global'. */
+    scope?: ActionScope;
+    /**
+     * Optional single-keystroke binding. Matched against the keypress within
+     * the action's scope. Case-sensitive at dispatch time so users can declare
+     * uppercase-only bindings. If absent, the action is reachable only via `:`.
+     */
+    key?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/actions/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/actions/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;;;GAQG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC;AAEjC,qEAAqE;AACrE,MAAM,WAAW,mBAAmB;IAClC,yEAAyE;IACzE,aAAa,EAAE,MAAM,CAAC;IACtB,uEAAuE;IACvE,MAAM,EAAE,YAAY,CAAC;IACrB,wEAAwE;IACxE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,GAAG,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5B,2DAA2D;IAC3D,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAChC;AAED,MAAM,WAAW,YAAY;IAC3B,2DAA2D;IAC3D,EAAE,EAAE,MAAM,CAAC;IACX,mEAAmE;IACnE,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,mBAAmB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5D,uEAAuE;IACvE,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,+DAA+D;IAC/D,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB;;;;OAIG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;CACd"}

package/dist/buildCli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildCli.d.ts","sourceRoot":"","sources":["../src/buildCli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAU/C,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAkBD,wBAAgB,QAAQ,CAAC,IAAI,GAAE,eAAoB,GAAG,OAAO,CAwF5D"}
+{"version":3,"file":"buildCli.d.ts","sourceRoot":"","sources":["../src/buildCli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAW/C,MAAM,WAAW,eAAe;IAC/B,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAkBD,wBAAgB,QAAQ,CAAC,IAAI,GAAE,eAAoB,GAAG,OAAO,CA6I5D"}

package/dist/chunk-6XGHLLYT.js

@@ -0,0 +1,46 @@
+import { createRequire as __createRequireDC } from 'node:module';
+const require = __createRequireDC(import.meta.url);
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __export,
+  __toESM
+};
+//# sourceMappingURL=chunk-6XGHLLYT.js.map

package/dist/chunk-6XGHLLYT.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/chunk-C4GFJDMG.js

@@ -0,0 +1,79 @@
+import { createRequire as __createRequireDC } from 'node:module';
+const require = __createRequireDC(import.meta.url);
+
+
+// src/core/manifest.ts
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+var MANIFEST_VERSION = 1;
+function manifestPath() {
+  const xdgDataHome = process.env["XDG_DATA_HOME"] || path.join(os.homedir(), ".local", "share");
+  return path.join(xdgDataHome, "dev-cockpit", "manifest.json");
+}
+function canonical(p) {
+  const abs = path.resolve(p);
+  try {
+    return fs.realpathSync(abs);
+  } catch {
+    return abs;
+  }
+}
+function readManifest() {
+  const filePath = manifestPath();
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    const raw = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    if (raw.version !== MANIFEST_VERSION) return null;
+    if (!raw.projects || typeof raw.projects !== "object") return null;
+    const projects = {};
+    for (const [k, v] of Object.entries(raw.projects)) {
+      if (typeof k === "string" && typeof v === "string") projects[k] = v;
+    }
+    return { version: MANIFEST_VERSION, projects };
+  } catch {
+    return null;
+  }
+}
+function lookupConfig(workspaceRoot) {
+  const m = readManifest();
+  if (!m) return null;
+  return m.projects[canonical(workspaceRoot)] ?? null;
+}
+function writeManifest(m) {
+  const filePath = manifestPath();
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const tmp = `${filePath}.tmp`;
+  fs.writeFileSync(tmp, `${JSON.stringify(m, null, 2)}
+`, "utf8");
+  fs.renameSync(tmp, filePath);
+}
+function setMapping(workspaceRoot, configPath) {
+  const existing = readManifest() ?? { version: MANIFEST_VERSION, projects: {} };
+  existing.projects[canonical(workspaceRoot)] = canonical(configPath);
+  writeManifest(existing);
+}
+function removeMapping(workspaceRoot) {
+  const existing = readManifest();
+  if (!existing) return false;
+  const key = canonical(workspaceRoot);
+  if (!(key in existing.projects)) return false;
+  delete existing.projects[key];
+  writeManifest(existing);
+  return true;
+}
+function listMappings() {
+  const m = readManifest();
+  if (!m) return [];
+  return Object.entries(m.projects).map(([workspace, config]) => ({ workspace, config })).sort((a, b) => a.workspace.localeCompare(b.workspace));
+}
+
+export {
+  manifestPath,
+  canonical,
+  lookupConfig,
+  setMapping,
+  removeMapping,
+  listMappings
+};
+//# sourceMappingURL=chunk-C4GFJDMG.js.map

package/dist/chunk-C4GFJDMG.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/core/manifest.ts"],
+  "sourcesContent": ["/**\n * Read/write the global project\u2192config manifest at\n * `$XDG_DATA_HOME/dev-cockpit/manifest.json`. Keys are canonical\n * absolute paths to a workspace root; values are absolute paths to\n * the cockpit.yaml that workspace should use.\n *\n * Used by core/config-discovery.ts as the last-resort lookup when\n * the workspace doesn't carry its own cockpit.yaml at the root.\n */\n\nimport fs from 'node:fs';\nimport os from 'node:os';\nimport path from 'node:path';\n\nconst MANIFEST_VERSION = 1 as const;\n\nexport interface Manifest {\n  version: typeof MANIFEST_VERSION;\n  projects: Record<string, string>;\n}\n\n/** Absolute path of `$XDG_DATA_HOME/dev-cockpit/manifest.json`. */\nexport function manifestPath(): string {\n  // `||` (not `??`) so an empty-string env var falls through to the default.\n  const xdgDataHome =\n    process.env['XDG_DATA_HOME'] || path.join(os.homedir(), '.local', 'share');\n  return path.join(xdgDataHome, 'dev-cockpit', 'manifest.json');\n}\n\n/**\n * Canonicalise an absolute path \u2014 resolves symlinks if the path exists,\n * falls back to `path.resolve()` otherwise. Ensures a symlinked workspace\n * dir (`~/work`) and its real target (`/Users/me/code/work`) hash to the\n * same manifest key.\n */\nexport function canonical(p: string): string {\n  const abs = path.resolve(p);\n  try {\n    return fs.realpathSync(abs);\n  } catch {\n    return abs;\n  }\n}\n\n/**\n * Read the manifest. Returns `null` when the file is missing, unreadable,\n * malformed JSON, or doesn't match the expected shape. Callers treat null\n * as \"no mapping registered\" rather than an error \u2014 the user simply\n * hasn't run `dev-cockpit link` yet.\n */\nexport function readManifest(): Manifest | null {\n  const filePath = manifestPath();\n  if (!fs.existsSync(filePath)) return null;\n  try {\n    const raw = JSON.parse(fs.readFileSync(filePath, 'utf8')) as Partial<Manifest>;\n    if (raw.version !== MANIFEST_VERSION) return null;\n    if (!raw.projects || typeof raw.projects !== 'object') return null;\n    const projects: Record<string, string> = {};\n    for (const [k, v] of Object.entries(raw.projects)) {\n      if (typeof k === 'string' && typeof v === 'string') projects[k] = v;\n    }\n    return { version: MANIFEST_VERSION, projects };\n  } catch {\n    return null;\n  }\n}\n\n/** Look up a workspace's config path. Returns `null` when unmapped. */\nexport function lookupConfig(workspaceRoot: string): string | null {\n  const m = readManifest();\n  if (!m) return null;\n  return m.projects[canonical(workspaceRoot)] ?? null;\n}\n\n/**\n * Atomic write: serialise to `<file>.tmp` next to the manifest, then\n * rename onto the real path. Creates the parent dir if missing. Same\n * pattern used by dev-cockpit's mount-manifest writer.\n */\nfunction writeManifest(m: Manifest): void {\n  const filePath = manifestPath();\n  fs.mkdirSync(path.dirname(filePath), { recursive: true });\n  const tmp = `${filePath}.tmp`;\n  fs.writeFileSync(tmp, `${JSON.stringify(m, null, 2)}\\n`, 'utf8');\n  fs.renameSync(tmp, filePath);\n}\n\n/**\n * Register a mapping. Both inputs are canonicalised first \u2014 the\n * workspace key is resolved through symlinks so a `~/work` symlink and\n * `/Users/me/code/work` real path resolve to the same entry.\n */\nexport function setMapping(workspaceRoot: string, configPath: string): void {\n  const existing = readManifest() ?? { version: MANIFEST_VERSION, projects: {} };\n  existing.projects[canonical(workspaceRoot)] = canonical(configPath);\n  writeManifest(existing);\n}\n\n/** Remove a mapping. Returns `true` when an entry was deleted. */\nexport function removeMapping(workspaceRoot: string): boolean {\n  const existing = readManifest();\n  if (!existing) return false;\n  const key = canonical(workspaceRoot);\n  if (!(key in existing.projects)) return false;\n  delete existing.projects[key];\n  writeManifest(existing);\n  return true;\n}\n\n/** Sorted mapping list, for `dev-cockpit link list`. */\nexport function listMappings(): Array<{ workspace: string; config: string }> {\n  const m = readManifest();\n  if (!m) return [];\n  return Object.entries(m.projects)\n    .map(([workspace, config]) => ({ workspace, config }))\n    .sort((a, b) => a.workspace.localeCompare(b.workspace));\n}\n"],
+  "mappings": ";;;;;AAUA,OAAO,QAAQ;AACf,OAAO,QAAQ;AACf,OAAO,UAAU;AAEjB,IAAM,mBAAmB;AAQlB,SAAS,eAAuB;AAErC,QAAM,cACJ,QAAQ,IAAI,eAAe,KAAK,KAAK,KAAK,GAAG,QAAQ,GAAG,UAAU,OAAO;AAC3E,SAAO,KAAK,KAAK,aAAa,eAAe,eAAe;AAC9D;AAQO,SAAS,UAAU,GAAmB;AAC3C,QAAM,MAAM,KAAK,QAAQ,CAAC;AAC1B,MAAI;AACF,WAAO,GAAG,aAAa,GAAG;AAAA,EAC5B,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAQO,SAAS,eAAgC;AAC9C,QAAM,WAAW,aAAa;AAC9B,MAAI,CAAC,GAAG,WAAW,QAAQ,EAAG,QAAO;AACrC,MAAI;AACF,UAAM,MAAM,KAAK,MAAM,GAAG,aAAa,UAAU,MAAM,CAAC;AACxD,QAAI,IAAI,YAAY,iBAAkB,QAAO;AAC7C,QAAI,CAAC,IAAI,YAAY,OAAO,IAAI,aAAa,SAAU,QAAO;AAC9D,UAAM,WAAmC,CAAC;AAC1C,eAAW,CAAC,GAAG,CAAC,KAAK,OAAO,QAAQ,IAAI,QAAQ,GAAG;AACjD,UAAI,OAAO,MAAM,YAAY,OAAO,MAAM,SAAU,UAAS,CAAC,IAAI;AAAA,IACpE;AACA,WAAO,EAAE,SAAS,kBAAkB,SAAS;AAAA,EAC/C,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAGO,SAAS,aAAa,eAAsC;AACjE,QAAM,IAAI,aAAa;AACvB,MAAI,CAAC,EAAG,QAAO;AACf,SAAO,EAAE,SAAS,UAAU,aAAa,CAAC,KAAK;AACjD;AAOA,SAAS,cAAc,GAAmB;AACxC,QAAM,WAAW,aAAa;AAC9B,KAAG,UAAU,KAAK,QAAQ,QAAQ,GAAG,EAAE,WAAW,KAAK,CAAC;AACxD,QAAM,MAAM,GAAG,QAAQ;AACvB,KAAG,cAAc,KAAK,GAAG,KAAK,UAAU,GAAG,MAAM,CAAC,CAAC;AAAA,GAAM,MAAM;AAC/D,KAAG,WAAW,KAAK,QAAQ;AAC7B;AAOO,SAAS,WAAW,eAAuB,YAA0B;AAC1E,QAAM,WAAW,aAAa,KAAK,EAAE,SAAS,kBAAkB,UAAU,CAAC,EAAE;AAC7E,WAAS,SAAS,UAAU,aAAa,CAAC,IAAI,UAAU,UAAU;AAClE,gBAAc,QAAQ;AACxB;AAGO,SAAS,cAAc,eAAgC;AAC5D,QAAM,WAAW,aAAa;AAC9B,MAAI,CAAC,SAAU,QAAO;AACtB,QAAM,MAAM,UAAU,aAAa;AACnC,MAAI,EAAE,OAAO,SAAS,UAAW,QAAO;AACxC,SAAO,SAAS,SAAS,GAAG;AAC5B,gBAAc,QAAQ;AACtB,SAAO;AACT;AAGO,SAAS,eAA6D;AAC3E,QAAM,IAAI,aAAa;AACvB,MAAI,CAAC,EAAG,QAAO,CAAC;AAChB,SAAO,OAAO,QAAQ,EAAE,QAAQ,EAC7B,IAAI,CAAC,CAAC,WAAW,MAAM,OAAO,EAAE,WAAW,OAAO,EAAE,EACpD,KAAK,CAAC,GAAG,MAAM,EAAE,UAAU,cAAc,EAAE,SAAS,CAAC;AAC1D;",
+  "names": []
+}