@san-siva/blogkit-md-cli 0.1.31 → 0.1.32

package/bin/blogkit-md.js

@@ -23,12 +23,16 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // scripts/cli.ts
-var import_node_child_process = require("child_process");
-var import_node_fs = require("fs");
+var import_node_child_process2 = require("child_process");
+var import_node_fs2 = require("fs");
 var import_node_http = require("http");
-var import_node_os = __toESM(require("os"));
-var import_node_path = __toESM(require("path"));
+var import_node_os3 = __toESM(require("os"));
+var import_node_path2 = __toESM(require("path"));
 var import_node_readline = __toESM(require("readline"));
+
+// scripts/cli/output.ts
+var import_node_child_process = require("child_process");
+var import_node_os = __toESM(require("os"));
 var useColor = process.stdout.isTTY && !process.env.NO_COLOR;
 var paint = (code) => (s) => useColor ? `\x1B[${code}m${s}\x1B[0m` : s;
 var c = {
@@ -45,6 +49,10 @@ var c = {
 var INDENT = " ".repeat(3);
 var line = (s = "") => console.log(INDENT + s);
 var tree = (s = "") => console.log(c.gray(INDENT + "\u2502 ") + s);
+var tilde = (p) => {
+  const home = import_node_os.default.homedir();
+  return p.startsWith(home) ? "~" + p.slice(home.length) : p;
+};
 var bannerShown = false;
 function banner() {
   if (bannerShown) return;
@@ -54,8 +62,115 @@ function banner() {
   line(c.gray("preview markdown as blogkit blog posts"));
   line();
 }
-var tilde = (p) => {
-  const home = import_node_os.default.homedir();
+
+// scripts/cli/registry.ts
+var import_node_fs = require("fs");
+var import_node_os2 = __toESM(require("os"));
+var import_node_path = __toESM(require("path"));
+var registryDir = () => process.env.BLOGKIT_MD_DIR || import_node_path.default.join(import_node_os2.default.homedir(), ".blogkit-md");
+var registryFile = () => import_node_path.default.join(registryDir(), "instances.json");
+var isAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+};
+function readRegistry() {
+  try {
+    const raw = JSON.parse((0, import_node_fs.readFileSync)(registryFile(), "utf8"));
+    return Array.isArray(raw) ? raw : [];
+  } catch {
+    return [];
+  }
+}
+function writeRegistry(list) {
+  try {
+    (0, import_node_fs.mkdirSync)(registryDir(), { recursive: true });
+    (0, import_node_fs.writeFileSync)(registryFile(), JSON.stringify(list, null, 2));
+  } catch {
+  }
+}
+function pruneRegistry() {
+  const all = readRegistry();
+  const live = all.filter((i) => isAlive(i.pid));
+  if (live.length !== all.length) writeRegistry(live);
+  return live;
+}
+function removeInstance(pid) {
+  writeRegistry(readRegistry().filter((i) => i.pid !== pid));
+}
+function findByDir(dir) {
+  return pruneRegistry().find((i) => i.dir === dir);
+}
+function killInstance(inst) {
+  try {
+    process.kill(inst.pid, "SIGTERM");
+  } catch {
+  }
+  removeInstance(inst.pid);
+}
+
+// scripts/cli/stop.ts
+function stopAllAndExit() {
+  banner();
+  const instances = pruneRegistry();
+  if (instances.length === 0) {
+    line(c.yellow("No running instances"));
+  } else {
+    for (const inst of instances) {
+      killInstance(inst);
+      line(c.green(`\u2713 Stopped localhost:${inst.port}`));
+      tree(c.dim(tilde(inst.dir)));
+    }
+  }
+  line();
+  process.exit(0);
+}
+function stopAndExit(inputPath) {
+  banner();
+  const existing = findByDir(inputPath);
+  if (existing) {
+    killInstance(existing);
+    line(c.green(`\u2713 Stopped localhost:${existing.port}`));
+    tree(c.dim(tilde(existing.dir)));
+  } else {
+    line(c.yellow("No running instance for that path"));
+    tree(c.dim(tilde(inputPath)));
+  }
+  line();
+  process.exit(0);
+}
+
+// scripts/cli.ts
+var useColor2 = process.stdout.isTTY && !process.env.NO_COLOR;
+var paint2 = (code) => (s) => useColor2 ? `\x1B[${code}m${s}\x1B[0m` : s;
+var c2 = {
+  bold: paint2("1"),
+  dim: paint2("2"),
+  red: paint2("31"),
+  green: paint2("32"),
+  yellow: paint2("33"),
+  blue: paint2("34"),
+  magenta: paint2("35"),
+  cyan: paint2("36"),
+  gray: paint2("90")
+};
+var INDENT2 = " ".repeat(3);
+var line2 = (s = "") => console.log(INDENT2 + s);
+var tree2 = (s = "") => console.log(c2.gray(INDENT2 + "\u2502 ") + s);
+var bannerShown2 = false;
+function banner2() {
+  if (bannerShown2) return;
+  bannerShown2 = true;
+  line2();
+  line2(c2.bold(c2.blue("blogkit-md")));
+  line2(c2.gray("preview markdown as blogkit blog posts"));
+  line2();
+}
+var tilde2 = (p) => {
+  const home = import_node_os3.default.homedir();
   return p.startsWith(home) ? "~" + p.slice(home.length) : p;
 };
 function humanAge(iso) {
@@ -67,17 +182,23 @@ function humanAge(iso) {
   if (secs < 86400) return `${Math.floor(secs / 3600)}h`;
   return `${Math.floor(secs / 86400)}d`;
 }
-function openBrowser(url, skip = false) {
+function openBrowser(url, skip = false, forceNewTab = false) {
   if (skip || process.env.BLOGKIT_MD_NO_OPEN) return;
   try {
-    (0, import_node_child_process.exec)(`open -a "Google Chrome" ${url} || open ${url}`);
+    if (forceNewTab) {
+      (0, import_node_child_process2.exec)(
+        `osascript -e 'tell app "Google Chrome" to open location "${url}"' 2>/dev/null || open -a "Google Chrome" "${url}" || open "${url}"`
+      );
+    } else {
+      (0, import_node_child_process2.exec)(`open -a "Google Chrome" "${url}" || open "${url}"`);
+    }
   } catch {
   }
 }
-var registryDir = () => process.env.BLOGKIT_MD_DIR || import_node_path.default.join(import_node_os.default.homedir(), ".blogkit-md");
-var registryFile = () => import_node_path.default.join(registryDir(), "instances.json");
-var logDir = () => import_node_path.default.join(registryDir(), "logs");
-var isAlive = (pid) => {
+var registryDir2 = () => process.env.BLOGKIT_MD_DIR || import_node_path2.default.join(import_node_os3.default.homedir(), ".blogkit-md");
+var registryFile2 = () => import_node_path2.default.join(registryDir2(), "instances.json");
+var logDir = () => import_node_path2.default.join(registryDir2(), "logs");
+var isAlive2 = (pid) => {
   try {
     process.kill(pid, 0);
     return true;
@@ -85,75 +206,69 @@ var isAlive = (pid) => {
     return false;
   }
 };
-function readRegistry() {
+function readRegistry2() {
   try {
-    const raw = JSON.parse((0, import_node_fs.readFileSync)(registryFile(), "utf8"));
+    const raw = JSON.parse((0, import_node_fs2.readFileSync)(registryFile2(), "utf8"));
     return Array.isArray(raw) ? raw : [];
   } catch {
     return [];
   }
 }
-function writeRegistry(list) {
+function writeRegistry2(list) {
   try {
-    (0, import_node_fs.mkdirSync)(registryDir(), { recursive: true });
-    (0, import_node_fs.writeFileSync)(registryFile(), JSON.stringify(list, null, 2));
+    (0, import_node_fs2.mkdirSync)(registryDir2(), { recursive: true });
+    (0, import_node_fs2.writeFileSync)(registryFile2(), JSON.stringify(list, null, 2));
   } catch {
   }
 }
-function pruneRegistry() {
-  const all = readRegistry();
-  const live = all.filter((index) => isAlive(index.pid));
-  if (live.length !== all.length) writeRegistry(live);
+function pruneRegistry2() {
+  const all = readRegistry2();
+  const live = all.filter((index) => isAlive2(index.pid));
+  if (live.length !== all.length) writeRegistry2(live);
   return live;
 }
 function addInstance(inst) {
-  const list = pruneRegistry().filter((index) => index.pid !== inst.pid);
+  const list = pruneRegistry2().filter((index) => index.pid !== inst.pid);
   list.push(inst);
-  writeRegistry(list);
+  writeRegistry2(list);
 }
-function removeInstance(pid) {
-  writeRegistry(readRegistry().filter((index) => index.pid !== pid));
+function removeInstance2(pid) {
+  writeRegistry2(readRegistry2().filter((index) => index.pid !== pid));
 }
-function findByDir(dir) {
-  return pruneRegistry().find((index) => index.dir === dir);
+function findByDir2(dir) {
+  return pruneRegistry2().find((index) => index.dir === dir);
 }
+var isInside = (parent, child) => {
+  const relative = import_node_path2.default.relative(parent, child);
+  return relative !== "" && relative !== ".." && !relative.startsWith(".." + import_node_path2.default.sep) && !import_node_path2.default.isAbsolute(relative);
+};
 function findContainingDir(filePath) {
-  const contains = (dir) => {
-    const relative = import_node_path.default.relative(dir, filePath);
-    return relative !== "" && !relative.startsWith("..") && !import_node_path.default.isAbsolute(relative);
-  };
-  return pruneRegistry().filter((index) => index.isDirectory && contains(index.dir)).toSorted((a, b) => b.dir.length - a.dir.length)[0];
+  return pruneRegistry2().filter((index) => index.isDirectory && isInside(index.dir, filePath)).toSorted((a, b) => b.dir.length - a.dir.length)[0];
 }
 function findInstancesUnder(dir) {
-  return pruneRegistry().filter((index) => {
-    const relative = import_node_path.default.relative(dir, index.dir);
-    if (relative === "") return false;
-    if (relative.startsWith("..")) return false;
-    if (import_node_path.default.isAbsolute(relative)) return false;
-    return true;
-  });
+  return pruneRegistry2().filter((index) => isInside(dir, index.dir));
 }
 function fileUrlPath(dir, filePath) {
-  const relative = import_node_path.default.relative(dir, filePath);
-  return "/" + relative.replace(/\.md$/, "").split(import_node_path.default.sep).map(encodeURIComponent).join("/");
+  const relative = import_node_path2.default.relative(dir, filePath);
+  return "/" + relative.replace(/\.md$/, "").split(import_node_path2.default.sep).map(encodeURIComponent).join("/");
 }
-function killInstance(inst) {
+function killInstance2(inst) {
   try {
     process.kill(inst.pid, "SIGTERM");
   } catch {
   }
-  removeInstance(inst.pid);
+  removeInstance2(inst.pid);
 }
 function instanceLabel(inst) {
   const kind = inst.isDirectory ? "\u{1F4C1}" : "\u{1F4C4}";
-  const mode = inst.background ? c.magenta("bg") : c.gray("fg");
-  return `${c.green("localhost:" + inst.port)}  ${kind} ${tilde(inst.dir)}  ${c.gray("pid " + inst.pid)} ${c.gray("\xB7 " + humanAge(inst.startedAt))} ${mode}`;
+  const mode = inst.background ? c2.magenta("bg") : c2.gray("fg");
+  return `${c2.green("localhost:" + inst.port)}  ${kind} ${tilde2(inst.dir)}  ${c2.gray("pid " + inst.pid)} ${c2.gray("\xB7 " + humanAge(inst.startedAt))} ${mode}`;
 }
 function printPlainList(instances) {
-  banner();
-  line(c.bold("Running instances"));
-  instances.forEach((index) => tree(instanceLabel(index)));
-  line();
+  banner2();
+  line2(c2.bold("Running instances"));
+  instances.forEach((index) => tree2(instanceLabel(index)));
+  line2();
 }
 function printScriptList(instances) {
   for (const inst of instances) {
@@ -162,15 +277,15 @@ function printScriptList(instances) {
   }
 }
 async function listInstancesInteractive(nonInteractive = false) {
-  let instances = pruneRegistry();
+  let instances = pruneRegistry2();
   if (nonInteractive) {
     printScriptList(instances);
     return;
   }
   if (instances.length === 0) {
-    banner();
-    line(c.yellow("No running blogkit-md instances."));
-    line();
+    banner2();
+    line2(c2.yellow("No running blogkit-md instances."));
+    line2();
     return;
   }
   if (!process.stdin.isTTY) {
@@ -192,16 +307,16 @@ async function listInstancesInteractive(nonInteractive = false) {
     const render = (footer) => {
       const out = [
         "",
-        INDENT + c.bold(c.blue("blogkit-md")) + c.gray("  \xB7  running instances"),
+        INDENT2 + c2.bold(c2.blue("blogkit-md")) + c2.gray("  \xB7  running instances"),
         "",
         ...instances.map((inst, rowIndex) => {
           const selected = rowIndex === index;
-          const pointer = selected ? c.blue("\u276F ") : "  ";
-          const label = selected ? instanceLabel(inst) : c.dim(instanceLabel(inst));
-          return INDENT + pointer + label;
+          const pointer = selected ? c2.blue("\u276F ") : "  ";
+          const label = selected ? instanceLabel(inst) : c2.dim(instanceLabel(inst));
+          return INDENT2 + pointer + label;
         }),
         "",
-        footer ?? c.gray(INDENT + "\u2191/\u2193 j/k move   \u23CE open in Chrome   x stop   q quit"),
+        footer ?? c2.gray(INDENT2 + "\u2191/\u2193 j/k move   \u23CE open in Chrome   x stop   q quit"),
         ""
       ];
       process.stdout.write("\x1B[2J\x1B[H" + out.join("\n") + "\n");
@@ -230,19 +345,19 @@ async function listInstancesInteractive(nonInteractive = false) {
         }
         case "return": {
           openBrowser(`http://localhost:${target.port}`);
-          render(c.green(INDENT + `Opened localhost:${target.port} in Chrome`));
+          render(c2.green(INDENT2 + `Opened localhost:${target.port} in Chrome`));
           finish();
           return;
         }
         case "x": {
-          killInstance(target);
-          render(c.green(INDENT + `Stopped localhost:${target.port}.`));
+          killInstance2(target);
+          render(c2.green(INDENT2 + `Stopped localhost:${target.port}.`));
           finish();
           return;
         }
         default: {
           if (key.name === "q" || key.name === "escape" || key.ctrl && key.name === "c") {
-            render(c.gray(INDENT + "Ciao \u{1F44B}"));
+            render(c2.gray(INDENT2 + "Ciao \u{1F44B}"));
             finish();
           }
         }
@@ -252,6 +367,26 @@ async function listInstancesInteractive(nonInteractive = false) {
     render();
   });
 }
+var KNOWN_FLAGS = /* @__PURE__ */ new Set([
+  "--port",
+  "--tear",
+  "-t",
+  "--list",
+  "-l",
+  "--list-instances",
+  "--no-open",
+  "-n",
+  "--stop",
+  "-s",
+  "--stop-all",
+  "-S",
+  "--non-interactive",
+  "--help",
+  "-h",
+  "--__detached",
+  "--__port-reused"
+  // internal
+]);
 function parseArgs(argv) {
   const isFlag = (a) => a.startsWith("-");
   const flagNames = new Set(argv.filter(isFlag).map((a) => a.split("=", 1)[0]));
@@ -266,140 +401,129 @@ function parseArgs(argv) {
     wantTear: flagNames.has("--tear") || flagNames.has("-t"),
     wantNoOpen: flagNames.has("--no-open") || flagNames.has("-n"),
     wantStop: flagNames.has("--stop") || flagNames.has("-s"),
+    wantStopAll: flagNames.has("--stop-all") || flagNames.has("-S"),
     wantNonInteractive: flagNames.has("--non-interactive"),
     isDetachedChild: flagNames.has("--__detached"),
     // internal use only
     isPortReused: flagNames.has("--__port-reused"),
     // internal use only
-    wantHelp: flagNames.has("--help") || flagNames.has("-h")
+    wantHelp: flagNames.has("--help") || flagNames.has("-h"),
+    unknownFlags: [...flagNames].filter((f) => !KNOWN_FLAGS.has(f))
   };
 }
 function printHelp() {
-  banner();
-  line(c.bold("Usage"));
-  tree("blogkit-md <file-or-directory> [options]");
-  line();
-  line(c.bold("Options"));
-  tree(
-    `${c.green("--port=<port>")}       run on a specific port (default: random free port)`
+  banner2();
+  line2(c2.bold("Usage"));
+  tree2("blogkit-md <file-or-directory> [options]");
+  line2();
+  line2(c2.bold("Options"));
+  tree2(
+    `${c2.green("--port=<port>")}       run on a specific port (default: random free port)`
   );
-  tree(
-    `${c.green("-t, --tear")}          stop the instance already serving this path, then start fresh`
+  tree2(
+    `${c2.green("-t, --tear")}          stop the instance already serving this path, then start fresh`
   );
-  tree(
-    `${c.green("-l, --list")}          interactively list & stop running instances`
+  tree2(
+    `${c2.green("-l, --list")}          interactively list & stop running instances`
   );
-  tree(
-    `${c.green("--non-interactive")}   with -l, print a plain "<port>\\t<path>" list and exit`
+  tree2(
+    `${c2.green("--non-interactive")}   with -l, print a plain "<port>\\t<path>" list and exit`
   );
-  tree(
-    `${c.green("-s, --stop")}          stop the instance serving the given path, then exit`
+  tree2(
+    `${c2.green("-s, --stop")}          stop the instance serving the given path, then exit`
   );
-  tree(
-    `${c.green("-n, --no-open")}       start the server without opening it in the browser`
+  tree2(`${c2.green("-S, --stop-all")}      stop all running instances, then exit`);
+  tree2(
+    `${c2.green("-n, --no-open")}       start the server without opening it in the browser`
   );
-  tree(`${c.green("-h, --help")}          show this help`);
-  line();
-  line(
-    c.gray(
+  tree2(`${c2.green("-h, --help")}          show this help`);
+  line2();
+  line2(
+    c2.gray(
       "If a path is already being served, running it again just reopens it."
     )
   );
-  line(
-    c.gray("A file inside a served folder reuses that server; serving a folder")
+  line2(
+    c2.gray("A file inside a served folder reuses that server; serving a folder")
   );
-  line(c.gray("replaces any narrower instances already running inside it."));
-  line();
-  line(
-    c.gray("The server always runs in the background; stop it with ") + c.blue("--stop") + c.gray(" or ") + c.blue("--list") + c.gray(".")
+  line2(c2.gray("replaces any narrower instances already running inside it."));
+  line2();
+  line2(
+    c2.gray("The server always runs in the background; stop it with ") + c2.blue("--stop") + c2.gray(" or ") + c2.blue("--list") + c2.gray(".")
   );
-  line();
-}
-function stopAndExit(inputPath) {
-  banner();
-  const existing = findByDir(inputPath);
-  if (existing) {
-    killInstance(existing);
-    line(c.green(`\u2713 Stopped localhost:${existing.port}`));
-    tree(c.dim(tilde(existing.dir)));
-  } else {
-    line(c.yellow("No running instance for that path"));
-    tree(c.dim(tilde(inputPath)));
-  }
-  line();
-  process.exit(0);
+  line2();
 }
 function statInput(inputPath) {
   try {
-    return (0, import_node_fs.statSync)(inputPath).isDirectory();
+    return (0, import_node_fs2.statSync)(inputPath).isDirectory();
   } catch {
-    banner();
-    line(c.red("\u2717 Path does not exist"));
-    tree(c.dim(inputPath));
-    line();
+    banner2();
+    line2(c2.red("\u2717 Path does not exist"));
+    tree2(c2.dim(inputPath));
+    line2();
     process.exit(1);
   }
 }
 async function tearDownInstance(existing) {
-  banner();
-  line(c.yellow("Tearing down the running instance"));
-  tree(
-    `${c.green("localhost:" + existing.port)}  ${c.gray("pid " + existing.pid)}  ${existing.background ? c.magenta("background") : c.gray("foreground")}`
+  banner2();
+  line2(c2.yellow("Tearing down the running instance"));
+  tree2(
+    `${c2.green("localhost:" + existing.port)}  ${c2.gray("pid " + existing.pid)}  ${existing.background ? c2.magenta("background") : c2.gray("foreground")}`
   );
-  killInstance(existing);
-  line(c.green(`\u2713 Stopped localhost:${existing.port}`));
-  line();
+  killInstance2(existing);
+  line2(c2.green(`\u2713 Stopped localhost:${existing.port}`));
+  line2();
   await new Promise((r) => setTimeout(r, 400));
 }
 function reopenInstance(existing, parsed) {
   const url = `http://localhost:${existing.port}`;
-  banner();
-  line(c.green("Already running \u2014 opening it in the browser"));
-  tree(`${c.bold("URL")}   ${c.blue(url)}`);
-  tree(`${c.bold("Path")}  ${c.dim(tilde(existing.dir))}`);
-  line();
-  line(
-    c.gray("Restart it with ") + c.blue("--tear") + c.gray(", or list with ") + c.blue("--list")
+  banner2();
+  line2(c2.green("Already running \u2014 opening it in the browser"));
+  tree2(`${c2.bold("URL")}   ${c2.blue(url)}`);
+  tree2(`${c2.bold("Path")}  ${c2.dim(tilde2(existing.dir))}`);
+  line2();
+  line2(
+    c2.gray("Restart it with ") + c2.blue("--tear") + c2.gray(", or list with ") + c2.blue("--list")
   );
-  line();
+  line2();
   openBrowser(url, parsed.wantNoOpen);
   process.exit(0);
 }
 function reuseContainingDir(inputPath, isDirectory, parsed) {
   const parent = findContainingDir(inputPath);
   if (!parent) return;
-  const subPath = import_node_path.default.relative(parent.dir, inputPath).split(import_node_path.default.sep).map(encodeURIComponent).join("/");
+  const subPath = import_node_path2.default.relative(parent.dir, inputPath).split(import_node_path2.default.sep).map(encodeURIComponent).join("/");
   const url = isDirectory ? `http://localhost:${parent.port}/${subPath}/` : `http://localhost:${parent.port}${fileUrlPath(parent.dir, inputPath)}`;
-  banner();
-  line(
-    c.green(
+  banner2();
+  line2(
+    c2.green(
       isDirectory ? "Already serving a parent folder \u2014 opening it" : "Already serving this folder \u2014 opening the file"
     )
   );
-  tree(`${c.bold("URL")}     ${c.blue(url)}`);
-  tree(`${c.bold(isDirectory ? "Folder" : "File")}  ${c.dim(tilde(inputPath))}`);
-  tree(`${c.bold("Parent")}  ${c.dim(tilde(parent.dir))}`);
-  line();
+  tree2(`${c2.bold("URL")}     ${c2.blue(url)}`);
+  tree2(`${c2.bold(isDirectory ? "Folder" : "File")}  ${c2.dim(tilde2(inputPath))}`);
+  tree2(`${c2.bold("Parent")}  ${c2.dim(tilde2(parent.dir))}`);
+  line2();
   openBrowser(url, parsed.wantNoOpen);
   process.exit(0);
 }
 async function supersedeNarrowerInstances(dir) {
   const contained = findInstancesUnder(dir);
   if (contained.length === 0) return void 0;
-  banner();
-  line(c.yellow("Stopping narrower instances inside this folder"));
+  banner2();
+  line2(c2.yellow("Stopping narrower instances inside this folder"));
   for (const inst of contained) {
-    killInstance(inst);
-    tree(`${c.green("localhost:" + inst.port)}  ${c.dim(tilde(inst.dir))}`);
+    killInstance2(inst);
+    tree2(`${c2.green("localhost:" + inst.port)}  ${c2.dim(tilde2(inst.dir))}`);
   }
   const reusedPort = contained[0].port;
-  line(c.gray(`Reusing port ${reusedPort} for ${tilde(dir)}`));
-  line();
+  line2(c2.gray(`Reusing port ${reusedPort} for ${tilde2(dir)}`));
+  line2();
   await new Promise((r) => setTimeout(r, 400));
   return reusedPort;
 }
 async function reconcileInstances(inputPath, isDirectory, parsed) {
-  const existing = findByDir(inputPath);
+  const existing = findByDir2(inputPath);
   if (existing) {
     if (parsed.wantTear) {
       await tearDownInstance(existing);
@@ -418,57 +542,67 @@ async function reconcileInstances(inputPath, isDirectory, parsed) {
 async function launchInBackground(inputPath, parsed, scriptPath, reclaimedPort) {
   try {
     const port = parsed.requestedPort || reclaimedPort || await getFreePort();
-    (0, import_node_fs.mkdirSync)(logDir(), { recursive: true });
-    const logFile = import_node_path.default.join(logDir(), `${port}.log`);
-    const out = (0, import_node_fs.openSync)(logFile, "a");
+    (0, import_node_fs2.mkdirSync)(logDir(), { recursive: true });
+    const logFile = import_node_path2.default.join(logDir(), `${port}.log`);
+    const out = (0, import_node_fs2.openSync)(logFile, "a");
     const childArgs = [scriptPath, inputPath, `--port=${port}`, "--__detached"];
     if (parsed.wantNoOpen) childArgs.push("--no-open");
     if (reclaimedPort) childArgs.push("--__port-reused");
-    const child = (0, import_node_child_process.spawn)(process.execPath, childArgs, {
+    const child = (0, import_node_child_process2.spawn)(process.execPath, childArgs, {
       detached: true,
       stdio: ["ignore", out, out]
     });
     child.unref();
-    banner();
-    line(c.green("Started in the background"));
-    tree(`${c.bold("URL")}   ${c.blue("http://localhost:" + port)}`);
-    tree(`${c.bold("Path")}  ${c.dim(tilde(inputPath))}`);
-    tree(`${c.bold("PID")}   ${c.dim(String(child.pid))}`);
-    tree(`${c.bold("Log")}   ${c.dim(tilde(logFile))}`);
-    line();
-    line(c.gray("Stop it with:  ") + c.blue("blogkit-md --list"));
-    line();
+    banner2();
+    line2(c2.green("Started in the background"));
+    tree2(`${c2.bold("URL")}   ${c2.blue("http://localhost:" + port)}`);
+    tree2(`${c2.bold("Path")}  ${c2.dim(tilde2(inputPath))}`);
+    tree2(`${c2.bold("PID")}   ${c2.dim(String(child.pid))}`);
+    tree2(`${c2.bold("Log")}   ${c2.dim(tilde2(logFile))}`);
+    line2();
+    line2(c2.gray("Stop it with:  ") + c2.blue("blogkit-md --list"));
+    line2();
   } catch (error) {
-    banner();
-    line(c.red("\u2717 Failed to start in the background"));
-    tree(c.dim(String(error)));
-    line();
+    banner2();
+    line2(c2.red("\u2717 Failed to start in the background"));
+    tree2(c2.dim(String(error)));
+    line2();
     process.exit(1);
   }
   process.exit(0);
 }
 async function run(argv) {
   const parsed = parseArgs(argv);
+  if (parsed.unknownFlags.length > 0) {
+    banner2();
+    for (const flag of parsed.unknownFlags) {
+      line2(c2.red(`\u2717 Unknown flag: ${flag}`));
+    }
+    line2();
+    printHelp();
+    process.exit(1);
+  }
   if (parsed.wantHelp) {
     printHelp();
     process.exit(0);
   }
+  if (parsed.wantStopAll) stopAllAndExit();
   if (parsed.wantList) {
     await listInstancesInteractive(parsed.wantNonInteractive);
     process.exit(0);
   }
   if (!parsed.inputArg) {
-    line(c.red("\u2717 Missing path"));
+    line2(c2.red("\u2717 Missing path"));
     printHelp();
     process.exit(1);
   }
-  const inputPath = import_node_path.default.resolve(process.cwd(), parsed.inputArg);
+  const inputPath = import_node_path2.default.resolve(process.cwd(), parsed.inputArg);
   if (parsed.wantStop) stopAndExit(inputPath);
   const isDirectory = statInput(inputPath);
   const reclaimedPort = await reconcileInstances(inputPath, isDirectory, parsed);
   const scriptPath = process.argv[1];
-  const packageRoot = import_node_path.default.dirname(import_node_path.default.dirname(scriptPath));
-  const nextBin = import_node_path.default.join(packageRoot, "node_modules/.bin/next");
+  const packageRoot = import_node_path2.default.dirname(import_node_path2.default.dirname(scriptPath));
+  const nextBin = import_node_path2.default.join(packageRoot, "node_modules/.bin/next");
   if (!parsed.isDetachedChild) {
     await launchInBackground(inputPath, parsed, scriptPath, reclaimedPort);
   }
@@ -509,12 +643,12 @@ async function startServer(inputPath, isDirectory, parsed, paths) {
     for (const client of clients) client.write("data: reload\n\n");
   };
   if (isDirectory) {
-    (0, import_node_fs.watch)(inputPath, { recursive: true }, (_, filename) => {
+    (0, import_node_fs2.watch)(inputPath, { recursive: true }, (_, filename) => {
       if (filename && filename.endsWith(".md")) broadcastReload();
     });
   } else {
-    const markdownFilename = import_node_path.default.basename(inputPath);
-    (0, import_node_fs.watch)(import_node_path.default.dirname(inputPath), (_, filename) => {
+    const markdownFilename = import_node_path2.default.basename(inputPath);
+    (0, import_node_fs2.watch)(import_node_path2.default.dirname(inputPath), (_, filename) => {
       if (filename === markdownFilename) broadcastReload();
     });
   }
@@ -528,7 +662,7 @@ async function startServer(inputPath, isDirectory, parsed, paths) {
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   addInstance(me);
-  const child = (0, import_node_child_process.spawn)(paths.nextBin, ["start", "--port", String(nextPort)], {
+  const child = (0, import_node_child_process2.spawn)(paths.nextBin, ["start", "--port", String(nextPort)], {
     cwd: paths.packageRoot,
     env: nextEnvironment,
     stdio: ["inherit", "pipe", "inherit"]
@@ -542,7 +676,7 @@ async function startServer(inputPath, isDirectory, parsed, paths) {
       sseServer.close();
     } catch {
     }
-    removeInstance(process.pid);
+    removeInstance2(process.pid);
   };
   process.on("exit", shutdown);
   process.on("SIGINT", () => process.exit(0));
@@ -553,8 +687,8 @@ async function startServer(inputPath, isDirectory, parsed, paths) {
       const match = chunk.toString().match(/http:\/\/localhost:\d+/);
       if (match) {
         ready = true;
-        const url = parsed.isPortReused ? `http://localhost:${nextPort}/?_=${Date.now()}` : `http://localhost:${nextPort}`;
-        openBrowser(url, parsed.wantNoOpen);
+        const url = `http://localhost:${nextPort}`;
+        openBrowser(url, parsed.wantNoOpen, parsed.isPortReused);
       }
     }
   });
@@ -563,7 +697,7 @@ async function startServer(inputPath, isDirectory, parsed, paths) {
       sseServer.close();
     } catch {
     }
-    removeInstance(process.pid);
+    removeInstance2(process.pid);
     process.exit(code ?? 0);
   });
 }