dev-cockpit 0.2.1 → 0.2.2

package/dist/index.js

@@ -15,6 +15,11 @@ import {
 import {
   require_react
 } from "./chunk-VN6UILQW.js";
+import {
+  canonical,
+  lookupConfig,
+  manifestPath
+} from "./chunk-C4GFJDMG.js";
 import {
   __commonJS,
   __export,
@@ -1197,7 +1202,7 @@ var require_atomic_sleep = __commonJS({
 var require_sonic_boom = __commonJS({
   "node_modules/sonic-boom/index.js"(exports, module) {
     "use strict";
-    var fs17 = __require("fs");
+    var fs18 = __require("fs");
     var EventEmitter3 = __require("events");
     var inherits = __require("util").inherits;
     var path21 = __require("path");
@@ -1254,20 +1259,20 @@ var require_sonic_boom = __commonJS({
       const mode = sonic.mode;
       if (sonic.sync) {
         try {
-          if (sonic.mkdir) fs17.mkdirSync(path21.dirname(file), { recursive: true });
-          const fd = fs17.openSync(file, flags, mode);
+          if (sonic.mkdir) fs18.mkdirSync(path21.dirname(file), { recursive: true });
+          const fd = fs18.openSync(file, flags, mode);
           fileOpened(null, fd);
         } catch (err) {
           fileOpened(err);
           throw err;
         }
       } else if (sonic.mkdir) {
-        fs17.mkdir(path21.dirname(file), { recursive: true }, (err) => {
+        fs18.mkdir(path21.dirname(file), { recursive: true }, (err) => {
           if (err) return fileOpened(err);
-          fs17.open(file, flags, mode, fileOpened);
+          fs18.open(file, flags, mode, fileOpened);
         });
       } else {
-        fs17.open(file, flags, mode, fileOpened);
+        fs18.open(file, flags, mode, fileOpened);
       }
     }
     function SonicBoom(opts) {
@@ -1308,8 +1313,8 @@ var require_sonic_boom = __commonJS({
         this.flush = flushBuffer;
         this.flushSync = flushBufferSync;
         this._actualWrite = actualWriteBuffer;
-        fsWriteSync = () => fs17.writeSync(this.fd, this._writingBuf);
-        fsWrite = () => fs17.write(this.fd, this._writingBuf, this.release);
+        fsWriteSync = () => fs18.writeSync(this.fd, this._writingBuf);
+        fsWrite = () => fs18.write(this.fd, this._writingBuf, this.release);
       } else if (contentMode === void 0 || contentMode === kContentModeUtf8) {
         this._writingBuf = "";
         this.write = write;
@@ -1318,15 +1323,15 @@ var require_sonic_boom = __commonJS({
         this._actualWrite = actualWrite;
         fsWriteSync = () => {
           if (Buffer.isBuffer(this._writingBuf)) {
-            return fs17.writeSync(this.fd, this._writingBuf);
+            return fs18.writeSync(this.fd, this._writingBuf);
           }
-          return fs17.writeSync(this.fd, this._writingBuf, "utf8");
+          return fs18.writeSync(this.fd, this._writingBuf, "utf8");
         };
         fsWrite = () => {
           if (Buffer.isBuffer(this._writingBuf)) {
-            return fs17.write(this.fd, this._writingBuf, this.release);
+            return fs18.write(this.fd, this._writingBuf, this.release);
           }
-          return fs17.write(this.fd, this._writingBuf, "utf8", this.release);
+          return fs18.write(this.fd, this._writingBuf, "utf8", this.release);
         };
       } else {
         throw new Error(`SonicBoom supports "${kContentModeUtf8}" and "${kContentModeBuffer}", but passed ${contentMode}`);
@@ -1383,7 +1388,7 @@ var require_sonic_boom = __commonJS({
           }
         }
         if (this._fsync) {
-          fs17.fsyncSync(this.fd);
+          fs18.fsyncSync(this.fd);
         }
         const len = this._len;
         if (this._reopening) {
@@ -1497,7 +1502,7 @@ var require_sonic_boom = __commonJS({
       const onDrain = () => {
         if (!this._fsync) {
           try {
-            fs17.fsync(this.fd, (err) => {
+            fs18.fsync(this.fd, (err) => {
               this._flushPending = false;
               cb(err);
             });
@@ -1599,7 +1604,7 @@ var require_sonic_boom = __commonJS({
       const fd = this.fd;
       this.once("ready", () => {
         if (fd !== this.fd) {
-          fs17.close(fd, (err) => {
+          fs18.close(fd, (err) => {
             if (err) {
               return this.emit("error", err);
             }
@@ -1648,7 +1653,7 @@ var require_sonic_boom = __commonJS({
           buf = this._bufs[0];
         }
         try {
-          const n2 = Buffer.isBuffer(buf) ? fs17.writeSync(this.fd, buf) : fs17.writeSync(this.fd, buf, "utf8");
+          const n2 = Buffer.isBuffer(buf) ? fs18.writeSync(this.fd, buf) : fs18.writeSync(this.fd, buf, "utf8");
           const releasedBufObj = releaseWritingBuf(buf, this._len, n2);
           buf = releasedBufObj.writingBuf;
           this._len = releasedBufObj.len;
@@ -1664,7 +1669,7 @@ var require_sonic_boom = __commonJS({
         }
       }
       try {
-        fs17.fsyncSync(this.fd);
+        fs18.fsyncSync(this.fd);
       } catch {
       }
     }
@@ -1685,7 +1690,7 @@ var require_sonic_boom = __commonJS({
           buf = mergeBuf(this._bufs[0], this._lens[0]);
         }
         try {
-          const n2 = fs17.writeSync(this.fd, buf);
+          const n2 = fs18.writeSync(this.fd, buf);
           buf = buf.subarray(n2);
           this._len = Math.max(this._len - n2, 0);
           if (buf.length <= 0) {
@@ -1713,13 +1718,13 @@ var require_sonic_boom = __commonJS({
       this._writingBuf = this._writingBuf.length ? this._writingBuf : this._bufs.shift() || "";
       if (this.sync) {
         try {
-          const written = Buffer.isBuffer(this._writingBuf) ? fs17.writeSync(this.fd, this._writingBuf) : fs17.writeSync(this.fd, this._writingBuf, "utf8");
+          const written = Buffer.isBuffer(this._writingBuf) ? fs18.writeSync(this.fd, this._writingBuf) : fs18.writeSync(this.fd, this._writingBuf, "utf8");
           release(null, written);
         } catch (err) {
           release(err);
         }
       } else {
-        fs17.write(this.fd, this._writingBuf, release);
+        fs18.write(this.fd, this._writingBuf, release);
       }
     }
     function actualWriteBuffer() {
@@ -1728,7 +1733,7 @@ var require_sonic_boom = __commonJS({
       this._writingBuf = this._writingBuf.length ? this._writingBuf : mergeBuf(this._bufs.shift(), this._lens.shift());
       if (this.sync) {
         try {
-          const written = fs17.writeSync(this.fd, this._writingBuf);
+          const written = fs18.writeSync(this.fd, this._writingBuf);
           release(null, written);
         } catch (err) {
           release(err);
@@ -1737,7 +1742,7 @@ var require_sonic_boom = __commonJS({
         if (kCopyBuffer) {
           this._writingBuf = Buffer.from(this._writingBuf);
         }
-        fs17.write(this.fd, this._writingBuf, release);
+        fs18.write(this.fd, this._writingBuf, release);
       }
     }
     function actualClose(sonic) {
@@ -1753,12 +1758,12 @@ var require_sonic_boom = __commonJS({
       sonic._lens = [];
       assert(typeof sonic.fd === "number", `sonic.fd must be a number, got ${typeof sonic.fd}`);
       try {
-        fs17.fsync(sonic.fd, closeWrapped);
+        fs18.fsync(sonic.fd, closeWrapped);
       } catch {
       }
       function closeWrapped() {
         if (sonic.fd !== 1 && sonic.fd !== 2) {
-          fs17.close(sonic.fd, done);
+          fs18.close(sonic.fd, done);
         } else {
           done();
         }
@@ -4332,7 +4337,7 @@ var require_windows = __commonJS({
   "node_modules/isexe/windows.js"(exports, module) {
     module.exports = isexe;
     isexe.sync = sync;
-    var fs17 = __require("fs");
+    var fs18 = __require("fs");
     function checkPathExt(path21, options2) {
       var pathext = options2.pathExt !== void 0 ? options2.pathExt : process.env.PATHEXT;
       if (!pathext) {
@@ -4357,12 +4362,12 @@ var require_windows = __commonJS({
       return checkPathExt(path21, options2);
     }
     function isexe(path21, options2, cb) {
-      fs17.stat(path21, function(er, stat4) {
+      fs18.stat(path21, function(er, stat4) {
         cb(er, er ? false : checkStat(stat4, path21, options2));
       });
     }
     function sync(path21, options2) {
-      return checkStat(fs17.statSync(path21), path21, options2);
+      return checkStat(fs18.statSync(path21), path21, options2);
     }
   }
 });
@@ -4372,14 +4377,14 @@ var require_mode = __commonJS({
   "node_modules/isexe/mode.js"(exports, module) {
     module.exports = isexe;
     isexe.sync = sync;
-    var fs17 = __require("fs");
+    var fs18 = __require("fs");
     function isexe(path21, options2, cb) {
-      fs17.stat(path21, function(er, stat4) {
+      fs18.stat(path21, function(er, stat4) {
         cb(er, er ? false : checkStat(stat4, options2));
       });
     }
     function sync(path21, options2) {
-      return checkStat(fs17.statSync(path21), options2);
+      return checkStat(fs18.statSync(path21), options2);
     }
     function checkStat(stat4, options2) {
       return stat4.isFile() && checkMode(stat4, options2);
@@ -4403,7 +4408,7 @@ var require_mode = __commonJS({
 // node_modules/isexe/index.js
 var require_isexe = __commonJS({
   "node_modules/isexe/index.js"(exports, module) {
-    var fs17 = __require("fs");
+    var fs18 = __require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -4667,16 +4672,16 @@ var require_shebang_command = __commonJS({
 var require_readShebang = __commonJS({
   "node_modules/cross-spawn/lib/util/readShebang.js"(exports, module) {
     "use strict";
-    var fs17 = __require("fs");
+    var fs18 = __require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
       const buffer = Buffer.alloc(size);
       let fd;
       try {
-        fd = fs17.openSync(command, "r");
-        fs17.readSync(fd, buffer, 0, size, 0);
-        fs17.closeSync(fd);
+        fd = fs18.openSync(command, "r");
+        fs18.readSync(fd, buffer, 0, size, 0);
+        fs18.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -11683,14 +11688,14 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs17 = this.flowScalar(this.type);
+              const fs18 = this.flowScalar(this.type);
               if (atNextItem || it.value) {
-                map.items.push({ start, key: fs17, sep: [] });
+                map.items.push({ start, key: fs18, sep: [] });
                 this.onKeyLine = true;
               } else if (it.sep) {
-                this.stack.push(fs17);
+                this.stack.push(fs18);
               } else {
-                Object.assign(it, { key: fs17, sep: [] });
+                Object.assign(it, { key: fs18, sep: [] });
                 this.onKeyLine = true;
               }
               return;
@@ -11818,13 +11823,13 @@ var require_parser = __commonJS({
             case "scalar":
             case "single-quoted-scalar":
             case "double-quoted-scalar": {
-              const fs17 = this.flowScalar(this.type);
+              const fs18 = this.flowScalar(this.type);
               if (!it || it.value)
-                fc.items.push({ start: [], key: fs17, sep: [] });
+                fc.items.push({ start: [], key: fs18, sep: [] });
               else if (it.sep)
-                this.stack.push(fs17);
+                this.stack.push(fs18);
               else
-                Object.assign(it, { key: fs17, sep: [] });
+                Object.assign(it, { key: fs18, sep: [] });
               return;
             }
             case "flow-map-end":
@@ -13066,7 +13071,7 @@ var require_command = __commonJS({
     var EventEmitter3 = __require("node:events").EventEmitter;
     var childProcess = __require("node:child_process");
     var path21 = __require("node:path");
-    var fs17 = __require("node:fs");
+    var fs18 = __require("node:fs");
     var process10 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -13999,10 +14004,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
           const localBin = path21.resolve(baseDir, baseName);
-          if (fs17.existsSync(localBin)) return localBin;
+          if (fs18.existsSync(localBin)) return localBin;
           if (sourceExt.includes(path21.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs17.existsSync(`${localBin}${ext}`)
+            (ext) => fs18.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -14014,7 +14019,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs17.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs18.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
@@ -90787,8 +90792,8 @@ import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { dirname as dirname3, join as join3 } from "node:path";
 
 // src/commands/dev.ts
-import path13 from "node:path";
-import fs8 from "node:fs";
+import path14 from "node:path";
+import fs9 from "node:fs";
 
 // src/actions/registry.ts
 function buildActionRegistry(configActions, profileActions = []) {
@@ -90798,23 +90803,78 @@ function buildActionRegistry(configActions, profileActions = []) {
   return Array.from(byId.values());
 }
 
+// src/core/config-discovery.ts
+import fs8 from "node:fs";
+import path13 from "node:path";
+var DiscoveryError = class extends Error {
+  constructor(workspaceRoot) {
+    super(
+      `dev-cockpit: no cockpit.yaml found at ${workspaceRoot}/cockpit.yaml and no entry in ${manifestPath()}. Run \`dev-cockpit link <config-path>\` from this directory to register one, or pass --config <path>.`
+    );
+    this.workspaceRoot = workspaceRoot;
+    this.name = "DiscoveryError";
+  }
+};
+function discoverConfig(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const envConfig = opts.envConfig ?? process.env["DEV_COCKPIT_CONFIG"];
+  const profileRoot = opts.workspaceDiscoverer?.()?.root;
+  const workspaceRoot = profileRoot ? canonical(profileRoot) : canonical(cwd);
+  if (opts.cliConfig) {
+    return {
+      configPath: path13.resolve(cwd, opts.cliConfig),
+      workspaceRoot,
+      source: "cli"
+    };
+  }
+  if (envConfig) {
+    return {
+      configPath: path13.resolve(cwd, envConfig),
+      workspaceRoot,
+      source: "env"
+    };
+  }
+  const localConfig = path13.join(workspaceRoot, "cockpit.yaml");
+  if (fs8.existsSync(localConfig)) {
+    return { configPath: localConfig, workspaceRoot, source: "workspace" };
+  }
+  const mapped = lookupConfig(workspaceRoot);
+  if (mapped) {
+    return { configPath: mapped, workspaceRoot, source: "manifest" };
+  }
+  throw new DiscoveryError(workspaceRoot);
+}
+
 // src/commands/dev.ts
 async function devCommand(opts = {}) {
-  const configPath = path13.resolve(opts.config ?? "cockpit.yaml");
-  if (!fs8.existsSync(configPath)) {
+  const profile = opts.profile;
+  let configPath;
+  let workspaceRoot;
+  try {
+    const result = discoverConfig({
+      cliConfig: opts.config,
+      workspaceDiscoverer: profile?.discoverer
+    });
+    configPath = result.configPath;
+    workspaceRoot = result.workspaceRoot;
+  } catch (err) {
+    if (err instanceof DiscoveryError) {
+      process.stderr.write(`${err.message}
+`);
+      process.exit(1);
+    }
+    throw err;
+  }
+  if (!fs9.existsSync(configPath)) {
     process.stderr.write(
-      `dev-cockpit: no cockpit.yaml found at ${configPath}.
-  Run \`dev-cockpit init-config\` to scaffold one.
-`
+      `dev-cockpit: cockpit.yaml at ${configPath} doesn't exist (resolved via --config DEV_COCKPIT_CONFIG / link).`
     );
     process.exit(1);
   }
-  const profile = opts.profile;
   const config = loadConfig(configPath, {
     configSchemaExt: profile?.configSchemaExt,
     profileKey: profile?.appName
   });
-  const workspaceRoot = profile?.discoverer?.()?.root ?? path13.dirname(configPath);
   const seededRepos = {};
   const seededOrder = [];
   for (const repo of config.repos) {
@@ -90886,7 +90946,7 @@ async function devCommand(opts = {}) {
       });
     };
     spawnStream(shell, [shellFlag, proc.command], {
-      cwd: proc.cwd ? path13.resolve(workspaceRoot, proc.cwd) : workspaceRoot,
+      cwd: proc.cwd ? path14.resolve(workspaceRoot, proc.cwd) : workspaceRoot,
       env: proc.env,
       tag: proc.id,
       onStdout: (line2) => emit(line2, "info"),
@@ -90958,7 +91018,7 @@ async function devCommand(opts = {}) {
       });
       return;
     }
-    const cwd = action.cwd ? path13.resolve(workspaceRoot, action.cwd) : workspaceRoot;
+    const cwd = action.cwd ? path14.resolve(workspaceRoot, action.cwd) : workspaceRoot;
     store.appendOutput({
       ts: Date.now(),
       source: action.id,
@@ -91024,8 +91084,7 @@ async function devCommand(opts = {}) {
 }
 
 // src/commands/doctor.ts
-import path14 from "node:path";
-import fs9 from "node:fs";
+import fs10 from "node:fs";
 var GLYPH = {
   ok: "\u2713",
   warn: "\u26A0",
@@ -91053,18 +91112,34 @@ function formatResults(results, appName) {
   return { lines, exitCode: anyError ? 1 : 0 };
 }
 async function doctorCommand(opts = {}) {
-  const configPath = path14.resolve(opts.config ?? "cockpit.yaml");
-  if (!fs9.existsSync(configPath)) {
-    process.stderr.write(`dev-cockpit doctor: no cockpit.yaml found at ${configPath}.
+  const profile = opts.profile;
+  let configPath;
+  let workspaceRoot;
+  try {
+    const result = discoverConfig({
+      cliConfig: opts.config,
+      workspaceDiscoverer: profile?.discoverer
+    });
+    configPath = result.configPath;
+    workspaceRoot = result.workspaceRoot;
+  } catch (err) {
+    if (err instanceof DiscoveryError) {
+      process.stderr.write(`${err.message}
 `);
+      process.exit(1);
+    }
+    throw err;
+  }
+  if (!fs10.existsSync(configPath)) {
+    process.stderr.write(
+      `dev-cockpit: cockpit.yaml at ${configPath} doesn't exist (resolved via --config DEV_COCKPIT_CONFIG / link).`
+    );
     process.exit(1);
   }
-  const profile = opts.profile;
   const config = loadConfig(configPath, {
     configSchemaExt: profile?.configSchemaExt,
     profileKey: profile?.appName
   });
-  const workspaceRoot = profile?.discoverer?.()?.root ?? path14.dirname(configPath);
   const ctx = buildHealthContext(workspaceRoot);
   const registry = buildHealthRegistry({
     profileChecks: profile?.healthChecks,
@@ -91080,11 +91155,11 @@ async function doctorCommand(opts = {}) {
 }
 
 // src/commands/init-config.ts
-import fs11 from "node:fs";
+import fs12 from "node:fs";
 import path16 from "node:path";
 
 // src/commands/init-config-wizard.ts
-import fs10 from "node:fs";
+import fs11 from "node:fs";
 import path15 from "node:path";
 function indent(line2, level) {
   return "  ".repeat(level) + line2;
@@ -91266,20 +91341,20 @@ function showSummary(result) {
 }
 function safeReadJson(p) {
   try {
-    return JSON.parse(fs10.readFileSync(p, "utf8"));
+    return JSON.parse(fs11.readFileSync(p, "utf8"));
   } catch {
     return null;
   }
 }
 function detectComposeFile(cwd) {
   for (const candidate of ["compose.yaml", "compose.yml", "docker-compose.yml", "docker-compose.yaml"]) {
-    if (fs10.existsSync(path15.join(cwd, candidate))) return candidate;
+    if (fs11.existsSync(path15.join(cwd, candidate))) return candidate;
   }
   return void 0;
 }
 function parseComposeServices(cwd, composeFile) {
   try {
-    const text = fs10.readFileSync(path15.join(cwd, composeFile), "utf8");
+    const text = fs11.readFileSync(path15.join(cwd, composeFile), "utf8");
     const out = [];
     let inServices = false;
     for (const raw of text.split("\n")) {
@@ -91314,9 +91389,9 @@ function detectRepoSuggestions(cwd, pkg) {
     }
   }
   const pnpmFile = path15.join(cwd, "pnpm-workspace.yaml");
-  if (fs10.existsSync(pnpmFile)) {
+  if (fs11.existsSync(pnpmFile)) {
     try {
-      const text = fs10.readFileSync(pnpmFile, "utf8");
+      const text = fs11.readFileSync(pnpmFile, "utf8");
       const inPackages = /packages:\s*([\s\S]*?)(?:\n[a-zA-Z]|$)/.exec(text);
       if (inPackages?.[1]) {
         for (const line2 of inPackages[1].split("\n")) {
@@ -91341,15 +91416,15 @@ function detectRepoSuggestions(cwd, pkg) {
 }
 function expandSimpleGlob(cwd, glob) {
   if (!glob.includes("*")) {
-    return fs10.existsSync(path15.join(cwd, glob)) ? [glob] : [];
+    return fs11.existsSync(path15.join(cwd, glob)) ? [glob] : [];
   }
   const m = /^([^*]+?)\/?\*$/.exec(glob);
   if (!m?.[1]) return [];
   const baseRel = m[1];
   const baseAbs = path15.join(cwd, baseRel);
-  if (!fs10.existsSync(baseAbs)) return [];
+  if (!fs11.existsSync(baseAbs)) return [];
   try {
-    return fs10.readdirSync(baseAbs, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => path15.posix.join(baseRel, d.name));
+    return fs11.readdirSync(baseAbs, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith(".")).map((d) => path15.posix.join(baseRel, d.name));
   } catch {
     return [];
   }
@@ -91365,8 +91440,8 @@ function gatherHints(cwd) {
     packageJsonScripts: pkgScripts,
     composeFile,
     composeServices,
-    hasArtisan: fs10.existsSync(path15.join(cwd, "artisan")),
-    hasComposerJson: fs10.existsSync(path15.join(cwd, "composer.json")),
+    hasArtisan: fs11.existsSync(path15.join(cwd, "artisan")),
+    hasComposerJson: fs11.existsSync(path15.join(cwd, "composer.json")),
     repoSuggestions: detectRepoSuggestions(cwd, pkg)
   };
 }
@@ -92092,8 +92167,8 @@ ${dockerBlock}
 }
 async function initConfigCommand(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
-  const target = path16.join(cwd, "cockpit.yaml");
-  const exists = fs11.existsSync(target);
+  const target = opts.output ? path16.resolve(cwd, opts.output) : path16.join(cwd, "cockpit.yaml");
+  const exists = fs12.existsSync(target);
   if (exists && !opts.force) {
     process.stdout.write(
       `dev-cockpit init-config: ${target} already exists.
@@ -92112,7 +92187,7 @@ async function initConfigCommand(opts = {}) {
     withDocker: opts.withDocker ?? false,
     appName: opts.appName ?? "my-cockpit"
   });
-  fs11.writeFileSync(target, content, "utf8");
+  fs12.writeFileSync(target, content, "utf8");
   process.stdout.write(`
 dev-cockpit init-config: wrote ${target}
 `);
@@ -92147,10 +92222,10 @@ doctor failed: ${err instanceof Error ? err.message : String(err)}
 
 // src/commands/mount.ts
 import path19 from "node:path";
-import fs14 from "node:fs";
+import fs15 from "node:fs";
 
 // src/mount/manifest.ts
-import fs12 from "node:fs";
+import fs13 from "node:fs";
 import path17 from "node:path";
 var CURRENT_MANIFEST_VERSION = 1;
 var MountManifestError = class extends Error {
@@ -92159,24 +92234,24 @@ var MountManifestError = class extends Error {
     this.name = "MountManifestError";
   }
 };
-function readMountManifest(manifestPath) {
-  if (!fs12.existsSync(manifestPath)) return null;
+function readMountManifest(manifestPath2) {
+  if (!fs13.existsSync(manifestPath2)) return null;
   let raw;
   try {
-    raw = JSON.parse(fs12.readFileSync(manifestPath, "utf8"));
+    raw = JSON.parse(fs13.readFileSync(manifestPath2, "utf8"));
   } catch (err) {
-    throw new MountManifestError(manifestPath, `JSON parse error: ${String(err)}`);
+    throw new MountManifestError(manifestPath2, `JSON parse error: ${String(err)}`);
   }
-  validateMountManifest(manifestPath, raw);
+  validateMountManifest(manifestPath2, raw);
   return raw;
 }
-function writeMountManifest(manifestPath, manifest) {
-  fs12.mkdirSync(path17.dirname(manifestPath), { recursive: true });
-  fs12.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf8");
+function writeMountManifest(manifestPath2, manifest) {
+  fs13.mkdirSync(path17.dirname(manifestPath2), { recursive: true });
+  fs13.writeFileSync(manifestPath2, JSON.stringify(manifest, null, 2), "utf8");
 }
-function deleteMountManifest(manifestPath) {
-  if (!fs12.existsSync(manifestPath)) return false;
-  fs12.rmSync(manifestPath);
+function deleteMountManifest(manifestPath2) {
+  if (!fs13.existsSync(manifestPath2)) return false;
+  fs13.rmSync(manifestPath2);
   return true;
 }
 function validateMountManifest(filePath, raw) {
@@ -92233,7 +92308,7 @@ function renderDockerOverlay(mounts, opts) {
 }
 
 // src/mount/symlinks.ts
-import fs13 from "node:fs";
+import fs14 from "node:fs";
 import path18 from "node:path";
 function applyManagedSymlinks(workspaceRoot, mounts, strategy) {
   const report = { created: [], skipped: [] };
@@ -92241,24 +92316,24 @@ function applyManagedSymlinks(workspaceRoot, mounts, strategy) {
     const linkPath = strategy.linkPath(m, workspaceRoot);
     if (!linkPath) continue;
     try {
-      const lstat3 = fs13.lstatSync(linkPath);
+      const lstat3 = fs14.lstatSync(linkPath);
       if (lstat3.isSymbolicLink()) {
-        const existing = fs13.readlinkSync(linkPath);
+        const existing = fs14.readlinkSync(linkPath);
         if (existing === m.hostPath) {
           report.created.push(linkPath);
           continue;
         }
-        fs13.unlinkSync(linkPath);
+        fs14.unlinkSync(linkPath);
       } else if (lstat3.isDirectory()) {
         report.skipped.push(linkPath);
         continue;
       } else {
-        fs13.unlinkSync(linkPath);
+        fs14.unlinkSync(linkPath);
       }
     } catch {
     }
-    fs13.mkdirSync(path18.dirname(linkPath), { recursive: true });
-    fs13.symlinkSync(m.hostPath, linkPath);
+    fs14.mkdirSync(path18.dirname(linkPath), { recursive: true });
+    fs14.symlinkSync(m.hostPath, linkPath);
     report.created.push(linkPath);
   }
   return report;
@@ -92268,8 +92343,8 @@ function removeManagedSymlinks(workspaceRoot, mounts, strategy) {
     const linkPath = strategy.linkPath(m, workspaceRoot);
     if (!linkPath) continue;
     try {
-      const lstat3 = fs13.lstatSync(linkPath);
-      if (lstat3.isSymbolicLink()) fs13.unlinkSync(linkPath);
+      const lstat3 = fs14.lstatSync(linkPath);
+      if (lstat3.isSymbolicLink()) fs14.unlinkSync(linkPath);
     } catch {
     }
   }
@@ -92281,7 +92356,7 @@ function detectBrokenSymlinks(workspaceRoot, mounts, strategy) {
     if (!linkPath) continue;
     let lstat3 = null;
     try {
-      lstat3 = fs13.lstatSync(linkPath);
+      lstat3 = fs14.lstatSync(linkPath);
     } catch {
       broken.push({ linkPath, intendedTarget: m.hostPath, reason: "missing", mount: m });
       continue;
@@ -92291,7 +92366,7 @@ function detectBrokenSymlinks(workspaceRoot, mounts, strategy) {
       continue;
     }
     try {
-      fs13.statSync(linkPath);
+      fs14.statSync(linkPath);
     } catch {
       broken.push({ linkPath, intendedTarget: m.hostPath, reason: "broken", mount: m });
     }
@@ -92339,17 +92414,34 @@ function mergeMounts(configMounts, providerMounts) {
 }
 async function resolveContext(opts) {
   const profile = opts.profile;
-  const configPath = path19.resolve(opts.config ?? "cockpit.yaml");
-  if (!fs14.existsSync(configPath)) {
-    process.stderr.write(`dev-cockpit mount: no cockpit.yaml found at ${configPath}.
+  let configPath;
+  let workspaceRoot;
+  try {
+    const result = discoverConfig({
+      cliConfig: opts.config,
+      workspaceDiscoverer: profile?.discoverer
+    });
+    configPath = result.configPath;
+    workspaceRoot = result.workspaceRoot;
+  } catch (err) {
+    if (err instanceof DiscoveryError) {
+      process.stderr.write(`${err.message}
 `);
+      process.exit(1);
+    }
+    throw err;
+  }
+  if (!fs15.existsSync(configPath)) {
+    process.stderr.write(
+      `dev-cockpit mount: cockpit.yaml at ${configPath} doesn't exist.
+`
+    );
     process.exit(1);
   }
   const config = loadConfig(configPath, {
     configSchemaExt: profile?.configSchemaExt,
     profileKey: profile?.appName
   });
-  const workspaceRoot = profile?.discoverer?.()?.root ?? path19.dirname(configPath);
   const explicitService = opts.service ?? config.docker?.services?.[0]?.name;
   if (!explicitService) {
     process.stderr.write(
@@ -92360,7 +92452,7 @@ async function resolveContext(opts) {
   const providerMounts = await profile?.mountCandidatesProvider?.() ?? [];
   const overlayPath = path19.resolve(workspaceRoot, config.mount.overlayPath);
   const paths = getStatePaths(workspaceRoot, { appName: config.appName });
-  const manifestPath = path19.join(paths.stateDir, config.mount.manifestFile);
+  const manifestPath2 = path19.join(paths.stateDir, config.mount.manifestFile);
   return {
     configPath,
     workspaceRoot,
@@ -92369,7 +92461,7 @@ async function resolveContext(opts) {
     configMounts: config.mounts,
     providerMounts,
     overlayPath,
-    manifestPath,
+    manifestPath: manifestPath2,
     profile
   };
 }
@@ -92400,7 +92492,7 @@ async function pickMounts(candidates) {
 }
 async function mountCommand(opts = {}) {
   const ctx = await resolveContext(opts);
-  const { workspaceRoot, appName, service, configMounts, providerMounts, overlayPath, manifestPath, profile } = ctx;
+  const { workspaceRoot, appName, service, configMounts, providerMounts, overlayPath, manifestPath: manifestPath2, profile } = ctx;
   const merged = applyExclude(mergeMounts(configMounts, providerMounts), opts.exclude ?? []);
   if (merged.length === 0) {
     process.stdout.write(
@@ -92422,11 +92514,11 @@ async function mountCommand(opts = {}) {
       return;
     }
   }
-  fs14.mkdirSync(path19.dirname(overlayPath), { recursive: true });
-  fs14.writeFileSync(overlayPath, renderDockerOverlay(selected, { service }), "utf8");
+  fs15.mkdirSync(path19.dirname(overlayPath), { recursive: true });
+  fs15.writeFileSync(overlayPath, renderDockerOverlay(selected, { service }), "utf8");
   process.stdout.write(`dev-cockpit mount: wrote ${overlayPath}
 `);
-  writeMountManifest(manifestPath, {
+  writeMountManifest(manifestPath2, {
     version: 1,
     appName,
     workspaceRoot,
@@ -92435,7 +92527,7 @@ async function mountCommand(opts = {}) {
     mounts: selected,
     appliedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
-  process.stdout.write(`dev-cockpit mount: wrote ${manifestPath}
+  process.stdout.write(`dev-cockpit mount: wrote ${manifestPath2}
 `);
   if (profile?.mountSymlinks) {
     const report = applyManagedSymlinks(workspaceRoot, selected, profile.mountSymlinks);
@@ -92461,8 +92553,8 @@ async function mountCommand(opts = {}) {
 }
 async function mountStatusCommand(opts = {}) {
   const ctx = await resolveContext(opts);
-  const { workspaceRoot, manifestPath, profile } = ctx;
-  const manifest = readMountManifest(manifestPath);
+  const { workspaceRoot, manifestPath: manifestPath2, profile } = ctx;
+  const manifest = readMountManifest(manifestPath2);
   if (!manifest || manifest.mounts.length === 0) {
     process.stdout.write("dev-cockpit mount: no active mounts.\n");
     return;
@@ -92526,8 +92618,8 @@ dev-cockpit mount status \u2014 service: ${manifest.service}
 }
 async function mountClearCommand(opts = {}) {
   const ctx = await resolveContext(opts);
-  const { workspaceRoot, overlayPath, manifestPath, profile } = ctx;
-  const manifest = readMountManifest(manifestPath);
+  const { workspaceRoot, overlayPath, manifestPath: manifestPath2, profile } = ctx;
+  const manifest = readMountManifest(manifestPath2);
   const previous = manifest?.mounts ?? [];
   if (profile?.mountSymlinks && previous.length > 0) {
     removeManagedSymlinks(workspaceRoot, previous, profile.mountSymlinks);
@@ -92535,14 +92627,14 @@ async function mountClearCommand(opts = {}) {
 `);
   }
   let removed = 0;
-  if (fs14.existsSync(overlayPath)) {
-    fs14.rmSync(overlayPath);
+  if (fs15.existsSync(overlayPath)) {
+    fs15.rmSync(overlayPath);
     process.stdout.write(`dev-cockpit mount: removed ${overlayPath}
 `);
     removed += 1;
   }
-  if (deleteMountManifest(manifestPath)) {
-    process.stdout.write(`dev-cockpit mount: removed ${manifestPath}
+  if (deleteMountManifest(manifestPath2)) {
+    process.stdout.write(`dev-cockpit mount: removed ${manifestPath2}
 `);
     removed += 1;
   }
@@ -92563,16 +92655,16 @@ async function mountClearCommand(opts = {}) {
 
 // src/commands/migrate-config.ts
 var import_yaml2 = __toESM(require_dist(), 1);
-import fs15 from "node:fs";
+import fs16 from "node:fs";
 import path20 from "node:path";
 async function migrateConfigCommand(opts = {}) {
   const configPath = path20.resolve(opts.config ?? "cockpit.yaml");
-  if (!fs15.existsSync(configPath)) {
+  if (!fs16.existsSync(configPath)) {
     process.stderr.write(`dev-cockpit migrate-config: no file at ${configPath}.
 `);
     process.exit(1);
   }
-  const content = fs15.readFileSync(configPath, "utf8");
+  const content = fs16.readFileSync(configPath, "utf8");
   const raw = (0, import_yaml2.parse)(content) ?? {};
   if (typeof raw["version"] !== "number") {
     process.stderr.write(
@@ -92612,7 +92704,7 @@ async function migrateConfigCommand(opts = {}) {
     process.stdout.write(out);
     return;
   }
-  fs15.writeFileSync(configPath, out, "utf8");
+  fs16.writeFileSync(configPath, out, "utf8");
   process.stdout.write(
     `dev-cockpit migrate-config: rewrote ${configPath} (v${fromVersion} \u2192 v${CONFIG_VERSION}).
 `
@@ -92643,30 +92735,45 @@ function buildCli(opts = {}) {
     profile.setupCli(program2);
   }
   if (!hasCommand(program2, "dev")) {
-    program2.command("dev").description("Boot the three-pane TUI (Repos / Output / Health / Help)").option("-c, --config <path>", "Path to cockpit.yaml", "cockpit.yaml").action(async (cmdOpts) => {
+    program2.command("dev").description("Boot the three-pane TUI (Repos / Output / Health / Help)").option("-c, --config <path>", "Path to cockpit.yaml (default: <cwd>/cockpit.yaml or registered via `link`)").action(async (cmdOpts) => {
       await devCommand({ config: cmdOpts.config, profile });
     });
   }
   if (!hasCommand(program2, "doctor")) {
-    program2.command("doctor").description("Run all health checks once and print a status table").option("-c, --config <path>", "Path to cockpit.yaml", "cockpit.yaml").action(async (cmdOpts) => {
+    program2.command("doctor").description("Run all health checks once and print a status table").option("-c, --config <path>", "Path to cockpit.yaml (default: <cwd>/cockpit.yaml or registered via `link`)").action(async (cmdOpts) => {
       await doctorCommand({ config: cmdOpts.config, profile });
     });
   }
   if (!hasCommand(program2, "init-config")) {
-    program2.command("init-config").description("Write a starter cockpit.yaml in the current directory").option("-f, --force", "Overwrite an existing cockpit.yaml without prompting", false).option("--with-docker", "Include an uncommented docker block (static template only)", false).option("-i, --interactive", "Walk through prompts to populate the file (skips static template)", false).action(
+    program2.command("init-config").description("Write a starter cockpit.yaml in the current directory").option("-f, --force", "Overwrite an existing cockpit.yaml without prompting", false).option("--with-docker", "Include an uncommented docker block (static template only)", false).option("-i, --interactive", "Walk through prompts to populate the file (skips static template)", false).option("-o, --output <path>", "Write the file to this path instead of <cwd>/cockpit.yaml").action(
       async (cmdOpts) => {
         await initConfigCommand({
           force: cmdOpts.force ?? false,
           withDocker: cmdOpts.withDocker ?? false,
           interactive: cmdOpts.interactive ?? false,
           appName,
-          profile
+          profile,
+          output: cmdOpts.output
         });
       }
     );
   }
+  if (!hasCommand(program2, "link")) {
+    const linkCmd = program2.command("link").description("Register the current directory as using a cockpit.yaml that lives elsewhere").argument("<config-path>", "Path to the cockpit.yaml to associate with this directory").action(async (configPath) => {
+      const { linkAddCommand } = await import("./link-HXNII7EU.js");
+      linkAddCommand({ configPath });
+    });
+    linkCmd.command("list").description("Print all registered project \u2192 config mappings").action(async () => {
+      const { linkListCommand } = await import("./link-HXNII7EU.js");
+      linkListCommand();
+    });
+    linkCmd.command("remove").description("Unregister the current directory from the manifest").action(async () => {
+      const { linkRemoveCommand } = await import("./link-HXNII7EU.js");
+      linkRemoveCommand();
+    });
+  }
   if (!hasCommand(program2, "mount")) {
-    const mountCmd = program2.command("mount").description("Apply a docker-compose bind-mount overlay (interactive picker by default)").option("-c, --config <path>", "Path to cockpit.yaml", "cockpit.yaml").option("-s, --service <name>", "Target compose service (default: first in docker.services)").option("-q, --quiet", "Skip the interactive picker; apply all candidates").option(
+    const mountCmd = program2.command("mount").description("Apply a docker-compose bind-mount overlay (interactive picker by default)").option("-c, --config <path>", "Path to cockpit.yaml (default: <cwd>/cockpit.yaml or registered via `link`)").option("-s, --service <name>", "Target compose service (default: first in docker.services)").option("-q, --quiet", "Skip the interactive picker; apply all candidates").option(
       "-e, --exclude <name>",
       "Exclude a candidate by meta.name (repeatable)",
       (val, prev) => [...prev, val],
@@ -92680,15 +92787,15 @@ function buildCli(opts = {}) {
         profile
       });
     });
-    mountCmd.command("status").description("Show active mounts with branch, dirty, and broken-symlink status").option("-c, --config <path>", "Path to cockpit.yaml", "cockpit.yaml").action(async (cmdOpts) => {
+    mountCmd.command("status").description("Show active mounts with branch, dirty, and broken-symlink status").option("-c, --config <path>", "Path to cockpit.yaml (default: <cwd>/cockpit.yaml or registered via `link`)").action(async (cmdOpts) => {
       await mountStatusCommand({ config: cmdOpts.config, profile });
     });
-    mountCmd.command("clear").description("Remove the overlay, manifest, and managed symlinks; runs profile.onMountClear").option("-c, --config <path>", "Path to cockpit.yaml", "cockpit.yaml").action(async (cmdOpts) => {
+    mountCmd.command("clear").description("Remove the overlay, manifest, and managed symlinks; runs profile.onMountClear").option("-c, --config <path>", "Path to cockpit.yaml (default: <cwd>/cockpit.yaml or registered via `link`)").action(async (cmdOpts) => {
       await mountClearCommand({ config: cmdOpts.config, profile });
     });
   }
   if (!hasCommand(program2, "migrate-config")) {
-    program2.command("migrate-config").description("Rewrite cockpit.yaml at the current CONFIG_VERSION").option("-c, --config <path>", "Path to cockpit.yaml", "cockpit.yaml").option("--dry-run", "Print the migrated YAML to stdout instead of writing").action(async (cmdOpts) => {
+    program2.command("migrate-config").description("Rewrite cockpit.yaml at the current CONFIG_VERSION").option("-c, --config <path>", "Path to cockpit.yaml (default: <cwd>/cockpit.yaml or registered via `link`)").option("--dry-run", "Print the migrated YAML to stdout instead of writing").action(async (cmdOpts) => {
       await migrateConfigCommand({ config: cmdOpts.config, dryRun: cmdOpts.dryRun });
     });
   }
@@ -92696,9 +92803,9 @@ function buildCli(opts = {}) {
 }
 
 // src/mount/discovery.ts
-import fs16 from "node:fs";
+import fs17 from "node:fs";
 function findHostClones(opts) {
-  const fsImpl = opts.fsImpl ?? fs16;
+  const fsImpl = opts.fsImpl ?? fs17;
   const found = [];
   for (const pkg of opts.packages) {
     const hostPath = opts.resolveHostPath(pkg, opts.parentDir);