md-task-viewer 0.1.8 → 0.1.10

package/README.md

@@ -8,7 +8,7 @@ Each Markdown file (`1 file = 1 task`) is managed through a browser UI, and all
 
 - List Markdown tasks
 - Create, edit, and delete tasks
-- Frontmatter-based `MUST` / `WANT` priority and `TODO` / `WIP` / `DONE` status
+- Frontmatter-based `MUST` / `WANT` priority and `TODO` / `DONE` status
 - Drag-and-drop reordering
 - Persistent ordering via a dedicated metadata file
 - Auto-reload on external file changes
@@ -46,7 +46,7 @@ Each Markdown file should have frontmatter with the following keys:
 ---
 title: Release notes
 priority: MUST
-status: WIP
+status: TODO
 createdAt: 2026-03-15T08:00:00.000Z
 updatedAt: 2026-03-15T09:30:00.000Z
 ---
@@ -60,7 +60,7 @@ Free-form body text.
 
 - `title`
 - `priority`: `MUST` or `WANT`
-- `status`: `TODO`, `WIP`, or `DONE`
+- `status`: `TODO` or `DONE`
 - `createdAt`: UTC ISO 8601
 - `updatedAt`: UTC ISO 8601
 
@@ -68,6 +68,8 @@ Unknown frontmatter keys are preserved as-is.
 
 Files missing required keys are displayed with default values and normalized on save.
 
+Legacy `status: WIP` is treated as `TODO` when loaded and will be replaced with `TODO` on save.
+
 Files with unparseable YAML frontmatter are excluded from the list and shown in the error panel.
 
 ## Ordering Metadata

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import path4 from "path";
+import path8 from "path";
 import process from "process";
 import open from "open";
 
@@ -9,32 +9,25 @@ import open from "open";
 import Fastify from "fastify";
 import fastifyStatic from "@fastify/static";
 import chokidar from "chokidar";
-import path3 from "path";
+import path7 from "path";
 import { fileURLToPath } from "url";
 
-// src/taskStore.ts
-import matter from "gray-matter";
-import picomatch from "picomatch";
-import path from "path";
-import { promises as fs } from "fs";
-
-// src/types.ts
-var CONFIG_FILE_NAME = ".md-task-viewer.json";
-
 // src/slugify.ts
 function slugify(value) {
   const slug = value.normalize("NFC").replace(/[\s\u3000]+/g, "-").replace(/[^\p{L}\p{N}-]+/gu, "").replace(/^-+|-+$/g, "");
   return slug || "untitled-task";
 }
 
-// src/taskStore.ts
-var MARKDOWN_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".markdown"]);
-var REQUIRED_PRIORITY = ["MUST", "WANT"];
-var REQUIRED_STATUS = ["TODO", "WIP", "DONE"];
+// src/taskStore/paths.ts
+import path from "path";
+
+// src/taskStore/errors.ts
 var ConflictError = class extends Error {
 };
 var ValidationError = class extends Error {
 };
+
+// src/taskStore/paths.ts
 function toPosixPath(filePath) {
   return filePath.split(path.sep).join("/");
 }
@@ -48,11 +41,30 @@ function normalizeRelativePath(candidate) {
 function ensureMarkdownExtension(filePath) {
   return path.posix.extname(filePath) ? filePath : `${filePath}.md`;
 }
+
+// src/taskStore/frontmatter.ts
+import matter from "gray-matter";
+import path2 from "path";
+import { promises as fs } from "fs";
+var REQUIRED_PRIORITY = ["MUST", "WANT"];
+var REQUIRED_STATUS = ["TODO", "DONE"];
+function isValidPriority(value) {
+  return REQUIRED_PRIORITY.includes(value);
+}
+function isValidStatus(value) {
+  return REQUIRED_STATUS.includes(value);
+}
+function ensureRequiredStatus(status) {
+  if (!isValidStatus(status)) {
+    throw new ValidationError("Status must be TODO or DONE.");
+  }
+  return status;
+}
 function asUtcISOString(date) {
   return date.toISOString();
 }
 function buildDefaults(filePath, stats) {
-  const basename = path.basename(filePath, path.extname(filePath));
+  const basename = path2.basename(filePath, path2.extname(filePath));
   const title = basename.replace(/[-_]+/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
   return {
     title,
@@ -70,8 +82,8 @@ function splitFrontmatter(data, statsDefaults) {
     }
   }
   const title = typeof data.title === "string" && data.title.trim() ? data.title : statsDefaults.title;
-  const priority = REQUIRED_PRIORITY.includes(data.priority) ? data.priority : statsDefaults.priority;
-  const status = REQUIRED_STATUS.includes(data.status) ? data.status : statsDefaults.status;
+  const priority = isValidPriority(data.priority) ? data.priority : statsDefaults.priority;
+  const status = isValidStatus(data.status) ? data.status : statsDefaults.status;
   const createdAt = typeof data.createdAt === "string" && !Number.isNaN(Date.parse(data.createdAt)) ? new Date(data.createdAt).toISOString() : statsDefaults.createdAt;
   const updatedAt = typeof data.updatedAt === "string" && !Number.isNaN(Date.parse(data.updatedAt)) ? new Date(data.updatedAt).toISOString() : statsDefaults.updatedAt;
   const normalized = title !== data.title || priority !== data.priority || status !== data.status || createdAt !== data.createdAt || updatedAt !== data.updatedAt;
@@ -92,53 +104,8 @@ function serializeTask(record) {
   };
   return matter.stringify(record.content, data);
 }
-async function readDirectoryRecursive(rootDir, currentDir, results) {
-  const entries = await fs.readdir(currentDir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (entry.name === ".git" || entry.name === "node_modules") {
-      continue;
-    }
-    const absolutePath = path.join(currentDir, entry.name);
-    if (entry.isDirectory()) {
-      await readDirectoryRecursive(rootDir, absolutePath, results);
-      continue;
-    }
-    if (entry.name === CONFIG_FILE_NAME) {
-      continue;
-    }
-    if (!MARKDOWN_EXTENSIONS.has(path.extname(entry.name).toLowerCase())) {
-      continue;
-    }
-    results.push(toPosixPath(path.relative(rootDir, absolutePath)));
-  }
-}
-async function listMarkdownFiles(rootDir, taskDirs, ignorePaths) {
-  const results = [];
-  const seen = /* @__PURE__ */ new Set();
-  const isIgnored = ignorePaths.length > 0 ? picomatch(ignorePaths) : null;
-  for (const taskDir of taskDirs) {
-    const scanDir = path.resolve(rootDir, taskDir);
-    try {
-      await fs.access(scanDir);
-    } catch {
-      continue;
-    }
-    const dirResults = [];
-    await readDirectoryRecursive(rootDir, scanDir, dirResults);
-    for (const filePath of dirResults) {
-      if (!seen.has(filePath)) {
-        seen.add(filePath);
-        if (isIgnored && isIgnored(filePath)) {
-          continue;
-        }
-        results.push(filePath);
-      }
-    }
-  }
-  return results.sort();
-}
 async function parseTask(rootDir, relativePath) {
-  const absolutePath = path.join(rootDir, relativePath);
+  const absolutePath = path2.join(rootDir, relativePath);
   const raw = await fs.readFile(absolutePath, "utf8");
   const stats = await fs.stat(absolutePath);
   const parsed = matter(raw);
@@ -153,10 +120,19 @@ async function parseTask(rootDir, relativePath) {
     normalized
   };
 }
+
+// src/taskStore/config.ts
+import path3 from "path";
+import { promises as fs2 } from "fs";
+
+// src/types.ts
+var CONFIG_FILE_NAME = ".md-task-viewer.json";
+
+// src/taskStore/config.ts
 async function readConfig(rootDir) {
-  const configFilePath = path.join(rootDir, CONFIG_FILE_NAME);
+  const configFilePath = path3.join(rootDir, CONFIG_FILE_NAME);
   try {
-    const raw = await fs.readFile(configFilePath, "utf8");
+    const raw = await fs2.readFile(configFilePath, "utf8");
     const parsed = JSON.parse(raw);
     const taskDirs = Array.isArray(parsed.taskDirs) ? parsed.taskDirs.filter((item) => typeof item === "string") : ["."];
     const ignorePaths = Array.isArray(parsed.ignorePaths) ? parsed.ignorePaths.filter((item) => typeof item === "string") : [];
@@ -201,8 +177,14 @@ async function saveOrder(rootDir, order) {
     )
   );
   const existing = await readConfig(rootDir);
-  const payload = { version: 1, taskDirs: existing.taskDirs, ignorePaths: existing.ignorePaths, order: normalized, commands: existing.commands };
-  await fs.writeFile(path.join(rootDir, CONFIG_FILE_NAME), `${JSON.stringify(payload, null, 2)}
+  const payload = {
+    version: 1,
+    taskDirs: existing.taskDirs,
+    ignorePaths: existing.ignorePaths,
+    order: normalized,
+    commands: existing.commands
+  };
+  await fs2.writeFile(path3.join(rootDir, CONFIG_FILE_NAME), `${JSON.stringify(payload, null, 2)}
 `, "utf8");
 }
 async function saveConfig(rootDir, taskDirs, ignorePaths, commands) {
@@ -219,11 +201,102 @@ async function saveConfig(rootDir, taskDirs, ignorePaths, commands) {
   const existing = await readConfig(rootDir);
   const validatedIgnorePaths = ignorePaths ?? existing.ignorePaths;
   const validatedCommands = commands !== void 0 ? commands : existing.commands;
-  const payload = { version: 1, taskDirs: validated, ignorePaths: validatedIgnorePaths, order: existing.order, commands: validatedCommands };
-  await fs.writeFile(path.join(rootDir, CONFIG_FILE_NAME), `${JSON.stringify(payload, null, 2)}
+  const payload = {
+    version: 1,
+    taskDirs: validated,
+    ignorePaths: validatedIgnorePaths,
+    order: existing.order,
+    commands: validatedCommands
+  };
+  await fs2.writeFile(path3.join(rootDir, CONFIG_FILE_NAME), `${JSON.stringify(payload, null, 2)}
 `, "utf8");
   return payload;
 }
+function parseOrderPayload(input) {
+  if (!Array.isArray(input)) {
+    throw new ValidationError("Order payload must be an array.");
+  }
+  return input.map((item) => ensureMarkdownExtension(normalizeRelativePath(String(item))));
+}
+
+// src/taskStore/tasks.ts
+import path5 from "path";
+import { promises as fs4 } from "fs";
+
+// src/taskStore/scanner.ts
+import picomatch from "picomatch";
+import path4 from "path";
+import { promises as fs3 } from "fs";
+var MARKDOWN_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".markdown"]);
+async function readDirectoryRecursive(rootDir, currentDir, results) {
+  const entries = await fs3.readdir(currentDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === ".git" || entry.name === "node_modules") {
+      continue;
+    }
+    const absolutePath = path4.join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      await readDirectoryRecursive(rootDir, absolutePath, results);
+      continue;
+    }
+    if (entry.name === CONFIG_FILE_NAME) {
+      continue;
+    }
+    if (!MARKDOWN_EXTENSIONS.has(path4.extname(entry.name).toLowerCase())) {
+      continue;
+    }
+    results.push(toPosixPath(path4.relative(rootDir, absolutePath)));
+  }
+}
+async function listMarkdownFiles(rootDir, taskDirs, ignorePaths) {
+  const results = [];
+  const seen = /* @__PURE__ */ new Set();
+  const isIgnored = ignorePaths.length > 0 ? picomatch(ignorePaths) : null;
+  for (const taskDir of taskDirs) {
+    const scanDir = path4.resolve(rootDir, taskDir);
+    try {
+      await fs3.access(scanDir);
+    } catch {
+      continue;
+    }
+    const dirResults = [];
+    await readDirectoryRecursive(rootDir, scanDir, dirResults);
+    for (const filePath of dirResults) {
+      if (!seen.has(filePath)) {
+        seen.add(filePath);
+        if (isIgnored && isIgnored(filePath)) {
+          continue;
+        }
+        results.push(filePath);
+      }
+    }
+  }
+  return results.sort();
+}
+
+// src/taskStore/tasks.ts
+async function ensureDirectoryForFile(rootDir, relativeFilePath) {
+  const normalized = ensureMarkdownExtension(normalizeRelativePath(relativeFilePath));
+  const absolutePath = path5.join(rootDir, normalized);
+  const directory = path5.dirname(absolutePath);
+  await fs4.mkdir(directory, { recursive: true });
+  return normalized;
+}
+async function nextAvailablePath(rootDir, directory, title) {
+  const safeDirectory = directory ? normalizeRelativePath(directory) : "";
+  const slug = slugify(title);
+  const base = safeDirectory ? `${safeDirectory}/${slug}` : slug;
+  let attempt = 0;
+  while (true) {
+    const candidate = ensureMarkdownExtension(attempt === 0 ? base : `${base}-${attempt + 1}`);
+    try {
+      await fs4.access(path5.join(rootDir, candidate));
+      attempt += 1;
+    } catch {
+      return candidate;
+    }
+  }
+}
 async function listTasks(rootDir) {
   const config = await readConfig(rootDir);
   const files = await listMarkdownFiles(rootDir, config.taskDirs, config.ignorePaths);
@@ -257,46 +330,27 @@ async function listTasks(rootDir) {
   });
   return { tasks: taskRecords, errors };
 }
-async function ensureDirectoryForFile(rootDir, relativeFilePath) {
-  const normalized = ensureMarkdownExtension(normalizeRelativePath(relativeFilePath));
-  const absolutePath = path.join(rootDir, normalized);
-  const directory = path.dirname(absolutePath);
-  await fs.mkdir(directory, { recursive: true });
-  return normalized;
-}
-async function nextAvailablePath(rootDir, directory, title) {
-  const safeDirectory = directory ? normalizeRelativePath(directory) : "";
-  const slug = slugify(title);
-  const base = safeDirectory ? `${safeDirectory}/${slug}` : slug;
-  let attempt = 0;
-  while (true) {
-    const candidate = ensureMarkdownExtension(attempt === 0 ? base : `${base}-${attempt + 1}`);
-    try {
-      await fs.access(path.join(rootDir, candidate));
-      attempt += 1;
-    } catch {
-      return candidate;
-    }
-  }
-}
 async function createTask(rootDir, input) {
   if (!input.title.trim()) {
     throw new ValidationError("Title is required.");
   }
+  const status = input.status !== void 0 ? ensureRequiredStatus(input.status) : "TODO";
   const now = asUtcISOString(/* @__PURE__ */ new Date());
   const relativePath = input.path?.trim() ? await ensureDirectoryForFile(rootDir, input.path) : await nextAvailablePath(rootDir, input.directory ?? "", input.title);
-  const absolutePath = path.join(rootDir, relativePath);
+  const absolutePath = path5.join(rootDir, relativePath);
+  let targetExists = false;
   try {
-    await fs.access(absolutePath);
+    await fs4.access(absolutePath);
+    targetExists = true;
   } catch (error) {
     const maybeError = error;
-    if (maybeError.code === "ENOENT") {
-    } else if (maybeError.code) {
+    if (maybeError.code !== "ENOENT") {
       throw error;
-    } else {
-      throw new ValidationError("A task already exists at that path.");
     }
   }
+  if (targetExists) {
+    throw new ValidationError("A task already exists at that path.");
+  }
   const record = {
     path: relativePath,
     content: input.content ?? "",
@@ -306,20 +360,21 @@ async function createTask(rootDir, input) {
     frontmatter: {
       title: input.title.trim(),
       priority: input.priority ?? "MUST",
-      status: input.status ?? "TODO",
+      status,
       createdAt: now,
       updatedAt: now
     }
   };
-  await fs.mkdir(path.dirname(absolutePath), { recursive: true });
-  await fs.writeFile(absolutePath, serializeTask(record), "utf8");
-  const current = await listTasks(rootDir);
-  await saveOrder(rootDir, current.tasks.map((task) => task.path).concat(relativePath));
+  await fs4.mkdir(path5.dirname(absolutePath), { recursive: true });
+  await fs4.writeFile(absolutePath, serializeTask(record), "utf8");
+  const config = await readConfig(rootDir);
+  const filteredOrder = config.order.filter((item) => item !== relativePath);
+  await saveOrder(rootDir, [relativePath, ...filteredOrder]);
   return parseTask(rootDir, relativePath);
 }
 async function updateTask(rootDir, currentPath, input) {
   const normalizedCurrentPath = ensureMarkdownExtension(normalizeRelativePath(currentPath));
-  const absoluteCurrentPath = path.join(rootDir, normalizedCurrentPath);
+  const absoluteCurrentPath = path5.join(rootDir, normalizedCurrentPath);
   let existing;
   try {
     existing = await parseTask(rootDir, normalizedCurrentPath);
@@ -333,20 +388,23 @@ async function updateTask(rootDir, currentPath, input) {
   if (input.baseUpdatedAt && existing.frontmatter.updatedAt !== input.baseUpdatedAt) {
     throw new ConflictError("The task changed on disk. Reload before saving.");
   }
+  const status = ensureRequiredStatus(input.status);
   const nextPath = input.path?.trim() ? await ensureDirectoryForFile(rootDir, input.path) : normalizedCurrentPath;
-  const absoluteNextPath = path.join(rootDir, nextPath);
+  const absoluteNextPath = path5.join(rootDir, nextPath);
   if (nextPath !== normalizedCurrentPath) {
+    let targetExists = false;
     try {
-      await fs.access(absoluteNextPath);
+      await fs4.access(absoluteNextPath);
+      targetExists = true;
     } catch (error) {
       const maybeError = error;
-      if (maybeError.code === "ENOENT") {
-      } else if (maybeError.code) {
+      if (maybeError.code !== "ENOENT") {
         throw error;
-      } else {
-        throw new ValidationError("A task already exists at the target path.");
       }
     }
+    if (targetExists) {
+      throw new ValidationError("A task already exists at the target path.");
+    }
   }
   const record = {
     path: nextPath,
@@ -357,15 +415,15 @@ async function updateTask(rootDir, currentPath, input) {
     frontmatter: {
       title: input.title.trim(),
       priority: input.priority,
-      status: input.status,
+      status,
       createdAt: existing.frontmatter.createdAt,
       updatedAt: asUtcISOString(/* @__PURE__ */ new Date())
     }
   };
-  await fs.writeFile(absoluteCurrentPath, serializeTask(record), "utf8");
+  await fs4.writeFile(absoluteCurrentPath, serializeTask(record), "utf8");
   if (nextPath !== normalizedCurrentPath) {
-    await fs.mkdir(path.dirname(absoluteNextPath), { recursive: true });
-    await fs.rename(absoluteCurrentPath, absoluteNextPath);
+    await fs4.mkdir(path5.dirname(absoluteNextPath), { recursive: true });
+    await fs4.rename(absoluteCurrentPath, absoluteNextPath);
   }
   if (nextPath !== normalizedCurrentPath) {
     const config = await readConfig(rootDir);
@@ -384,9 +442,9 @@ async function updateTask(rootDir, currentPath, input) {
 }
 async function deleteTask(rootDir, relativePath) {
   const normalizedPath = ensureMarkdownExtension(normalizeRelativePath(relativePath));
-  const absolutePath = path.join(rootDir, normalizedPath);
+  const absolutePath = path5.join(rootDir, normalizedPath);
   try {
-    await fs.unlink(absolutePath);
+    await fs4.unlink(absolutePath);
   } catch (error) {
     const maybeError = error;
     if (maybeError.code === "ENOENT") {
@@ -402,7 +460,7 @@ async function deleteTask(rootDir, relativePath) {
 }
 async function patchTaskFields(rootDir, currentPath, input) {
   const normalizedCurrentPath = ensureMarkdownExtension(normalizeRelativePath(currentPath));
-  const absoluteCurrentPath = path.join(rootDir, normalizedCurrentPath);
+  const absoluteCurrentPath = path5.join(rootDir, normalizedCurrentPath);
   let existing;
   try {
     existing = await parseTask(rootDir, normalizedCurrentPath);
@@ -413,8 +471,8 @@ async function patchTaskFields(rootDir, currentPath, input) {
     }
     throw error;
   }
-  const priority = input.priority && REQUIRED_PRIORITY.includes(input.priority) ? input.priority : existing.frontmatter.priority;
-  const status = input.status && REQUIRED_STATUS.includes(input.status) ? input.status : existing.frontmatter.status;
+  const priority = input.priority && isValidPriority(input.priority) ? input.priority : existing.frontmatter.priority;
+  const status = input.status && isValidStatus(input.status) ? input.status : existing.frontmatter.status;
   if (priority === existing.frontmatter.priority && status === existing.frontmatter.status) {
     return existing;
   }
@@ -431,19 +489,13 @@ async function patchTaskFields(rootDir, currentPath, input) {
       updatedAt: asUtcISOString(/* @__PURE__ */ new Date())
     }
   };
-  await fs.writeFile(absoluteCurrentPath, serializeTask(record), "utf8");
+  await fs4.writeFile(absoluteCurrentPath, serializeTask(record), "utf8");
   return parseTask(rootDir, normalizedCurrentPath);
 }
-function parseOrderPayload(input) {
-  if (!Array.isArray(input)) {
-    throw new ValidationError("Order payload must be an array.");
-  }
-  return input.map((item) => ensureMarkdownExtension(normalizeRelativePath(String(item))));
-}
 
 // src/commandExecutor.ts
 import { spawn } from "child_process";
-import path2 from "path";
+import path6 from "path";
 var TIMEOUT_MS = 3e4;
 var VARIABLE_PATTERN = /\$\{?(TASK_TITLE|TASK_FILEPATH|TASK_BODY)\}?/g;
 function substituteVariables(command, vars) {
@@ -453,7 +505,7 @@ async function executeCommandPipeline(rootDir, steps, task) {
   if (steps.length === 0) {
     return { stdout: "", stderr: "", exitCode: 0, duration: 0 };
   }
-  const absoluteFilePath = path2.resolve(rootDir, task.path);
+  const absoluteFilePath = path6.resolve(rootDir, task.path);
   const vars = {
     TASK_TITLE: task.frontmatter.title,
     TASK_FILEPATH: absoluteFilePath,
@@ -531,7 +583,7 @@ async function executeCommandPipeline(rootDir, steps, task) {
 
 // src/server.ts
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = path3.dirname(__filename);
+var __dirname = path7.dirname(__filename);
 function resolveClientDir(explicitClientDir) {
   if (explicitClientDir === null) {
     return null;
@@ -539,7 +591,7 @@ function resolveClientDir(explicitClientDir) {
   if (explicitClientDir) {
     return explicitClientDir;
   }
-  return path3.resolve(__dirname, "client");
+  return path7.resolve(__dirname, "client");
 }
 function sendJsonError(reply, error) {
   if (error instanceof ValidationError) {
@@ -553,7 +605,7 @@ function sendJsonError(reply, error) {
   reply.code(500).send({ error: error instanceof Error ? error.message : "Internal server error" });
 }
 async function createServer(options) {
-  const app = Fastify({ logger: false });
+  const app = Fastify({ logger: false, forceCloseConnections: true });
   const listeners = /* @__PURE__ */ new Set();
   const clientDir = resolveClientDir(options.clientDir);
   app.addHook("onClose", async () => {
@@ -702,18 +754,18 @@ async function createServer(options) {
   });
   const watcher = chokidar.watch(options.rootDir, {
     ignoreInitial: true,
-    ignored: (watchPath) => watchPath.includes(`${path3.sep}.git`) || watchPath.includes(`${path3.sep}node_modules`)
+    ignored: (watchPath) => watchPath.includes(`${path7.sep}.git`) || watchPath.includes(`${path7.sep}node_modules`)
   });
   watcher.on("all", (eventName, changedPath) => {
     const isMarkdown = changedPath.endsWith(".md") || changedPath.endsWith(".markdown");
-    const isConfigFile = path3.basename(changedPath) === ".md-task-viewer.json";
+    const isConfigFile = path7.basename(changedPath) === ".md-task-viewer.json";
     if (!isMarkdown && !isConfigFile) {
       return;
     }
     const payload = JSON.stringify({
       type: "tasks-changed",
       eventName,
-      path: path3.relative(options.rootDir, changedPath)
+      path: path7.relative(options.rootDir, changedPath)
     });
     for (const listener of listeners) {
       listener.send(payload);
@@ -760,7 +812,7 @@ function parseArgs(argv) {
       continue;
     }
     if (!current.startsWith("--")) {
-      rootDir = path4.resolve(current);
+      rootDir = path8.resolve(current);
     }
   }
   return { rootDir, port, host, shouldOpen };
@@ -780,9 +832,31 @@ URL: ${browserUrl}
   if (options.shouldOpen) {
     await open(browserUrl);
   }
-  const shutdown = async () => {
-    await app.close();
-    process.exit(0);
+  let shuttingDown = false;
+  const SHUTDOWN_TIMEOUT_MS = 5e3;
+  const shutdown = (signal) => {
+    if (shuttingDown) {
+      process.stderr.write(`
+Received ${signal} again \u2014 forcing exit.
+`);
+      process.exit(1);
+    }
+    shuttingDown = true;
+    const timer = setTimeout(() => {
+      process.stderr.write(`
+Graceful shutdown timed out after ${SHUTDOWN_TIMEOUT_MS}ms \u2014 forcing exit.
+`);
+      process.exit(1);
+    }, SHUTDOWN_TIMEOUT_MS);
+    timer.unref();
+    app.close().then(
+      () => process.exit(0),
+      (error) => {
+        process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}
+`);
+        process.exit(1);
+      }
+    );
   };
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);