localdeck 1.0.1 → 1.0.3

package/dist/index.js

@@ -27,7 +27,7 @@ import {
   stripAnsi,
   waitForReadiness,
   wrapper_default
-} from "./index-2ec54s5t.js";
+} from "./index-3qpxpxwq.js";
 
 // src/index.ts
 import { spawn as spawn2 } from "node:child_process";
@@ -175,9 +175,7 @@ async function startService(opts, overrides = {}) {
     console.log(`${tag}${c.bold("LocalDeck")} ${c.dim("›")} ${paint(service.name)} ${c.dim("→")} ${c.green(appUrl)} ${c.dim(`(also ${service.urls[1]} · dashboard http://localhost:${daemon.apiPort})`)}`);
   }
   const posix = process.platform !== "win32";
-  const child = dependencies.spawn(argv[0], argv.slice(1), { cwd, env, stdio: [opts.prefix ? "ignore" : "inherit", "pipe", "pipe"], shell: !posix, detached: posix });
-  if (child.pid)
-    send({ type: "pid", pid: child.pid });
+  let child;
   const pipe = (stream, name, out) => {
     stream.on("data", (chunk) => {
       if (opts.prefix) {
@@ -192,8 +190,6 @@ async function startService(opts, overrides = {}) {
         send({ type: "log", stream: name, line: part });
     });
   };
-  pipe(child.stdout, "stdout", process.stdout);
-  pipe(child.stderr, "stderr", process.stderr);
   let hinted = false;
   let recentOutput = "";
   const hintOnPortClash = (chunk) => {
@@ -206,34 +202,11 @@ async function startService(opts, overrides = {}) {
       console.error(`${tag}${c.yellow(`  Fix: run without --port (LocalDeck finds the tool's own port automatically), or pick a different stable port, e.g. --port ${service.stablePort + 1000}.`)}`);
     }
   };
-  child.stdout.on("data", hintOnPortClash);
-  child.stderr.on("data", hintOnPortClash);
   let detectTimer;
   let reported;
-  if (!opts.upstreamPort && child.pid) {
-    const rootPid = child.pid;
-    let idle = 0;
-    const tick = async () => {
-      if (child.exitCode !== null || child.signalCode)
-        return;
-      try {
-        const listeners = await listeningPorts(await processTree(rootPid));
-        const pick = chooseUpstream(listeners, upstreamPort);
-        if (pick) {
-          const key = `${connectHost(pick)}:${pick.port}`;
-          if (key !== reported) {
-            reported = key;
-            send({ type: "upstream", port: pick.port, host: connectHost(pick) });
-            if (pick.port !== upstreamPort)
-              console.log(`${tag}${c.dim(`LocalDeck: process is listening on ${key} (ignored $PORT) — ${service.urls[0]} now points there`)}`);
-          }
-          idle++;
-        }
-      } catch {}
-      detectTimer = setTimeout(tick, reported ? Math.min(2000 + idle * 500, 1e4) : 400);
-    };
-    detectTimer = setTimeout(tick, 300);
-  }
+  let retryTimer;
+  let retryAttempts = 0;
+  let finalizing = false;
   let stopping = false;
   let cleanupPromise;
   let leaderExit;
@@ -244,20 +217,49 @@ async function startService(opts, overrides = {}) {
   });
   const cleanup = (signal) => cleanupPromise ??= cleanupTerminalTree(child, signal);
   const finishAfterCleanup = async (signal) => {
-    if (finished || !leaderExit)
+    if (finished || finalizing || !leaderExit)
       return;
+    finalizing = true;
     if (!await cleanup(signal)) {
       cleanupPromise = undefined;
+      finalizing = false;
       stopping = false;
       console.error(`${tag}${c.red(`LocalDeck: process descendants survived cleanup; retry Stop`)}`);
       return;
     }
     if (finished)
       return;
-    finished = true;
     if (detectTimer)
       clearTimeout(detectTimer);
     send({ type: "log", stream: "stderr", line: `process exited (${leaderExit.signal ?? `code ${leaderExit.code}`})` });
+    const interrupted = ["SIGINT", "SIGTERM", "SIGHUP"].includes(leaderExit.signal ?? "") || [130, 143, 129].includes(leaderExit.code ?? -1);
+    if (!stopping && !interrupted && retryAttempts < 3 && ws.readyState === wrapper_default.OPEN) {
+      const message = `LocalDeck: restarting in ${(dependencies.retryDelayMs ?? 3000) / 1000} seconds (attempt ${++retryAttempts}/3)`;
+      console.log(`${tag}${c.yellow(message)}`);
+      send({ type: "log", stream: "stderr", line: message });
+      send({ type: "readiness", status: "checking", message });
+      retryTimer = setTimeout(() => {
+        retryTimer = undefined;
+        if (stopping || finished)
+          return;
+        try {
+          launch();
+        } catch (error) {
+          finished = true;
+          console.error(`${tag}${c.red(`LocalDeck: restart failed: ${error instanceof Error ? error.message : error}`)}`);
+          ws.close();
+          resolveDone(1);
+        }
+      }, dependencies.retryDelayMs ?? 3000);
+      finalizing = false;
+      return;
+    }
+    if (!stopping && !interrupted && retryAttempts === 3) {
+      const message = "LocalDeck: automatic restart limit reached (3/3). Start the service manually to try again.";
+      console.error(`${tag}${c.red(message)}`);
+      send({ type: "log", stream: "stderr", line: message });
+    }
+    finished = true;
     setTimeout(() => {
       ws.close();
       resolveDone(leaderExit.code ?? (leaderExit.signal ? 1 : 0));
@@ -267,6 +269,10 @@ async function startService(opts, overrides = {}) {
     if (finished || stopping)
       return;
     stopping = true;
+    if (retryTimer) {
+      clearTimeout(retryTimer);
+      retryTimer = undefined;
+    }
     cleanup(signal).then(() => finishAfterCleanup(signal));
   };
   ws.on("message", (raw) => {
@@ -280,29 +286,77 @@ async function startService(opts, overrides = {}) {
     }
   });
   ws.on("close", () => {
-    if (!stopping)
+    if (retryTimer) {
+      stop();
+      return;
+    }
+    if (!stopping && !finished)
       console.error(`${tag}${c.yellow("LocalDeck: lost connection to daemon; the stable port is no longer proxied. Process keeps running.")}`);
   });
-  child.on("exit", (code, signal) => {
-    if (code !== 0 && !hinted) {
-      const guidance = startupGuidance(recentOutput);
-      if (guidance)
-        console.error(`${tag}${c.yellow(["LocalDeck: " + guidance.title, ...guidance.steps].join(`
-`))}`);
+  function launch() {
+    leaderExit = undefined;
+    cleanupPromise = undefined;
+    finalizing = false;
+    reported = undefined;
+    recentOutput = "";
+    hinted = false;
+    child = dependencies.spawn(argv[0], argv.slice(1), { cwd, env, stdio: [opts.prefix ? "ignore" : "inherit", "pipe", "pipe"], shell: !posix, detached: posix });
+    if (child.pid)
+      send({ type: "pid", pid: child.pid });
+    pipe(child.stdout, "stdout", process.stdout);
+    pipe(child.stderr, "stderr", process.stderr);
+    child.stdout.on("data", hintOnPortClash);
+    child.stderr.on("data", hintOnPortClash);
+    if (!opts.upstreamPort && child.pid) {
+      const detectedChild = child;
+      const rootPid = child.pid;
+      let idle = 0;
+      const tick = async () => {
+        if (child !== detectedChild || child.exitCode !== null || child.signalCode)
+          return;
+        try {
+          const listeners = await listeningPorts(await processTree(rootPid));
+          const pick = chooseUpstream(listeners, upstreamPort);
+          if (pick) {
+            const key = `${connectHost(pick)}:${pick.port}`;
+            if (key !== reported) {
+              reported = key;
+              send({ type: "upstream", port: pick.port, host: connectHost(pick) });
+              if (pick.port !== upstreamPort)
+                console.log(`${tag}${c.dim(`LocalDeck: process is listening on ${key} (ignored $PORT) — ${service.urls[0]} now points there`)}`);
+            }
+            idle++;
+          }
+        } catch {}
+        if (child !== detectedChild || child.exitCode !== null || stopping || leaderExit)
+          return;
+        detectTimer = setTimeout(tick, reported ? Math.min(2000 + idle * 500, 1e4) : 400);
+      };
+      detectTimer = setTimeout(tick, 300);
     }
-    leaderExit = { code, signal };
-    stopping = true;
-    finishAfterCleanup("SIGTERM");
-  });
-  child.on("error", (err) => {
-    stopping = true;
-    finished = true;
-    console.error(`${tag}${c.red(`LocalDeck: failed to start "${argv[0]}": ${err.message}`)}`);
-    ws.close();
-    resolveDone(1);
-  });
+    child.on("exit", (code, signal) => {
+      if (code !== 0 && !hinted) {
+        const guidance = startupGuidance(recentOutput);
+        if (guidance)
+          console.error(`${tag}${c.yellow(["LocalDeck: " + guidance.title, ...guidance.steps].join(`
+`))}`);
+      }
+      leaderExit = { code, signal };
+      finishAfterCleanup("SIGTERM");
+    });
+    child.on("error", (err) => {
+      stopping = true;
+      finished = true;
+      console.error(`${tag}${c.red(`LocalDeck: failed to start "${argv[0]}": ${err.message}`)}`);
+      ws.close();
+      resolveDone(1);
+    });
+    if (retryAttempts > 0)
+      checkReadiness().catch(() => stop());
+  }
+  launch();
   const readiness = opts.ready;
-  const readyOperation = readiness ? (async () => {
+  const checkReadiness = () => readiness ? (async () => {
     send({ type: "readiness", status: "checking", message: readiness.type === "tcp" ? "Waiting for the service to listen" : "Running configured readiness check" });
     try {
       const ready = await waitForReadiness({
@@ -326,8 +380,11 @@ async function startService(opts, overrides = {}) {
       throw error;
     }
   })() : Promise.resolve(service);
+  const readyOperation = checkReadiness();
   readyOperation.catch(() => {});
-  return { name: opts.name, service, child, stop, done, ready: readyOperation };
+  return { name: opts.name, service, get child() {
+    return child;
+  }, stop, done, ready: readyOperation };
 }
 async function cleanupTerminalTree(child, signal) {
   await killProcessTree(child, signal);
@@ -775,6 +832,7 @@ ${c.bold("Usage")}
   localdeck daemon status|start|stop|run
   localdeck --help | --h | -h     show help
   localdeck --version | --v | -v  show the installed version
+  localdeck --update               update the global npm install and restart the daemon
 
 ${c.bold("How it works")}
   LocalDeck holds a stable port for each service (e.g. 4000) and proxies to
@@ -819,12 +877,16 @@ async function main(argv, overrides = {}) {
     case "--help":
       console.log(HELP);
       return;
+    case "--update":
+      if (rest.length)
+        throw new Error("Usage: localdeck --update");
+      return (await import("./update-2f1pgdst.js")).updateLocalDeck();
     case "up":
       return cmdUp(rest, dependencies);
     case "init":
       return cmdInit(rest, dependencies);
     case "mcp":
-      return (await import("./mcp-hyc99xp8.js")).runMcp(rest);
+      return (await import("./mcp-tgg2n05x.js")).runMcp(rest);
     case "doctor":
       return cmdDoctor(rest);
     case "forward":

package/dist/{mcp-hyc99xp8.js → mcp-tgg2n05x.js}

@@ -7,7 +7,7 @@ import {
   ensureDaemon,
   environmentValues,
   redactDiagnostic
-} from "./index-2ec54s5t.js";
+} from "./index-3qpxpxwq.js";
 
 // ../../node_modules/.bun/ajv@8.20.0/node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS((exports) => {

package/dist/update-2f1pgdst.js

@@ -0,0 +1,127 @@
+import {
+  Api,
+  STATE_FILE,
+  findDaemon
+} from "./index-3qpxpxwq.js";
+
+// src/update.ts
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function installationPrefix(packageRoot, globalRoot, platform = process.platform) {
+  const paths = platform === "win32" ? path.win32 : path.posix;
+  const root = paths.normalize(packageRoot);
+  const modules = paths.dirname(root);
+  const equal = (a, b) => platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
+  if (paths.basename(root) !== "localdeck" || !equal(paths.basename(modules), "node_modules")) {
+    throw new Error("--update requires a global npm installation. Source checkouts and linked development builds must be updated manually.");
+  }
+  if (equal(modules, paths.normalize(globalRoot))) {
+    return platform === "win32" ? paths.dirname(modules) : paths.dirname(paths.dirname(modules));
+  }
+  if (platform !== "win32" && paths.basename(paths.dirname(modules)) === "lib")
+    return paths.dirname(paths.dirname(modules));
+  throw new Error("This is not the active global npm installation. Update it with the package manager and prefix used to install it.");
+}
+function npmCommand() {
+  const candidates = [
+    path.resolve(path.dirname(process.execPath), "node_modules/npm/bin/npm-cli.js"),
+    path.resolve(path.dirname(process.execPath), "../lib/node_modules/npm/bin/npm-cli.js")
+  ];
+  for (const directory of (process.env.PATH ?? "").split(path.delimiter)) {
+    if (!directory)
+      continue;
+    candidates.push(path.join(directory, "node_modules/npm/bin/npm-cli.js"));
+    try {
+      const executable = fs.realpathSync(path.join(directory, "npm"));
+      if (path.basename(executable) === "npm-cli.js")
+        candidates.push(executable);
+    } catch {}
+  }
+  const cli = candidates.find((candidate) => fs.existsSync(candidate));
+  if (!cli)
+    throw new Error("npm was not found. Install Node.js with npm, then run localdeck --update again.");
+  return [process.execPath, cli];
+}
+async function execute(command, capture = false) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command[0], command.slice(1), { stdio: capture ? ["ignore", "pipe", "inherit"] : "inherit", shell: false });
+    let output = "";
+    child.stdout?.on("data", (chunk) => {
+      output += chunk.toString();
+    });
+    child.once("error", reject);
+    child.once("close", (code, signal) => code === 0 ? resolve(output.trim()) : reject(new Error(`Command failed (${signal ?? `exit ${code}`}).`)));
+  });
+}
+async function applyUpdate(steps) {
+  await steps.install();
+  const version = await steps.validate();
+  await steps.stop();
+  await steps.start();
+  return version;
+}
+async function updateLocalDeck() {
+  const root = fs.realpathSync(path.resolve(path.dirname(fileURLToPath(import.meta.url)), ".."));
+  const npm = npmCommand();
+  const globalRoot = await execute([...npm, "root", "--global"], true);
+  const prefix = installationPrefix(root, globalRoot);
+  const bin = path.join(root, "bin/localdeck.js");
+  console.log(`Updating LocalDeck from npm in ${prefix}…`);
+  console.log("After installation, the daemon will restart. Managed services and public shares will stop; start them again when ready.");
+  let installedVersion = "";
+  const version = await applyUpdate({
+    install: async () => {
+      try {
+        await execute([...npm, "install", "--global", "--prefix", prefix, "localdeck@latest", "--registry=https://registry.npmjs.org/"]);
+      } catch (error) {
+        throw new Error(`npm update failed. The daemon was not restarted. Check the npm error above; the installation prefix must be writable. ${error instanceof Error ? error.message : error}`);
+      }
+    },
+    validate: async () => {
+      const version2 = await execute([process.execPath, bin, "--version"], true);
+      if (!/^\d+\.\d+\.\d+(?:[-+][\w.-]+)?$/.test(version2))
+        throw new Error("The updated CLI could not be verified. The daemon was not restarted.");
+      installedVersion = version2;
+      return version2;
+    },
+    stop: async () => {
+      const running = await findDaemon();
+      if (!running)
+        return;
+      await new Api(running.apiPort, globalThis.fetch, 30000).shutdown();
+      const deadline = Date.now() + 30000;
+      const ownsState = () => {
+        try {
+          return JSON.parse(fs.readFileSync(STATE_FILE, "utf8")).pid === running.pid;
+        } catch (error) {
+          if (error.code === "ENOENT")
+            return false;
+          throw error;
+        }
+      };
+      while (ownsState()) {
+        if (Date.now() >= deadline)
+          throw new Error("Package updated, but the daemon did not stop within 30 seconds. Restart it manually.");
+        await new Promise((resolve) => setTimeout(resolve, 150));
+      }
+    },
+    start: async () => {
+      try {
+        await execute([process.execPath, bin, "daemon", "start"]);
+        const running = await findDaemon();
+        if (running?.version !== installedVersion)
+          throw new Error("Unexpected daemon version");
+      } catch {
+        throw new Error("Package updated, but the daemon could not restart. Run localdeck daemon start to retry.");
+      }
+    }
+  });
+  console.log(`LocalDeck ${version} installed. The daemon has restarted.`);
+}
+export {
+  updateLocalDeck,
+  installationPrefix,
+  applyUpdate
+};

package/docs/commands.md

@@ -92,3 +92,15 @@ Child services receive `PORT` (upstream), `LOCALDECK_PORT` (stable/published por
 ## MCP client connection
 
 `localdeck mcp` runs the stdio MCP server for service inspection, controls, recorded GET/HEAD replay, and quick sharing. `--project <id>` restricts every tool to one remembered project; `--help` prints usage without connecting. A tool call can start the daemon, but connecting never starts application services. Closing the client leaves services running. See [MCP setup and every tool](mcp.md).
+
+## Update LocalDeck
+
+```sh
+localdeck --update
+```
+
+Available starting with 1.0.3. Installs the latest public npm release into the current global npm prefix, verifies the updated CLI, and restarts the daemon. Restarting stops daemon-managed services and public shares. Start services again afterward; terminal sessions may need to be rerun to reconnect.
+
+A failed installation leaves the daemon running. The npm prefix must be writable; LocalDeck never invokes sudo. Source checkouts, linked builds, local installs, npx caches, and unsupported package-manager layouts must be updated manually. Custom Unix prefixes are preserved. On Windows the installation must match npm's active global root.
+
+Older versions without this command can upgrade with `npm install -g localdeck@latest` using their existing npm prefix.

package/docs/dashboard.md

@@ -7,16 +7,16 @@ Open the dashboard with `localdeck open`. It runs on `http://localhost:7777` by
 ## Pages and projects
 
 - **Projects** (`/projects`) lists projects remembered through the CLI. Selecting one opens `/projects/<id>`.
-- **All Services** (`/services`) lists configured and running services across projects, with search, Start/Stop, Share, and Logs controls.
+- **All Services** (`/services`) lists configured and running services across projects, with search, Start/Stop, Share, View logs, and View requests controls.
 - **Settings** (`/settings`) contains Clean URLs and the log display limit.
 - **About** (`/about`) contains setup and command information.
 - **Changelog** (`/changelog`) lists release features and changes.
 
 Routes support refresh, direct links, and browser Back/Forward. LocalDeck remembers registered project files; it does not scan your disk. Missing or invalid projects remain visible with recovery actions until fixed or forgotten.
 
-Project pages expose individual Start/Stop, View logs, and Share controls, plus Start all and Stop all. Start includes prerequisites and waits for readiness; Stop all reverses dependency order. Local and shared URLs appear below each service. Failed services keep their own errors so other services remain usable.
+Project pages expose individual Start/Stop, View logs, View requests, and Share controls, plus Start all and Stop all. Start includes prerequisites and waits for readiness; Stop all reverses dependency order. Local and shared URLs appear below each service. Failed services keep their own errors so other services remain usable.
 
-Dashboard-started services run in the background under the daemon. Terminal services stay attached to their original CLI session; stopping them is supported, but restart them from their terminal. Shutting down the daemon stops its services and shares.
+Dashboard-started services run in the background under the daemon. Terminal services stay attached to their original CLI session; stopping them is supported, but restart them from their terminal. Unexpected process exits trigger up to three automatic restarts, each after a three-second delay. Logs show the attempt number; after the third failed retry, start the service manually to try again. The retry budget lasts until the next manual start. Stop, Stop all, Ctrl-C, and daemon shutdown cancel pending retries. Shutting down the daemon stops its services and shares.
 
 ## Project settings
 
@@ -68,7 +68,9 @@ Windows CI covers native detection and script syntax. Administrator installation
 
 Project diagnostics include configuration, readiness errors, and recent logs. Environment values and recognized credential formats are redacted; review the preview because application output may still contain private data. Nothing is uploaded automatically.
 
-Request inspection is available through CLI/API/MCP. Recorded GET/HEAD replay sends a new request to the current local upstream, without copying cookies, authorization, or request bodies. It does not follow redirects and has bounded response size and duration.
+Successful asset and development-module requests are hidden by default. Enable **Show assets & dev traffic** to include them; this preference is saved in the browser. Failed requests, page navigations, and API calls remain visible. Filtering affects the dashboard view, not capture.
+
+Choose **View requests** on a service, then expand a request row to inspect its method, path, status, timing, size, and local/share source. Details and replay responses expand directly below the selected row. Click the request again to collapse it. Service tabs and filtering are available in this view. **Replay request** sends eligible GET/HEAD requests and displays the new response body. New HTTP requests include request and response headers, request cookies, Set-Cookie values, and query parameters. Headers retain duplicate entries and are capped at 100 entries or 16 KiB per direction. These details, including cookie and authorization values, are stored in local request history. Older records cannot recover headers that were not captured. New HTTP requests also retain original request and response body previews, limited to 16 KiB per direction. Text is shown as UTF-8; binary or undecodable compressed content is shown as Base64. Complete gzip, deflate and Brotli bodies are decoded within the same preview limit. Older records cannot recover bodies that were not captured. Request inspection is also available through CLI/API/MCP. Recorded GET/HEAD replay sends a new request to the current local upstream, without copying cookies, authorization, or request bodies. It does not follow redirects and has bounded response size and duration.
 
 For an occupied startup port, service errors show recovery guidance with the raw output under Technical details. Vite guidance covers `strictPort` and reading `PORT`; LocalDeck does not change your application configuration or terminate unrelated listeners.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "localdeck",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "type": "module",
   "description": "Stable ports, shareable HTTPS links and request logs for your local dev servers",
   "bin": {