@hienlh/ppm 0.17.52 → 0.17.53

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [0.17.53] - 2026-09-02
+
+### Fixed
+- **Starting the dev server no longer takes over the public URL** — since 0.17.50 the shared link is served by a small forwarder that looks up the running server's port in a file, and `bun dev:server` wrote its own port there, so the public URL quietly served the dev instance instead. Only the server the supervisor started publishes that now, and the supervisor puts it back if anything else overwrites it.
+- **A background task finishing no longer ends your turn** — the notification was treated as the turn's result, so the assistant stopped mid-work.
+
 ## [0.17.52] - 2026-09-02
 
 ### Added

package/assets/skills/ppm/SKILL.md

@@ -71,4 +71,4 @@ This skill covers the `ppm` CLI, its HTTP API, and its config DB. It does **not*
 - Third-party extensions (inspect via `ppm ext list`).
 - The Claude Agent SDK internals (separate skill).
 
-<!-- Generated for PPM v0.17.52 at build time. Re-run `ppm export skill --install` to refresh. -->
+<!-- Generated for PPM v0.17.53 at build time. Re-run `ppm export skill --install` to refresh. -->

package/assets/skills/ppm/references/http-api.md

@@ -288,4 +288,4 @@ _Base URL: `http://localhost:8080` (default; override via `ppm config set port <
 - `ws://<host>/ws/terminal` — PTY terminal multiplexer
 - `ws://<host>/ws/extensions` — extension host channel
 
-<!-- Generated from src/server/routes/ for PPM v0.17.52 -->
+<!-- Generated from src/server/routes/ for PPM v0.17.53 -->

package/package.json

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

package/src/providers/claude-agent-sdk.ts

@@ -1806,6 +1806,23 @@ export class ClaudeAgentSdkProvider implements AIProvider {
           const result = msg as any;
           const subtype = result.subtype as string | undefined;
 
+          // The SDK closes out background deliveries with a result of their own —
+          // notably the orphaned-task notifications it replays on resume. Those carry
+          // origin 'task-notification' with no turns, no usage and duration_api_ms 0:
+          // no request ever reached the API. Treating one as the end of the user's turn
+          // raised a bogus "Claude returned no response (0 turns)", yielded `done`, and
+          // flipped the session to idle while the real turn was still streaming.
+          // Only the empty ones are ignored: a scheduled-trigger delivery shares this
+          // origin but does run a real turn, and must still be allowed to finish.
+          if (
+            result.origin?.kind === "task-notification"
+            && (result.num_turns ?? 0) === 0
+            && !assistantContent
+          ) {
+            console.log(`[sdk] session=${sessionId} ignoring empty task-notification result (no turn ran)`);
+            continue;
+          }
+
           // Write cost to shared usage cache
           if (result.total_cost_usd != null) {
             updateFromSdkEvent(undefined, undefined, result.total_cost_usd);

package/src/server/index.ts

@@ -942,15 +942,17 @@ if (process.argv.includes("__serve__")) {
     }, 200);
   }
 
-  // Publish the port we actually bound. With `port: 0` the OS picks it, so this
-  // file is the only way anything else can find the server — the edge forwarder
-  // reads it to know where to send traffic, and the supervisor mirrors it into
-  // status.json. The server is the single writer; see edge-target-resolver.ts
-  // for why this is not status.json.
-  try {
-    writeFileSync(SERVER_PORT_FILE(), String(server.port));
-  } catch (e) {
-    console.error(`[serve] Failed to publish server port: ${e}`);
+  // Publish the port we actually bound so the edge forwarder knows where to
+  // send traffic. Only meaningful when the supervisor spawned us with port 0
+  // (OS-assigned); a dev server on a fixed port (e.g. `bun dev:server` on 8081)
+  // serves directly and must NOT overwrite this file — doing so redirects all
+  // production tunnel traffic to the dev instance.
+  if (port === 0) {
+    try {
+      writeFileSync(SERVER_PORT_FILE(), String(server.port));
+    } catch (e) {
+      console.error(`[serve] Failed to publish server port: ${e}`);
+    }
   }
 
   console.log(`Server child ready on port ${server.port}`);

package/src/services/supervisor.ts

@@ -63,6 +63,10 @@ let adoptedTunnelPid: number | null = null; // PID of tunnel kept alive across u
 // survives self-replace, so a new supervisor adopts it rather than respawning.
 let edgePid: number | null = null;
 let edgeProbeTimer: ReturnType<typeof setInterval> | null = null;
+// The loopback port our own server child published. Cleared on every respawn so
+// a stale value never fights the incoming generation. Once set, it makes the
+// supervisor the authority on what `.server-port` should contain.
+let serverPublishedPort: number | null = null;
 let shuttingDown = false;
 // Monotonic token for the authoritative tunnel loop. Every EXTERNAL (re)start
 // bumps it; a loop whose captured generation is stale must exit instead of
@@ -423,6 +427,7 @@ async function mirrorServerPort(): Promise<void> {
     _resetTargetCache(); // the memo is for the forwarder's hot path, not this poll
     const port = resolveTargetPort();
     if (port !== null) {
+      serverPublishedPort = port;
       updateStatus({ serverPort: port });
       log("INFO", `Server bound loopback port ${port}`);
       return;
@@ -432,6 +437,38 @@ async function mirrorServerPort(): Promise<void> {
   log("WARN", "Server never published its port — status.serverPort left stale");
 }
 
+/**
+ * Repair `.server-port` when another process overwrites it.
+ *
+ * The file is the edge's routing table and lives in the shared `~/.ppm`, so
+ * ANY process running the `__serve__` entry can clobber it — most easily
+ * `bun dev:server`, which is not PPM_HOME-isolated and only differs by DB
+ * profile. When that happens the production tunnel silently serves the dev
+ * instance. The server-side guard (only a port-0, supervisor-spawned server
+ * publishes) stops new writes, but a value left behind by an older build would
+ * otherwise persist until the server restarts.
+ *
+ * After the initial handshake the supervisor knows the port its own child
+ * published, so it is the authority. It still does not write the file on the
+ * happy path — only to undo someone else's write.
+ */
+function repairServerPortFile(): void {
+  if (serverPublishedPort === null || !serverChild) return;
+  _resetTargetCache();
+  const onDisk = resolveTargetPort();
+  if (onDisk === serverPublishedPort) return;
+  log(
+    "WARN",
+    `.server-port says ${onDisk ?? "nothing"} but our server child is on ${serverPublishedPort} — another process (a dev server?) hijacked the edge's target; restoring`,
+  );
+  try {
+    writeFileSync(SERVER_PORT_FILE(), String(serverPublishedPort));
+    _resetTargetCache();
+  } catch (e) {
+    log("ERROR", `Failed to restore .server-port: ${e}`);
+  }
+}
+
 // ─── Server management ─────────────────────────────────────────────────
 export async function spawnServer(
   serverArgs: string[],
@@ -456,7 +493,9 @@ export async function spawnServer(
   // Zombie-port handling now applies only to the edge's public port.
   //
   // Clear the stale port file so the mirror below cannot publish the previous
-  // generation's port to `ppm status`.
+  // generation's port to `ppm status`, and drop our record of it so
+  // repairServerPortFile does not restore a port that just died.
+  serverPublishedPort = null;
   try { unlinkSync(SERVER_PORT_FILE()); } catch {}
   const cmd = isCompiledBinary()
     ? [process.execPath, ...serverArgs]
@@ -784,6 +823,10 @@ function startServerHealthCheck() {
       return;
     }
     noServerChildCycles = 0;
+    // Undo any foreign write to `.server-port` before reading it, or the probe
+    // below would health-check a dev server and report our own as fine while
+    // the public tunnel serves the wrong instance.
+    repairServerPortFile();
     // Probe the SERVER's own loopback port, never `_opts.port` — that is the
     // public port and belongs to the edge. Probing through the edge would make
     // a dead edge look like a dead server and kill a perfectly healthy one

package/src/web/components/shared/theme-mode-menu.tsx

@@ -0,0 +1,74 @@
+import { memo } from "react";
+import { Check } from "lucide-react";
+import {
+  DropdownMenu,
+  DropdownMenuTrigger,
+  DropdownMenuContent,
+  DropdownMenuLabel,
+  DropdownMenuItem,
+} from "@/components/ui/dropdown-menu";
+import { useSettingsStore } from "@/stores/settings-store";
+import { THEME_MODE_OPTIONS } from "@/theme/theme-mode-options";
+import { cn } from "@/lib/utils";
+
+interface ThemeModeMenuProps {
+  /** Positioning / spacing for the trigger button. */
+  className?: string;
+}
+
+/**
+ * Icon-button dropdown for picking the theme mode (Light / Dark / System).
+ *
+ * Mode-only on purpose: this is used where the full theme *style* grid does not
+ * fit or is not yet reachable (the login screen runs pre-auth, so imported
+ * themes cannot be fetched). The trigger is a 44px touch target per the
+ * mobile-first UI rules.
+ */
+export const ThemeModeMenu = memo(function ThemeModeMenu({ className }: ThemeModeMenuProps) {
+  const themeMode = useSettingsStore((s) => s.themeMode);
+  const setThemeMode = useSettingsStore((s) => s.setThemeMode);
+
+  const active = THEME_MODE_OPTIONS.find((o) => o.value === themeMode) ?? THEME_MODE_OPTIONS[2]!;
+  const ActiveIcon = active.icon;
+
+  return (
+    <DropdownMenu>
+      <DropdownMenuTrigger asChild>
+        <button
+          type="button"
+          title={`Appearance: ${active.label}`}
+          aria-label={`Appearance: ${active.label}`}
+          className={cn(
+            "flex size-11 items-center justify-center rounded-xl text-text-subtle",
+            "can-hover:hover:bg-surface-elevated can-hover:hover:text-foreground",
+            className,
+          )}
+        >
+          <ActiveIcon className="size-[18px]" />
+        </button>
+      </DropdownMenuTrigger>
+      <DropdownMenuContent align="end" className="w-44">
+        <DropdownMenuLabel>Appearance</DropdownMenuLabel>
+        {THEME_MODE_OPTIONS.map((opt) => {
+          const Icon = opt.icon;
+          return (
+            <DropdownMenuItem
+              key={opt.value}
+              onClick={() => setThemeMode(opt.value)}
+              className="gap-2"
+            >
+              <Icon className="size-4 shrink-0" />
+              <span className="flex-1 truncate">{opt.label}</span>
+              <Check
+                className={cn(
+                  "size-4 shrink-0",
+                  themeMode === opt.value ? "opacity-100" : "opacity-0",
+                )}
+              />
+            </DropdownMenuItem>
+          );
+        })}
+      </DropdownMenuContent>
+    </DropdownMenu>
+  );
+});

package/src/web/theme/theme-mode-options.ts

@@ -0,0 +1,17 @@
+import { Sun, Moon, Monitor } from "lucide-react";
+import type { PpmThemeMode } from "./types";
+
+/**
+ * The three selectable theme modes, in display order. Shared by every mode
+ * picker (settings tab, login screen) so the labels and icons cannot drift
+ * apart between them.
+ */
+export const THEME_MODE_OPTIONS: {
+  value: PpmThemeMode;
+  label: string;
+  icon: React.ElementType;
+}[] = [
+  { value: "light", label: "Light", icon: Sun },
+  { value: "dark", label: "Dark", icon: Moon },
+  { value: "system", label: "System", icon: Monitor },
+];