@hienlh/ppm 0.13.4 → 0.13.5

package/src/services/supervisor.ts

@@ -7,7 +7,7 @@
 import type { Subprocess } from "bun";
 import { resolve } from "node:path";
 import {
-  readFileSync, writeFileSync, existsSync, mkdirSync, openSync, appendFileSync,
+  readFileSync, writeFileSync, existsSync, mkdirSync, openSync, closeSync, appendFileSync,
   unlinkSync,
 } from "node:fs";
 import { getPpmDir } from "./ppm-dir.ts";
@@ -170,40 +170,28 @@ export async function spawnServer(
 }
 
 // ─── Tunnel management ─────────────────────────────────────────────────
-async function extractUrlFromStderr(stderr: ReadableStream<Uint8Array>): Promise<string> {
-  const reader = stderr.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
+const cloudflaredLogPath = () => resolve(getPpmDir(), "cloudflared.log");
 
-  return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => reject(new Error("Tunnel URL timeout (30s)")), 30_000);
-
-    const read = async () => {
+/**
+ * Poll cloudflared log file for trycloudflare URL.
+ * Stderr is redirected to this file (not piped) so cloudflared survives
+ * parent supervisor exit during self-replace (no SIGPIPE on closed pipe).
+ */
+async function extractUrlFromLogFile(child: Subprocess): Promise<string> {
+  const path = cloudflaredLogPath();
+  const deadline = Date.now() + 30_000;
+  while (Date.now() < deadline) {
+    if (existsSync(path)) {
       try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          buffer += decoder.decode(value, { stream: true });
-          const match = buffer.match(TUNNEL_URL_REGEX);
-          if (match) {
-            clearTimeout(timeout);
-            // Keep draining in background to avoid SIGPIPE
-            (async () => {
-              try { while (!(await reader.read()).done) {} } catch {}
-            })();
-            resolve(match[0]);
-            return;
-          }
-        }
-        clearTimeout(timeout);
-        reject(new Error("cloudflared exited without providing URL"));
-      } catch (err) {
-        clearTimeout(timeout);
-        reject(err);
-      }
-    };
-    read();
-  });
+        const content = readFileSync(path, "utf8");
+        const match = content.match(TUNNEL_URL_REGEX);
+        if (match) return match[0];
+      } catch {}
+    }
+    if (child.exitCode !== null) throw new Error("cloudflared exited without providing URL");
+    await Bun.sleep(200);
+  }
+  throw new Error("Tunnel URL timeout (30s)");
 }
 
 async function syncUrlToCloud(url: string) {
@@ -243,11 +231,23 @@ export async function spawnTunnel(port: number): Promise<void> {
       ]
     : [bin, "tunnel", "--url", `http://127.0.0.1:${port}`];
 
-  tunnelChild = Bun.spawn(tunnelCmd, { stderr: "pipe", stdout: "ignore", stdin: "ignore" });
+  // Redirect cloudflared stderr to a log file (not pipe). This way cloudflared
+  // survives parent supervisor exit during self-replace — a piped stderr would
+  // close when parent exits, causing SIGPIPE on next cloudflared log write and
+  // killing the tunnel ~10-15s later (silently breaking adoption).
+  const logPath = cloudflaredLogPath();
+  try { unlinkSync(logPath); } catch {}  // truncate stale URLs from prior run
+  const tunnelLogFd = openSync(logPath, "a");
+  try {
+    tunnelChild = Bun.spawn(tunnelCmd, { stderr: tunnelLogFd, stdout: "ignore", stdin: "ignore" });
+  } finally {
+    // Close our handle; cloudflared keeps its own via dup2
+    try { closeSync(tunnelLogFd); } catch {}
+  }
   if (underSystemd) log("INFO", "Tunnel spawned inside transient systemd-run scope (escapes ppm.service cgroup)");
 
   try {
-    tunnelUrl = await extractUrlFromStderr(tunnelChild.stderr as ReadableStream<Uint8Array>);
+    tunnelUrl = await extractUrlFromLogFile(tunnelChild);
   } catch (err) {
     log("ERROR", `Tunnel URL extraction failed: ${err}`);
     tunnelUrl = null;

package/src/web/components/chat/message-list.tsx

@@ -109,12 +109,21 @@ export function MessageList({
     onFork?.(msgContent, msgId);
   }, [onFork]);
 
-  // Wrap expandCompact: bump visibleCount by loaded count so expansion is immediately visible
-  // in the paginated view (pre-compact messages land at top of flattened array, above pagination window).
+  // Scroll anchor bridge published from inside StickToBottom (needs the context's scrollRef).
+  // MessageList captures pre-expand scroll metrics and restores post-render so the compact
+  // message stays at the same viewport offset when history is prepended.
+  const scrollAnchorRef = useRef<ScrollAnchorHandle | null>(null);
+
+  // Wrap expandCompact: bump visibleCount, then restore scroll after React commits the new DOM.
+  // Pre-compact messages land at top of flattened array, above pagination window — bumping
+  // visibleCount by loaded count ensures they render immediately.
   const handleExpandCompact = useCallback(async (compactId: string, jsonlPath: string): Promise<number> => {
     if (!onExpandCompact) throw new Error("Expansion not wired");
+    scrollAnchorRef.current?.capture();
     const count = await onExpandCompact(compactId, jsonlPath);
     setVisibleCount((c) => c + count);
+    // rAF fires after React commits + layout; two rAFs to cover any async measure (lazy markdown).
+    requestAnimationFrame(() => requestAnimationFrame(() => scrollAnchorRef.current?.restore()));
     return count;
   }, [onExpandCompact]);
 
@@ -140,6 +149,7 @@ export function MessageList({
     <div className="relative flex-1 overflow-hidden flex flex-col min-h-0">
       <StickToBottom className="flex-1 overflow-y-auto overflow-x-hidden [contain:strict] [overflow-anchor:auto]" resize="smooth" initial="instant">
         <StickToBottom.Content className="p-4 space-y-4 select-none [&>*]:[overflow-anchor:auto]">
+          <ScrollAnchorBridge bridgeRef={scrollAnchorRef} />
           {hasMore && (
             <button onClick={() => setVisibleCount((c) => c + PAGE_SIZE)}
               className="w-full py-2 text-xs text-text-secondary hover:text-text-primary bg-surface-elevated/50 hover:bg-surface-elevated rounded-md border border-border/50 transition-colors">
@@ -179,6 +189,43 @@ export function MessageList({
   );
 }
 
+/** Imperative handle exposed by ScrollAnchorBridge — capture & restore scroll on prepend. */
+interface ScrollAnchorHandle {
+  /** Record current scrollTop + scrollHeight before a prepend. No-op if user is at bottom. */
+  capture: () => void;
+  /** After prepend commits, adjust scrollTop by the height delta so viewport stays locked. */
+  restore: () => void;
+}
+
+/**
+ * Consumes StickToBottom's scrollRef (only accessible inside its subtree) and publishes
+ * capture/restore functions to a ref owned by the parent MessageList, so prepend-history
+ * expansion can preserve scroll position across the re-render.
+ */
+function ScrollAnchorBridge({ bridgeRef }: { bridgeRef: React.MutableRefObject<ScrollAnchorHandle | null> }) {
+  const { scrollRef, isAtBottom } = useStickToBottomContext();
+  const state = useRef<{ top: number; height: number } | null>(null);
+  useEffect(() => {
+    bridgeRef.current = {
+      capture: () => {
+        const el = scrollRef.current;
+        if (!el || isAtBottom) { state.current = null; return; } // skip if sticking to bottom
+        state.current = { top: el.scrollTop, height: el.scrollHeight };
+      },
+      restore: () => {
+        const el = scrollRef.current;
+        const s = state.current;
+        if (!el || !s) return;
+        const delta = el.scrollHeight - s.height;
+        if (delta !== 0) el.scrollTop = s.top + delta;
+        state.current = null;
+      },
+    };
+    return () => { bridgeRef.current = null; };
+  }, [bridgeRef, scrollRef, isAtBottom]);
+  return null;
+}
+
 /** Floating button to scroll back to bottom when user has scrolled up */
 function ScrollToBottomButton() {
   const { isAtBottom, scrollToBottom } = useStickToBottomContext();

package/src/web/components/layout/draggable-tab.tsx

@@ -166,7 +166,7 @@ export function DraggableTab({
         // Tag identity marker — VS Code-style vertical bar on left edge (centered, ~60% height, rounded right)
         <span
           aria-hidden
-          className="absolute left-0 top-2 bottom-2 w-[2px] rounded-r-full pointer-events-none"
+          className="absolute left-0 top-2 bottom-2 w-[3px] rounded-r-full pointer-events-none"
           style={{ backgroundColor: tagColor }}
         />
       )}

package/src/web/hooks/use-chat.ts

@@ -816,7 +816,14 @@ export function useChat(sessionId: string | null, providerId = "claude", project
   /** Fetch pre-compact transcript. Idempotent: re-expanding same id replaces entry. */
   const expandCompact = useCallback(async (compactMessageId: string, jsonlPath: string): Promise<number> => {
     if (!projectName) throw new Error("No project context available");
-    const url = `${projectUrl(projectName)}/chat/pre-compact-messages?jsonlPath=${encodeURIComponent(jsonlPath)}`;
+    // Claude's compact summary references the CURRENT session file (pre+summary+post).
+    // Strip the `pc-{hash}-` prefix added by prefixPreCompactIds for nested expansions
+    // so BE receives the raw session uuid and truncates at the correct boundary.
+    const rawUuid = compactMessageId.replace(/^pc-[^-]+-/, "");
+    const url =
+      `${projectUrl(projectName)}/chat/pre-compact-messages` +
+      `?jsonlPath=${encodeURIComponent(jsonlPath)}` +
+      `&before=${encodeURIComponent(rawUuid)}`;
     const loaded = await api.get<ChatMessage[]>(url);
     const prefixed = prefixPreCompactIds(loaded, jsonlPath);
     setExpansions((prev) => {

package/dist/web/assets/keybindings-store-V12kZZHO.js

@@ -1 +0,0 @@
-import"./vendor-markdown-0Mxgxy0L.js";import"./api-client-r4nyVy7H.js";import{E as e}from"./index-DJOjXTcq.js";export{e as useKeybindingsStore};

package/docs/journals/2026-04-22-compare-files-feature-ship.md

@@ -1,53 +0,0 @@
-# Compare-Files Feature Ship
-
-**Date**: 2026-04-22 14:35
-**Severity**: Low
-**Component**: Web IDE / Diff Viewer
-**Status**: Resolved
-
-## What Happened
-
-Shipped compare-files feature (file diff picker) for PPM web IDE. Four trigger paths — tab context menu, file-tree context menu, command palette, keyboard shortcut `Mod+Alt+D`. Reused existing DiffViewer + git-diff tab type; zero backend changes. Added zustand store with persist middleware, ComparePicker singleton at App root, and in-flight guard to prevent double-invoke race.
-
-## Technical Details
-
-- **370 new lines of code** across 3 new files + 6 edited files
-- **Zustand store** (`useCompareStore`) with `persist` middleware that strips dirty content >500KB
-- **Dirty-buffer semantic**: snapshot at select-time, not compare-time (closing the tab doesn't invalidate selection)
-- **Custom event** (`open-compare-picker`) dispatched from 4 trigger points, singleton listener mounted at App root
-- **Keyboard shortcut**: `Mod+Alt+D` single-stroke (chord parser doesn't support `Cmd+K D` yet)
-- **Module-scope subscription**: `useProjectStore.subscribe` auto-clears selection on project switch
-- **In-flight guard**: ref-based tracking in `handlePick` to block concurrent invocations (reviewer comment M5)
-- **Test coverage**: 1698 pass, 48 pre-existing unrelated failures, 0 new regressions
-- **Code review**: 7.5/10, 0 critical, 6 major (1 addressed: M5; 3 deferred: M3/M4/M6)
-
-## Why This Matters
-
-Snapshot-at-select semantics felt risky initially but aligns with user mental model: "I'm picking a version to diff." Closing the tab doesn't invalidate the selection — this is more intuitive than invalidating on every interaction. Deferring byte-accurate persist limit (M4), clear-on-error (M3), and legacy multi-select-compare unification (M6) kept scope tight; all are low-risk YAGNI.
-
-## Key Decisions
-
-1. **Same-project only**: Cross-project selection auto-cleared rather than supported. Reduces state complexity; users can switch projects and re-pick.
-2. **Single-stroke `Mod+Alt+D`**: Chord parser limitation means `Cmd+K D` unsupported. Single-stroke is good enough; avoiding yak-shave on chord parsing.
-3. **Snapshot timing**: Capturing dirty buffer at select-time (not compare-time) prevents stale diffs after file edits. User closes tab; selection still valid.
-4. **Defer judgment calls**: M3/M4/M6 are correctness edge-cases, not showstoppers. Shipping first; addressing in follow-up if telemetry justifies.
-
-## Lessons Learned
-
-- **Persist middleware footprint**: 500KB strip limit is conservative but safe; no observed bloat in dev.
-- **Custom events + singleton**: Avoids prop-drilling 4 trigger points through component tree. Event-driven pattern cleaner than callback props.
-- **In-flight guard as ref**: Simpler than promise-based debounce; prevents race without async complexity.
-- **Deferred ≠ broken**: 6 major review comments sound high, but only 1 was blocking (M5). Others are judgment-calls; shipping with known trade-offs is valid.
-
-## Next Steps
-
-- Monitor telemetry for M3 (clear-on-error) if users report stale diffs
-- Consider byte-accurate persist limit (M4) if DB bloat observed
-- Unify legacy multi-select-compare path (M6) in v0.14 if feature gains adoption
-
-Commit: `cc09bb5b9e652a2feefde4e533934a6f53301895`
-
----
-
-**Status:** Resolved
-**Summary:** Shipped compare-files feature with 4 trigger paths, zustand persist store, and event-driven ComparePicker. 370 new LOC, 0 new test regressions, 1 review blocker addressed (M5), 3 judgment-calls deferred (M3/M4/M6). Snapshot-at-select semantics and same-project-only scope kept complexity tight.