localdeck 1.0.1 → 1.0.2

package/dist/index.js

@@ -27,7 +27,7 @@ import {
   stripAnsi,
   waitForReadiness,
   wrapper_default
-} from "./index-2ec54s5t.js";
+} from "./index-eyb4mz5b.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);
@@ -824,7 +881,7 @@ async function main(argv, overrides = {}) {
     case "init":
       return cmdInit(rest, dependencies);
     case "mcp":
-      return (await import("./mcp-hyc99xp8.js")).runMcp(rest);
+      return (await import("./mcp-4dnef2t7.js")).runMcp(rest);
     case "doctor":
       return cmdDoctor(rest);
     case "forward":

package/dist/{mcp-hyc99xp8.js → mcp-4dnef2t7.js}

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

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,7 @@ 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.
+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.2",
   "type": "module",
   "description": "Stable ports, shareable HTTPS links and request logs for your local dev servers",
   "bin": {