@hienlh/ppm 0.17.54 → 0.17.56

package/src/web/components/layout/upgrade-button.tsx

@@ -1,9 +1,9 @@
-import { useState, useEffect, useCallback } from "react";
+import { useState, useEffect, useCallback, useMemo } from "react";
 import { api } from "@/lib/api-client";
 import { toast } from "sonner";
 import { Loader2, ArrowUpCircle, RefreshCw, Download, ExternalLink, History } from "lucide-react";
 import { useSettingsStore } from "@/stores/settings-store";
-import { fetchChangelogSince, fetchRecentChangelog, compareSemver, type ChangelogSection } from "@/lib/changelog";
+import { fetchRecentChangelog, newestSectionVersion, compareSemver, type ChangelogSection } from "@/lib/changelog";
 import { cn } from "@/lib/utils";
 
 const POLL_INTERVAL_MS = 60_000;
@@ -113,26 +113,36 @@ export function UpgradeButton({ align = "right" }: { align?: "left" | "right" })
   const [notes, setNotes] = useState<ChangelogSection[] | null>(null);
   const [notesLoading, setNotesLoading] = useState(false);
 
-  useEffect(() => {
-    let timer: ReturnType<typeof setInterval>;
-    async function check() {
-      try {
-        const data = await api.get<UpgradeStatus>("/api/upgrade");
-        setCurrentVersion(data.currentVersion);
-        if (data.availableVersion) {
-          setAvailableVersion(data.availableVersion);
-          setDismissed(!!sessionStorage.getItem(DISMISS_KEY_PREFIX + data.availableVersion));
-        } else {
-          setAvailableVersion(null);
-        }
-      } catch {
-        // ignore — chip just shows the known version
+  // `force` asks the server to bypass its registry cache. The background poll
+  // stays cached (one request per client per minute must not hit the registry),
+  // but a user opening the popover is asking "is there one *now*" and must not
+  // be answered from an answer taken up to five minutes ago.
+  const check = useCallback(async (force = false) => {
+    try {
+      const data = await api.get<UpgradeStatus>(force ? "/api/upgrade?refresh=1" : "/api/upgrade");
+      setCurrentVersion(data.currentVersion);
+      if (data.availableVersion) {
+        setAvailableVersion(data.availableVersion);
+        setDismissed(!!sessionStorage.getItem(DISMISS_KEY_PREFIX + data.availableVersion));
+      } else {
+        setAvailableVersion(null);
       }
+    } catch {
+      // ignore — chip just shows the known version
     }
+  }, []);
+
+  useEffect(() => {
     check();
-    timer = setInterval(check, POLL_INTERVAL_MS);
+    const timer = setInterval(() => check(), POLL_INTERVAL_MS);
     return () => clearInterval(timer);
-  }, []);
+  }, [check]);
+
+  // Opening the popover re-checks immediately, so the panel never disagrees
+  // with itself: release notes and the Update button are resolved together.
+  useEffect(() => {
+    if (open) check(true);
+  }, [open, check]);
 
   const current = currentVersion ?? version;
   // QA hook (latched in sessionStorage — see getTestTarget). Forces the update
@@ -145,25 +155,44 @@ export function UpgradeButton({ align = "right" }: { align?: "left" | "right" })
   const realUpdate = !!availableVersion && !!current && compareSemver(availableVersion, current) > 0
     ? availableVersion
     : null;
-  const effectiveAvailable = realUpdate ?? (isTest ? testTarget : null);
-  const hasUpdate = !!effectiveAvailable && !dismissed;
 
   // Load release notes each time the popover opens. Refetching (not caching for
   // the session) avoids latching a stale/empty result from a transient fetch:
   // the changelog source can briefly lag the version signal after a release.
+  // Always the recent list, unfiltered — the sections themselves are what tell
+  // us whether a newer release exists, so filtering here would hide the signal.
   useEffect(() => {
     if (!open || !current) return;
     setNotesLoading(true);
-    // Update mode → sections newer than installed (test hook shows all).
-    // No update → recent releases so clicking the version chip still shows notes.
-    const load = hasUpdate
-      ? fetchChangelogSince(isTest ? "0.0.0" : current)
-      : fetchRecentChangelog();
-    load
+    fetchRecentChangelog()
       .then(setNotes)
       .catch(() => setNotes([]))
       .finally(() => setNotesLoading(false));
-  }, [open, current, hasUpdate, isTest]);
+  }, [open, current]);
+
+  // The published CHANGELOG is the earliest signal of a release: it updates the
+  // moment the release is pushed, while the registry only flips once the
+  // package is published. Whenever the notes name a version newer than the
+  // installed one, offer the upgrade — seeing a release in this panel and not
+  // being able to take it is never the right outcome, so the panel's own
+  // content is a first-class update signal, not decoration.
+  const changelogUpdate = useMemo(() => {
+    if (!notes || !current) return null;
+    const newest = newestSectionVersion(notes);
+    return newest && compareSemver(newest, current) > 0 ? newest : null;
+  }, [notes, current]);
+
+  const effectiveAvailable = realUpdate ?? changelogUpdate ?? (isTest ? testTarget : null);
+  const hasUpdate = !!effectiveAvailable && !dismissed;
+
+  // In update mode the list answers "what am I about to get", so drop anything
+  // already installed. If that leaves nothing (registry ahead of the changelog)
+  // keep the full list rather than an empty panel.
+  const visibleNotes = useMemo(() => {
+    if (!notes || !hasUpdate || isTest || !current) return notes;
+    const newer = notes.filter((s) => compareSemver(s.version, current) > 0);
+    return newer.length > 0 ? newer : notes;
+  }, [notes, hasUpdate, isTest, current]);
 
   // The server is restarting into the new version — stop showing "Updating…",
   // switch to the reconnect state, and auto-reload once it's listening again
@@ -185,7 +214,7 @@ export function UpgradeButton({ align = "right" }: { align?: "left" | "right" })
       } else {
         toast.info(data.message || "Upgrade installed. Restart PPM manually.");
         setUpgrading(false);
-        if (availableVersion) sessionStorage.setItem(DISMISS_KEY_PREFIX + availableVersion, "1");
+        if (effectiveAvailable) sessionStorage.setItem(DISMISS_KEY_PREFIX + effectiveAvailable, "1");
         setDismissed(true);
       }
     } catch (e) {
@@ -193,18 +222,26 @@ export function UpgradeButton({ align = "right" }: { align?: "left" | "right" })
         // Expected: self-replace killed the server before the response flushed.
         // The upgrade is in progress — wait for it, don't report a failure.
         enterRestartWait();
+      } else if (/already on latest/i.test((e as Error).message)) {
+        // Offered from the changelog, but the package registry has not caught up
+        // yet — the release is announced and not yet installable. Say so, and
+        // leave the offer standing so the next attempt can succeed.
+        toast.info(`v${effectiveAvailable} is announced but not published yet — try again shortly.`);
+        setUpgrading(false);
       } else {
         toast.error(`Upgrade failed: ${(e as Error).message}`);
         setUpgrading(false);
       }
     }
-  }, [availableVersion, enterRestartWait]);
+  }, [effectiveAvailable, enterRestartWait]);
 
   const handleDismiss = useCallback(() => {
-    if (availableVersion) sessionStorage.setItem(DISMISS_KEY_PREFIX + availableVersion, "1");
+    // Key on the offered version, not just the server-reported one: an update
+    // known only from the changelog must be dismissable too.
+    if (effectiveAvailable) sessionStorage.setItem(DISMISS_KEY_PREFIX + effectiveAvailable, "1");
     setDismissed(true);
     setOpen(false);
-  }, [availableVersion]);
+  }, [effectiveAvailable]);
 
   if (!current && !hasUpdate) return null;
 
@@ -277,9 +314,9 @@ export function UpgradeButton({ align = "right" }: { align?: "left" | "right" })
                 <span className="flex items-center gap-2 text-text-3">
                   <Loader2 className="size-3.5 animate-spin" /> Loading release notes…
                 </span>
-              ) : notes && notes.length > 0 ? (
+              ) : visibleNotes && visibleNotes.length > 0 ? (
                 <div className="space-y-2.5">
-                  {notes.map((s) => (
+                  {visibleNotes.map((s) => (
                     <ChangelogEntry key={s.version} version={s.version} body={s.body} />
                   ))}
                 </div>

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

@@ -216,9 +216,10 @@ export function useChat(sessionId: string | null, providerId = "claude", project
   // Sync streaming state to global store (for favicon + tab icon indicators)
   useEffect(() => {
     if (!sessionId) return;
-    useStreamingStore.getState().setStreaming(sessionId, phase !== "idle");
+    // projectName tags the entry so a project-scoped sync can reconcile it.
+    useStreamingStore.getState().setStreaming(sessionId, phase !== "idle", projectName);
     return () => { useStreamingStore.getState().setStreaming(sessionId, false); };
-  }, [sessionId, phase]);
+  }, [sessionId, phase, projectName]);
 
   /**
    * Route a child event to its parent Agent/Task tool_use's children array.

package/src/web/hooks/use-global-events.ts

@@ -3,6 +3,7 @@ import { WsClient } from "@/lib/ws-client";
 import { getAuthToken } from "@/lib/api-client";
 import { useNotificationStore } from "@/stores/notification-store";
 import { useStreamingStore } from "@/stores/streaming-store";
+import { syncRunningSessions } from "@/lib/sync-running-sessions";
 
 /**
  * App-wide event bus client (`/ws/global`).
@@ -18,6 +19,9 @@ import { useStreamingStore } from "@/stores/streaming-store";
  * - `session:phase_changed` → keeps the tab-strip spinner and title indicator
  *   correct for sessions whose tab is not mounted, and — critically — clears them
  *   when the turn ends. Nothing else can: `useChat` only runs while mounted.
+ *   On every (re)connect the indicators are also reconciled against the server
+ *   registry, since a phase change that happened while this socket was down was
+ *   never delivered and would otherwise stick until a full reload.
  * - `jira:*` → re-dispatched as window events.
  *
  * Also tells the server which project to watch, so file watching follows the
@@ -53,6 +57,7 @@ export function useGlobalEvents(enabled: boolean, projectName?: string): void {
         if (projectRef.current) {
           client.send(JSON.stringify({ type: "watch", projectName: projectRef.current }));
         }
+        void syncRunningSessions(projectRef.current);
         return;
       }
 
@@ -73,8 +78,8 @@ export function useGlobalEvents(enabled: boolean, projectName?: string): void {
       }
 
       if (type === "session:phase_changed") {
-        const d = data as unknown as { sessionId: string; phase: string };
-        useStreamingStore.getState().setStreaming(d.sessionId, d.phase !== "idle");
+        const d = data as unknown as { sessionId: string; phase: string; projectName?: string };
+        useStreamingStore.getState().setStreaming(d.sessionId, d.phase !== "idle", d.projectName);
         return;
       }
 
@@ -97,5 +102,6 @@ export function useGlobalEvents(enabled: boolean, projectName?: string): void {
   useEffect(() => {
     if (!enabled || !projectName) return;
     clientRef.current?.send(JSON.stringify({ type: "watch", projectName }));
+    void syncRunningSessions(projectName);
   }, [enabled, projectName]);
 }

package/src/web/lib/changelog.ts

@@ -51,6 +51,19 @@ export function parseChangelog(md: string): ChangelogSection[] {
   return sections;
 }
 
+/**
+ * Newest version among the given sections, or null when there are none.
+ * Order-independent on purpose: the file is authored newest-first by
+ * convention, and a release that lands out of order must not read as "no newer
+ * version" to the upgrade check that consumes this.
+ */
+export function newestSectionVersion(sections: ChangelogSection[]): string | null {
+  return sections.reduce<string | null>(
+    (best, s) => (best && compareSemver(s.version, best) <= 0 ? best : s.version),
+    null,
+  );
+}
+
 /** Parse CHANGELOG markdown into version sections strictly newer than `since`. */
 export function parseChangelogSince(md: string, since: string): ChangelogSection[] {
   return parseChangelog(md).filter((s) => compareSemver(s.version, since) > 0);

package/src/web/lib/sync-running-sessions.ts

@@ -0,0 +1,27 @@
+import { api, projectUrl } from "@/lib/api-client";
+import { useStreamingStore } from "@/stores/streaming-store";
+
+/**
+ * Reconcile a project's streaming indicators (tab-strip spinner, title/favicon)
+ * against the server's session registry.
+ *
+ * Runs on every `/ws/global` (re)connect and on project switch. Two gaps it
+ * closes, both of which nothing else can:
+ * - a turn running in a tab that is not mounted (tabs mount lazily, so its phase
+ *   never reaches this client) → indicator missing;
+ * - an `idle` broadcast that landed while the global socket was down → indicator
+ *   stuck on until a full page reload.
+ */
+export async function syncRunningSessions(projectName: string | undefined): Promise<void> {
+  if (!projectName) return;
+  try {
+    const running = await api.get<{ sessionId: string }[]>(
+      `${projectUrl(projectName)}/chat/sessions/running`,
+    );
+    useStreamingStore
+      .getState()
+      .replaceProjectStreaming(projectName, running.map((s) => s.sessionId));
+  } catch {
+    // Never block boot or a reconnect on an indicator.
+  }
+}

package/src/web/stores/streaming-store.ts

@@ -2,21 +2,43 @@ import { create } from "zustand";
 
 /** Tracks which chat sessions are currently streaming AI responses */
 interface StreamingStore {
-  /** Set of sessionIds that are actively streaming */
-  sessions: Set<string>;
+  /** sessionId → projectName ("" when unknown) for sessions actively streaming.
+   *  The project is recorded so a project-scoped sync can drop stale entries
+   *  without touching sessions that belong to another project. */
+  sessions: Map<string, string>;
   /** Mark a session as streaming or idle */
-  setStreaming: (sessionId: string, streaming: boolean) => void;
+  setStreaming: (sessionId: string, streaming: boolean, projectName?: string) => void;
+  /**
+   * Reconcile one project's streaming set against the server's registry, which
+   * is authoritative. Needed because an `idle` broadcast missed while
+   * `/ws/global` was down would otherwise leave a spinner running forever —
+   * nothing else ever clears it. Scoped per project: the running list only
+   * covers one project, so entries from other projects must survive.
+   */
+  replaceProjectStreaming: (projectName: string, sessionIds: string[]) => void;
 }
 
 export const useStreamingStore = create<StreamingStore>((set) => ({
-  sessions: new Set(),
-  setStreaming: (sessionId, streaming) =>
+  sessions: new Map(),
+  setStreaming: (sessionId, streaming, projectName) =>
     set((state) => {
-      const next = new Set(state.sessions);
-      if (streaming) next.add(sessionId);
+      const next = new Map(state.sessions);
+      // Keep a previously recorded project when a caller omits it, so the entry
+      // stays reconcilable.
+      if (streaming) next.set(sessionId, projectName ?? next.get(sessionId) ?? "");
       else next.delete(sessionId);
       return { sessions: next };
     }),
+  replaceProjectStreaming: (projectName, sessionIds) =>
+    set((state) => {
+      const running = new Set(sessionIds);
+      const next = new Map(state.sessions);
+      for (const [id, project] of state.sessions) {
+        if (project === projectName && !running.has(id)) next.delete(id);
+      }
+      for (const id of sessionIds) next.set(id, projectName);
+      return { sessions: next };
+    }),
 }));
 
 /** Selector: true if any session is streaming */

package/.rollout-mark

@@ -1,2 +0,0 @@
-logmark=10732315
-{"v":"0.17.50","port":3214,"url":"https://promo-laughing-postposted-personals.trycloudflare.com","tunnelPid":53404,"edgePid":56920,"serverPort":51159}