@hienlh/ppm 0.18.12 → 0.18.13

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hienlh/ppm",
-  "version": "0.18.12",
-  "description": "Personal Project Manager — mobile-first web IDE with AI assistance",
+  "version": "0.18.13",
+  "description": "Personal Project Manager — mobile-first web IDE with AI assistance",
   "author": "hienlh",
   "license": "SEE LICENSE IN LICENSE",
   "module": "src/index.ts",

package/src/cli/commands/autostart.ts

@@ -58,8 +58,8 @@ export function registerAutoStartCommands(program: Command): void {
       const { disableAutoStart } = await import("../../services/autostart-register.ts");
 
       try {
-        await disableAutoStart();
-        console.log("  ✓  Auto-start disabled. PPM will no longer start on boot.\n");
+        const msg = await disableAutoStart();
+        console.log(`  ✓  ${msg}\n`);
       } catch (err: unknown) {
         const msg = err instanceof Error ? err.message : String(err);
         console.error(`  ✗  Failed to disable auto-start: ${msg}\n`);

package/src/cli/commands/config-cmd.ts

@@ -1,5 +1,6 @@
 import { Command } from "commander";
 import type { PpmConfig } from "../../types/config.ts";
+import { isSecretConfigKey, redactSecretConfigValue } from "../../services/config-secret-keys.ts";
 
 const C = {
   reset: "\x1b[0m",
@@ -65,6 +66,10 @@ export function registerConfigCommands(program: Command): void {
     .description("Get a config value (e.g. port, auth.enabled)")
     .action(async (key: string) => {
       try {
+        if (isSecretConfigKey(key)) {
+          console.log("(secret — use the API's masked status endpoint)");
+          return;
+        }
         const { configService } = await import("../../services/config.service.ts");
         configService.load();
         const all = configService.getAll();
@@ -78,10 +83,14 @@ export function registerConfigCommands(program: Command): void {
           }
           process.exit(1);
         }
-        if (typeof value === "object") {
-          console.log(JSON.stringify(value, null, 2));
+        // A leaf secret key is caught above; an ANCESTOR of one (e.g. "tunnel",
+        // "auth") reaches here with the raw object still intact, so every
+        // result — object or scalar — is deep-redacted before printing.
+        const display = redactSecretConfigValue(key, value);
+        if (typeof display === "object") {
+          console.log(JSON.stringify(display, null, 2));
         } else {
-          console.log(`${C.bold}${key}${C.reset} = ${C.green}${String(value)}${C.reset}`);
+          console.log(`${C.bold}${key}${C.reset} = ${C.green}${String(display)}${C.reset}`);
         }
       } catch (err) {
         console.error(`${C.red}Error:${C.reset}`, (err as Error).message);

package/src/cli/commands/status.ts

@@ -1,6 +1,7 @@
 import { resolve } from "node:path";
 import { readFileSync, existsSync } from "node:fs";
 import { getPpmDir } from "../../services/ppm-dir.ts";
+import { redactSecrets } from "../../services/redact-secrets.ts";
 
 interface DaemonStatus {
   running: boolean;
@@ -149,13 +150,13 @@ export async function showStatus(options: { json?: boolean; all?: boolean }) {
     const serverProcs = ppmProcs.filter((p) => p.args.includes("ppm") && !p.args.includes("pgrep"));
     if (serverProcs.length > 0) {
       console.log(`\n  PPM-related processes (${serverProcs.length}):`);
-      for (const p of serverProcs) console.log(`    PID ${p.pid}  ${p.args}`);
+      for (const p of serverProcs) console.log(`    PID ${p.pid}  ${redactSecrets(p.args)}`);
     }
 
     // All cloudflared processes
     if (cfProcs.length > 0) {
       console.log(`\n  Cloudflared processes (${cfProcs.length}):`);
-      for (const p of cfProcs) console.log(`    PID ${p.pid}  ${p.args}`);
+      for (const p of cfProcs) console.log(`    PID ${p.pid}  ${redactSecrets(p.args)}`);
     }
 
     if (serverProcs.length === 0 && cfProcs.length === 0 && !status.running) {

package/src/cli/commands/stop.ts

@@ -19,6 +19,31 @@ function killPid(pid: number, label: string): boolean {
   }
 }
 
+/**
+ * PIDs of cloudflared processes spawned for THIS PPM_HOME: their command line
+ * carries `--config <ppmDir>/cloudflared-*.yml` (and usually the binary under
+ * `<ppmDir>/bin`). Anything else on the machine is not ours to kill.
+ */
+function findOwnCloudflaredPids(): number[] {
+  if (process.platform !== "win32") return [];
+  try {
+    const script =
+      `Get-CimInstance Win32_Process -Filter "Name='cloudflared.exe'" | ForEach-Object { "$($_.ProcessId)\`t$($_.CommandLine)" }`;
+    const result = Bun.spawnSync(
+      ["powershell.exe", "-NoProfile", "-NonInteractive", "-Command", script],
+      { stdout: "pipe", stderr: "ignore" },
+    );
+    const ppmDir = getPpmDir().replace(/\//g, "\\").toLowerCase();
+    return result.stdout.toString().split("\n")
+      .map((line) => line.trim().split("\t"))
+      .filter((parts) => parts.length >= 2 && (parts[1] ?? "").replace(/\//g, "\\").toLowerCase().includes(ppmDir))
+      .map((parts) => parseInt(parts[0]!, 10))
+      .filter((pid) => !isNaN(pid));
+  } catch {
+    return [];
+  }
+}
+
 function findPidsByName(name: string): number[] {
   try {
     if (process.platform === "win32") {
@@ -222,11 +247,14 @@ async function hardStop() {
     try { process.kill(tunnelPid, 0); killPid(tunnelPid, "tunnel"); } catch {}
   }
 
-  // Windows fallback: kill orphan cloudflared processes
+  // Windows fallback: kill orphan cloudflared processes — but only OURS.
+  // `taskkill /IM cloudflared.exe` would also take down every other
+  // cloudflared on the box: a second PPM_HOME instance, the user's own named
+  // tunnels, or another PPM's production tunnel (which then rotates its URL).
+  // Our processes are recognisable by the config/binary path under this
+  // PPM_HOME, so match on that and kill by exact PID.
   if (process.platform === "win32") {
-    try {
-      Bun.spawnSync(["taskkill", "/F", "/IM", "cloudflared.exe"], { stdout: "ignore", stderr: "ignore" });
-    } catch {}
+    for (const pid of findOwnCloudflaredPids()) killPid(pid, "orphan tunnel");
     // process.kill on Windows is TerminateProcess — the supervisor's shutdown
     // handler never runs, so its server grandchildren survive and keep the
     // inherited listening-socket handle open (zombie port). Reap them here.

package/src/server/index.ts

@@ -13,6 +13,7 @@ import { tunnelRoutes } from "./routes/tunnel.ts";
 import { tunnelService } from "../services/tunnel.service.ts";
 import { staticRoutes } from "./routes/static.ts";
 import { projectScopedRouter } from "./routes/project-scoped.ts";
+import { chatUnreadRoutes } from "./routes/chat-unread.ts";
 import { postgresRoutes } from "./routes/postgres.ts";
 import { databaseRoutes } from "./routes/database.ts";
 import { fsBrowseRoutes } from "./routes/fs-browse.ts";
@@ -114,7 +115,10 @@ export const app = new Hono();
 app.use("*", cors());
 
 // Public endpoints (before auth)
-app.get("/api/health", (c) => c.json(ok({ status: "running" })));
+// Per-boot id so a named-tunnel health probe can tell "my connector is dark"
+// from "someone else's connector answers my hostname" across a restart.
+const instanceId = crypto.randomUUID();
+app.get("/api/health", (c) => c.json(ok({ status: "running", instanceId })));
 app.get("/api/info", (c) => c.json(ok({
   version: VERSION,
   device_name: configService.get("device_name") || null,
@@ -180,7 +184,10 @@ app.route("/api/settings", settingsRoutes);
 app.route("/api/settings/mcp", mcpRoutes);
 app.route("/api/settings/themes", settingsThemesRoutes);
 app.route("/api/tunnel", tunnelRoutes);
+import { namedTunnelRoutes } from "./routes/named-tunnel.ts";
+app.route("/api/tunnel/named", namedTunnelRoutes);
 app.route("/api/projects", projectRoutes);
+app.route("/api/chat", chatUnreadRoutes);
 app.route("/api/project/:projectName", projectScopedRouter);
 app.route("/api/postgres", postgresRoutes);
 app.route("/api/db", databaseRoutes);
@@ -345,7 +352,12 @@ export async function startServer(options: {
                 signalSupervisor("SIGUSR1");
                 await waitForNewSupervisor(statusFile, supervisorPid);
               } else {
-                writeCmd("resume");
+                // resume is a lifecycle action and outranks a pending retunnel
+                // (writeCmd overwrites it), so `false` here means a genuinely
+                // different lifecycle command is already queued.
+                if (!writeCmd("resume")) {
+                  console.log("  Warning: another supervisor command is already pending; resume may be delayed.");
+                }
                 signalSupervisor("SIGUSR2", "resume");
                 await waitForServerReady(statusFile, port);
               }
@@ -367,7 +379,9 @@ export async function startServer(options: {
 
             if (state === "paused") {
               console.log("  Supervisor is paused (max restarts). Sending resume...");
-              writeCmd("resume");
+              if (!writeCmd("resume")) {
+                console.log("  Warning: another supervisor command is already pending; resume may be delayed.");
+              }
               signalSupervisor("SIGUSR2", "resume");
               await waitForServerReady(statusFile, port);
               return;

package/src/server/routes/chat-unread.ts

@@ -0,0 +1,36 @@
+import { Hono } from "hono";
+import { clearSessionUnreadMany } from "../../services/db.service.ts";
+import { ok, err } from "../../types/api.ts";
+
+/**
+ * Unread routes that are deliberately *not* project-scoped.
+ *
+ * The per-session read route lives under `/api/project/:projectName/chat`, but it never
+ * read the project segment — and being mounted there means the project middleware 404s
+ * first. That makes the entries most in need of clearing the ones that cannot be:
+ * a session whose project was renamed or deleted, or one PPM never recorded a project
+ * for. Unread state is keyed by session, so clearing it does not need a project at all.
+ */
+export const chatUnreadRoutes = new Hono();
+
+/** POST /chat/sessions/read — mark many sessions as read, in one request */
+chatUnreadRoutes.post("/sessions/read", async (c) => {
+  try {
+    const body = await c.req.json<{ sessionIds?: unknown }>();
+    const ids = Array.isArray(body.sessionIds)
+      ? body.sessionIds.filter((v): v is string => typeof v === "string" && v.length > 0)
+      : null;
+    if (!ids) return c.json(err("sessionIds must be an array of session ids"), 400);
+
+    clearSessionUnreadMany(ids);
+    // One broadcast per session, but one request and one DB transaction: "Clear all" used
+    // to be N requests fanned out to every connected device.
+    const { broadcastGlobalEvent } = await import("../ws/chat.ts");
+    for (const id of ids) {
+      broadcastGlobalEvent({ type: "session:unread_changed", sessionId: id, unreadCount: 0, unreadType: null, projectName: "" });
+    }
+    return c.json(ok({ cleared: ids.length }));
+  } catch (e) {
+    return c.json(err((e as Error).message), 500);
+  }
+});

package/src/server/routes/named-tunnel.ts

@@ -0,0 +1,132 @@
+/**
+ * Named-tunnel setup API (`/api/tunnel/named`). Thin wrappers over
+ * `cloudflared-login.service` and `named-tunnel-setup.service` — all business
+ * logic lives there; this file is guard + (de)serialization only.
+ */
+import { Hono, type Context } from "hono";
+import { ok, err } from "../../types/api.ts";
+import { configService } from "../../services/config.service.ts";
+import { resolveTunnelConfig, maskToken } from "../../services/named-tunnel/named-tunnel-config.ts";
+import { cloudflaredLoginService } from "../../services/named-tunnel/cloudflared-login.service.ts";
+import { namedTunnelSetupService, SetupError } from "../../services/named-tunnel/named-tunnel-setup.service.ts";
+import { broadcastGlobalEvent } from "../ws/global.ts";
+import { readStatus } from "../../services/supervisor-state.ts";
+
+export const namedTunnelRoutes = new Hono();
+
+/**
+ * A stable, guessable public hostname must never be one unauthenticated
+ * request away. `authMiddleware` already lets everything through when PPM
+ * auth is disabled (auth.ts:10-13 explicitly passes through), so the four
+ * mutating routes below enforce their own independent check, plus a
+ * same-origin check so a foreign page cannot drive them via ambient
+ * browser credentials.
+ */
+function assertMutationAllowed(c: Context): Response | null {
+  if (!configService.get("auth").enabled) {
+    return c.json(err("named-tunnel setup requires PPM authentication to be enabled"), 403);
+  }
+  const origin = c.req.header("origin");
+  if (origin) {
+    let originHost: string | null = null;
+    try { originHost = new URL(origin).host; } catch { originHost = null; }
+    const requestHost = new URL(c.req.url).host;
+    if (!originHost || originHost !== requestHost) {
+      return c.json(err("cross-origin request rejected"), 403);
+    }
+  }
+  return null;
+}
+
+namedTunnelRoutes.get("/status", (c) => {
+  const resolved = resolveTunnelConfig(configService.get("tunnel"));
+  // Config says what the user *asked for*; the supervisor's status.json says
+  // what is *actually running*. When a named tunnel failed and the supervisor
+  // fell back to quick, the warning it left behind is the only signal the UI
+  // has that the two disagree — surface it instead of a silently wrong URL.
+  const live = readStatus();
+  const liveMode = live.tunnelMode === "named" || live.tunnelMode === "quick" ? live.tunnelMode : null;
+  const tunnelWarning = typeof live.tunnelWarning === "string" ? live.tunnelWarning : null;
+  return c.json(ok({
+    mode: resolved.mode,
+    liveMode,
+    hostname: resolved.hostname,
+    tunnelName: resolved.tunnelName,
+    tokenMasked: maskToken(resolved.token),
+    certState: namedTunnelSetupService.currentCertState(),
+    dismissed: resolved.dismissed,
+    login: cloudflaredLoginService.getLoginSnapshot(),
+    tunnelWarning,
+    // A stable public hostname needs PPM auth to gate it — the client uses
+    // this to hide the first-run popup entirely on an auth-disabled install
+    // rather than walking the user into a 403 on `POST /login`.
+    authEnabled: configService.get("auth").enabled,
+  }));
+});
+
+// One-way, low-value target — must work even before auth is configured so
+// the popup can be silenced regardless of the mutation guard above.
+namedTunnelRoutes.post("/dismiss", (c) => {
+  const current = configService.get("tunnel");
+  configService.set("tunnel", { ...current, dismissed: true });
+  return c.json(ok({ dismissed: true }));
+});
+
+namedTunnelRoutes.get("/zone", async (c) => {
+  try {
+    const info = await namedTunnelSetupService.readZoneInfo();
+    return c.json(ok({ zone: info.zone, proposedHostname: info.proposedHostname }));
+  } catch (e) {
+    const status = e instanceof SetupError ? e.status : 500;
+    return c.json(err((e as Error).message || "failed to read zone info"), status as 400 | 500);
+  }
+});
+
+namedTunnelRoutes.post("/login", async (c) => {
+  const guard = assertMutationAllowed(c);
+  if (guard) return guard;
+  const relogin = c.req.query("relogin") === "1";
+  const snapshot = await cloudflaredLoginService.startLogin({ relogin });
+  return c.json(ok(snapshot));
+});
+
+namedTunnelRoutes.post("/login/cancel", (c) => {
+  const guard = assertMutationAllowed(c);
+  if (guard) return guard;
+  cloudflaredLoginService.cancelLogin();
+  return c.json(ok({ state: "cancelled" as const }));
+});
+
+namedTunnelRoutes.post("/setup", async (c) => {
+  const guard = assertMutationAllowed(c);
+  if (guard) return guard;
+
+  let body: { hostname?: unknown };
+  try {
+    body = await c.req.json();
+  } catch {
+    return c.json(err("invalid JSON body"), 400);
+  }
+  const hostname = typeof body.hostname === "string" ? body.hostname.trim().toLowerCase() : "";
+  if (!hostname) return c.json(err("hostname is required"), 400);
+
+  try {
+    const result = await namedTunnelSetupService.runSetup(hostname);
+    if (result.ok === "pending") {
+      return c.json(ok({ hostname: result.hostname, tunnelName: result.tunnelName, pending: true, message: result.message }));
+    }
+    return c.json(ok({ hostname: result.hostname, tunnelName: result.tunnelName }));
+  } catch (e) {
+    const status = e instanceof SetupError ? e.status : 500;
+    const message = (e as Error).message || "setup failed";
+    broadcastGlobalEvent({ type: "tunnel:setup_error", message });
+    return c.json(err(message), status as 400 | 409 | 500);
+  }
+});
+
+namedTunnelRoutes.post("/disable", async (c) => {
+  const guard = assertMutationAllowed(c);
+  if (guard) return guard;
+  await namedTunnelSetupService.disableNamedTunnel();
+  return c.json(ok({ mode: "quick" as const }));
+});

package/src/server/routes/tunnel.ts

@@ -3,6 +3,8 @@ import { tunnelService } from "../../services/tunnel.service.ts";
 import { configService } from "../../services/config.service.ts";
 import { getLocalIp } from "../../lib/network-utils.ts";
 import { ok, err } from "../../types/api.ts";
+import { getConfigValue } from "../../services/db.service.ts";
+import { resolveTunnelConfig } from "../../services/named-tunnel/named-tunnel-config.ts";
 
 export const tunnelRoutes = new Hono();
 
@@ -17,6 +19,17 @@ tunnelRoutes.get("/", (c) => {
 
 /** POST /api/tunnel/start — start tunnel if not already running */
 tunnelRoutes.post("/start", async (c) => {
+  // Named mode is exclusively supervisor-owned (spawnTunnel). This manual-start
+  // surface would otherwise spawn a SECOND cloudflared connector for the same
+  // hostname whenever `existing` is momentarily null — e.g. the restart/downgrade
+  // window right after a named tunnel is configured or disabled — and Cloudflare
+  // round-robins between the two, so ~half of requests hit whichever origin the
+  // stale connector still points at.
+  const cfg = resolveTunnelConfig(getConfigValue("tunnel"));
+  if (cfg.mode === "named") {
+    return c.json(err("named tunnel is supervisor-managed"), 409);
+  }
+
   const existing = tunnelService.getTunnelUrl();
   if (existing) {
     return c.json(ok({ url: existing }));

package/src/server/ws/chat.ts

@@ -644,7 +644,10 @@ async function startSessionConsumer(sessionId: string, providerId: string, conte
         }).catch(() => {});
         // Persist unread to DB + broadcast to all tabs/devices
         const doneSession = chatService.getSession(sessionId);
-        incrementSessionUnread(sessionId, "done", doneSession?.title);
+        // The project comes from the connection, not from a separate write on open: a
+        // session PPM did not create has no metadata row until this runs, and this is the
+        // one place that knows both the session and its project.
+        incrementSessionUnread(sessionId, "done", doneSession?.title, entry.projectName || null);
         broadcastGlobalEvent({ type: "session:unread_changed", sessionId, unreadCount: -1, unreadType: "done", projectName: entry.projectName || "", sessionTitle: doneSession?.title || null });
 
         import("../../services/notification.service.ts").then(({ notificationService }) => {
@@ -666,7 +669,7 @@ async function startSessionConsumer(sessionId: string, providerId: string, conte
         const nType = isQuestion ? "question" : "approval_request";
         // Persist unread to DB + broadcast to all tabs/devices
         const approvalSession = chatService.getSession(sessionId);
-        incrementSessionUnread(sessionId, nType, approvalSession?.title);
+        incrementSessionUnread(sessionId, nType, approvalSession?.title, entry.projectName || null);
         broadcastGlobalEvent({ type: "session:unread_changed", sessionId, unreadCount: -1, unreadType: nType, projectName: entry.projectName || "", sessionTitle: approvalSession?.title || null });
 
         import("../../services/notification.service.ts").then(({ notificationService }) => {

package/src/services/autostart-register.ts

@@ -35,6 +35,23 @@ const METADATA_FILE = resolve(homedir(), ".ppm", "autostart.json");
  * machine-global, so PPM_HOME does not isolate them. Registering or removing
  * one from an isolated run would hijack the user's live service.
  */
+/**
+ * Run a read-only status probe, treating a missing executable as "not registered".
+ *
+ * `Bun.spawnSync` *throws* when the binary is not on PATH — it does not return exit 127 —
+ * and `getAutoStartStatus()` sits on the `ppm start` (`server/index.ts`) and `ppm stop`
+ * paths. So a Linux box without systemd, or any container that has no `systemctl`, died
+ * there instead of falling back to spawning the supervisor directly.
+ */
+function probe(cmd: string[]): { stdout: string; exitCode: number } | null {
+  try {
+    const r = Bun.spawnSync({ cmd, stdout: "pipe", stderr: "ignore" });
+    return { stdout: r.stdout.toString(), exitCode: r.exitCode };
+  } catch {
+    return null;
+  }
+}
+
 function skipIsolated(action: "enable" | "disable"): string {
   const msg = `Auto-start ${action} skipped: PPM_HOME is isolated (${process.env.PPM_HOME}) — refusing to modify the real service manager`;
   console.warn(`  ${msg}`);
@@ -147,17 +164,19 @@ function statusMacOS(): AutoStartStatus {
   const fileExists = existsSync(plistPath);
 
   // Check if loaded
-  const result = Bun.spawnSync({
-    cmd: ["launchctl", "list"],
-    stdout: "pipe", stderr: "ignore",
-  });
-  const output = result.stdout.toString();
-  const isLoaded = output.includes(PLIST_LABEL);
+  const isLoaded = probe(["launchctl", "list"])?.stdout.includes(PLIST_LABEL) ?? false;
+  return mapMacStatus(fileExists, isLoaded, plistPath);
+}
 
-  // Mirror systemd's is-enabled / is-active split: the plist on disk is the
-  // registration, the loaded job is the running state. Tying `enabled` to
-  // `isLoaded` made "enabled && !running" unsatisfiable, so `ppm start` could
-  // never take the launchd path and always spawned the supervisor directly.
+/**
+ * The enabled/running split for launchd, kept pure so it can be tested anywhere.
+ *
+ * Mirrors systemd's is-enabled / is-active split: the plist on disk is the registration,
+ * the loaded job is the running state. Tying `enabled` to `isLoaded` made
+ * "enabled && !running" unsatisfiable, so `ppm start` could never take the launchd path
+ * and always spawned the supervisor directly — the regression this guards.
+ */
+export function mapMacStatus(fileExists: boolean, isLoaded: boolean, plistPath: string): AutoStartStatus {
   return {
     enabled: fileExists,
     running: isLoaded,
@@ -272,18 +291,12 @@ function statusLinux(): AutoStartStatus {
   const fileExists = existsSync(servicePath);
 
   // Check enabled
-  const enabled = Bun.spawnSync({
-    cmd: ["systemctl", "--user", "is-enabled", "ppm.service"],
-    stdout: "pipe", stderr: "ignore",
-  });
-  const isEnabled = enabled.stdout.toString().trim() === "enabled";
+  const enabled = probe(["systemctl", "--user", "is-enabled", "ppm.service"]);
+  const isEnabled = enabled?.stdout.trim() === "enabled";
 
   // Check active
-  const active = Bun.spawnSync({
-    cmd: ["systemctl", "--user", "is-active", "ppm.service"],
-    stdout: "pipe", stderr: "ignore",
-  });
-  const isActive = active.stdout.toString().trim() === "active";
+  const active = probe(["systemctl", "--user", "is-active", "ppm.service"]);
+  const isActive = active?.stdout.trim() === "active";
 
   return {
     enabled: isEnabled,
@@ -361,8 +374,8 @@ function statusWindows(): AutoStartStatus {
   const fileExists = existsSync(vbsPath);
 
   // Check if the scheduled task exists
-  const result = Bun.spawnSync({ cmd: buildSchtasksQueryCommand(), stdout: "pipe", stderr: "ignore" });
-  const taskExists = result.exitCode === 0 && result.stdout.toString().includes(TASK_NAME);
+  const result = probe(buildSchtasksQueryCommand());
+  const taskExists = result?.exitCode === 0 && result.stdout.includes(TASK_NAME);
 
   return {
     enabled: taskExists,
@@ -387,14 +400,19 @@ export async function enableAutoStart(config: AutoStartConfig, opts?: { skipStar
   throw new Error(`Auto-start not supported on ${platform}`);
 }
 
-/** Disable auto-start for the current platform */
-export async function disableAutoStart(): Promise<void> {
-  if (isIsolatedPpmHome()) { skipIsolated("disable"); return; }
+/**
+ * Disable auto-start for the current platform. Returns what happened, so a refusal is
+ * not reported as a success — `ppm autostart disable` printed "Auto-start disabled"
+ * even when the isolation guard had made it do nothing.
+ */
+export async function disableAutoStart(): Promise<string> {
+  if (isIsolatedPpmHome()) return skipIsolated("disable");
   const platform = process.platform;
-  if (platform === "darwin") return disableMacOS();
-  if (platform === "linux") return disableLinux();
-  if (platform === "win32") return disableWindows();
-  throw new Error(`Auto-start not supported on ${platform}`);
+  if (platform === "darwin") await disableMacOS();
+  else if (platform === "linux") await disableLinux();
+  else if (platform === "win32") await disableWindows();
+  else throw new Error(`Auto-start not supported on ${platform}`);
+  return "Auto-start disabled. PPM will no longer start on boot.";
 }
 
 /** Get auto-start status for the current platform */

package/src/services/cloud.service.ts

@@ -5,6 +5,7 @@ import { randomBytes } from "node:crypto";
 import { VERSION } from "../version.ts";
 import { configService } from "./config.service.ts";
 import { getPpmDir } from "./ppm-dir.ts";
+import { readStatus } from "./supervisor-state.ts";
 
 const authFile = () => resolve(getPpmDir(), "cloud-auth.json");
 const deviceFile = () => resolve(getPpmDir(), "cloud-device.json");
@@ -374,6 +375,27 @@ export async function listDevices(): Promise<DeviceInfo[]> {
 // ─── Heartbeat ──────────────────────────────────────────────────────────
 
 /** Send a single heartbeat to cloud (non-blocking, logs errors) */
+/**
+ * Tunnel health as last observed by the supervisor, in the shape the cloud
+ * heartbeat sends. `degraded` means the tunnel process is up but its public
+ * hostname did not answer as us — the device is reachable locally, the link
+ * may not be.
+ */
+function describeTunnelHealth(): { status: "online" | "degraded"; tunnel_mode?: string; tunnel_warning?: string } {
+  try {
+    const s = readStatus();
+    const warning = typeof s.tunnelWarning === "string" && s.tunnelWarning ? s.tunnelWarning : null;
+    const mode = s.tunnelMode === "named" || s.tunnelMode === "quick" ? s.tunnelMode : undefined;
+    return {
+      status: warning ? "degraded" : "online",
+      ...(mode ? { tunnel_mode: mode } : {}),
+      ...(warning ? { tunnel_warning: warning } : {}),
+    };
+  } catch {
+    return { status: "online" }; // never let a status-file hiccup stop the heartbeat
+  }
+}
+
 export async function sendHeartbeat(tunnelUrl: string): Promise<boolean> {
   const device = getCloudDevice();
   if (!device) return false;
@@ -385,7 +407,10 @@ export async function sendHeartbeat(tunnelUrl: string): Promise<boolean> {
       body: JSON.stringify({
         secret_key: device.secret_key,
         tunnel_url: tunnelUrl,
-        status: "online",
+        // A heartbeat that always says "online" makes the cloud link redirect
+        // into a hostname that stopped answering minutes ago. Report what the
+        // supervisor actually observed so the permanent link can say why.
+        ...describeTunnelHealth(),
         name: device.name,
       }),
     });

package/src/services/config-secret-keys.ts

@@ -0,0 +1,48 @@
+/**
+ * Shared denylist for config keys that must never be echoed back by a
+ * config-dump surface (`ppm config get`, the extension RPC `workspace:config:get`,
+ * and any future status/masking endpoint). Both consumers keep their own local
+ * `getNestedValue` implementation — verified not shared — so this list is the
+ * one place the two surfaces stay in sync.
+ *
+ * Exact-key based, not a blanket group hide: sibling fields like
+ * `tunnel.mode` or `tunnel.hostname` stay visible so the UI and
+ * `ppm config get tunnel.mode` keep working.
+ */
+export const SECRET_CONFIG_KEYS: readonly string[] = [
+  "tunnel.namedTunnelToken",
+  "auth.token",
+];
+
+/** Marker shown in place of a redacted secret value. Never the empty string, so a caller can tell "masked" apart from "absent". */
+const REDACTED = "[REDACTED]";
+
+/**
+ * True when `key` is a secret key or a dotted descendant of one (e.g. a
+ * caller requesting `tunnel.namedTunnelToken.raw` would still be blocked).
+ */
+export function isSecretConfigKey(key: string): boolean {
+  return SECRET_CONFIG_KEYS.some((entry) => key === entry || key.startsWith(`${entry}.`));
+}
+
+/**
+ * Deep-redacts secret leaves inside a config-dump result. `isSecretConfigKey`
+ * alone only catches a request for the secret key itself or a descendant of
+ * it — a request for an ANCESTOR (`ppm config get tunnel`, or `auth`) walks
+ * right past that check and returns the whole object, `namedTunnelToken`/
+ * `token` included. This walks `value`'s own keys, rebuilding the dotted path
+ * as it goes, and swaps in the masked marker wherever that path matches the
+ * denylist — every other key is copied through unchanged, so the shape of
+ * the object a caller gets back never changes, only the secret's value does.
+ */
+export function redactSecretConfigValue(key: string, value: unknown): unknown {
+  if (isSecretConfigKey(key)) return REDACTED;
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    const out: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+      out[k] = redactSecretConfigValue(key ? `${key}.${k}` : k, v);
+    }
+    return out;
+  }
+  return value;
+}

package/src/services/config.service.ts

@@ -16,7 +16,7 @@ import {
 
 /** Top-level config keys stored in the config table (not projects) */
 const CONFIG_TABLE_KEYS: (keyof PpmConfig)[] = [
-  "device_name", "port", "host", "theme", "auth", "ai", "telegram", "clawbot", "query_audit",
+  "device_name", "port", "host", "theme", "auth", "ai", "telegram", "clawbot", "query_audit", "tunnel",
 ];
 
 /** File filter config keys stored in the config table */