@arenahito/piggychick 0.2.1 → 0.2.2

package/dist/assets/main.js

@@ -146167,7 +146167,7 @@ var fetchJson = async (url, init) => {
   return data;
 };
 var fetchRoots = () => fetchJson("/api/roots?prdSort=desc");
-var rootEventsUrl = (rootId) => `/api/roots/${encodeURIComponent(rootId)}/events`;
+var allEventsUrl = () => "/api/events";
 var fetchPlan = (rootId, prd) => fetchJson(`/api/roots/${encodeURIComponent(rootId)}/prds/${encodeURIComponent(prd)}/plan`);
 var fetchMarkdown = (rootId, prd, docId) => fetchJson(`/api/roots/${encodeURIComponent(rootId)}/prds/${encodeURIComponent(prd)}/${encodeURIComponent(docId)}`);
 var fetchConfig = () => fetchJson("/api/config");
@@ -154078,7 +154078,10 @@ var normalizeRootChangedEvent = (input, fallbackRootId) => {
   const candidate = input;
   if (candidate.kind !== "changed")
     return null;
-  const rootId = typeof candidate.rootId === "string" && candidate.rootId.trim().length > 0 ? candidate.rootId : fallbackRootId;
+  const normalizedFallbackRootId = typeof fallbackRootId === "string" && fallbackRootId.trim().length > 0 ? fallbackRootId : null;
+  const rootId = typeof candidate.rootId === "string" && candidate.rootId.trim().length > 0 ? candidate.rootId : normalizedFallbackRootId;
+  if (!rootId)
+    return null;
   const prdId = typeof candidate.prdId === "string" && candidate.prdId.trim().length > 0 ? candidate.prdId : null;
   const at2 = typeof candidate.at === "string" ? candidate.at : new Date().toISOString();
   return { kind: "changed", rootId, prdId, at: at2 };
@@ -154091,16 +154094,13 @@ var parseRootChangedEvent = (raw, fallbackRootId) => {
     return null;
   }
 };
-var createRootEventsSubscription = (rootId, onChanged, onError) => {
-  const source = new EventSource(rootEventsUrl(rootId));
-  const handleChanged = (event4) => {
-    const payload = parseRootChangedEvent(event4.data, rootId);
-    if (!payload)
-      return;
-    onChanged(payload);
-  };
-  const handleMessage = (event4) => {
-    const payload = parseRootChangedEvent(event4.data, rootId);
+var createGlobalEventsSubscription = (onChanged, onError) => {
+  return createEventsSubscription(allEventsUrl(), onChanged, onError);
+};
+var createEventsSubscription = (url, onChanged, onError, fallbackRootId) => {
+  const source = new EventSource(url);
+  const handleEvent = (event4) => {
+    const payload = parseRootChangedEvent(event4.data, fallbackRootId);
     if (!payload)
       return;
     onChanged(payload);
@@ -154108,13 +154108,13 @@ var createRootEventsSubscription = (rootId, onChanged, onError) => {
   const handleError2 = (event4) => {
     onError?.(event4);
   };
-  source.addEventListener("changed", handleChanged);
-  source.addEventListener("message", handleMessage);
+  source.addEventListener("changed", handleEvent);
+  source.addEventListener("message", handleEvent);
   source.addEventListener("error", handleError2);
   return {
     close: () => {
-      source.removeEventListener("changed", handleChanged);
-      source.removeEventListener("message", handleMessage);
+      source.removeEventListener("changed", handleEvent);
+      source.removeEventListener("message", handleEvent);
       source.removeEventListener("error", handleError2);
       source.close();
     }
@@ -154205,6 +154205,7 @@ var configRequest = 0;
 var configHandle = null;
 var rootEventSubscriptions = new Map;
 var pendingRootChangeEvents = [];
+var globalEventsSubscriptionKey = "__global__";
 var readBooleanRecord = (key) => {
   try {
     const raw = localStorage.getItem(key);
@@ -154329,6 +154330,10 @@ var findFirstSelection = () => {
   }
   return null;
 };
+var createGlobalEventsSubscriptionKey = (roots) => {
+  const rootIds = [...new Set(roots.map((rootEntry) => rootEntry.id))].sort((left3, right3) => left3.localeCompare(right3, "en", { sensitivity: "base", numeric: true }));
+  return `${globalEventsSubscriptionKey}:${JSON.stringify(rootIds)}`;
+};
 var ensureSelection = (route) => {
   let updatedHash = false;
   if (route?.kind === "config") {
@@ -154792,8 +154797,12 @@ var handleRootChangedEvent = (event4) => {
   liveRefreshRunner.trigger();
 };
 var reconcileRootEventStreams = () => {
-  const rootIds = state3.roots.map((rootEntry) => rootEntry.id);
-  rootEventSubscriptions = reconcileRootSubscriptions(rootEventSubscriptions, rootIds, (rootId) => createRootEventsSubscription(rootId, handleRootChangedEvent));
+  if (state3.roots.length === 0) {
+    closeAllRootEventStreams();
+    return;
+  }
+  const subscriptionKey = createGlobalEventsSubscriptionKey(state3.roots);
+  rootEventSubscriptions = reconcileRootSubscriptions(rootEventSubscriptions, [subscriptionKey], () => createGlobalEventsSubscription(handleRootChangedEvent));
 };
 var syncRoots = async (payload, options2 = {}) => {
   const allowLoadSelection = options2.allowLoadSelection ?? true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arenahito/piggychick",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/server/prd-events.ts

@@ -4,6 +4,7 @@ import { basename, join, sep } from "node:path";
 import { resolveConfigPath } from "../shared/config";
 import {
   inferPrdIdFromWatchPath,
+  listRootIds,
   listRootWatchTargetsByRootId,
   type RootWatchTarget,
 } from "./tasks";
@@ -274,6 +275,34 @@ const getOrCreateRootEntry = async (rootId: string, configPath: string) => {
   return init;
 };
 
+const attachSubscriberToRoots = async (
+  rootIds: string[],
+  configPath: string,
+  isClosed: () => boolean,
+  subscriber: Subscriber,
+  attachedRootIds: Set<string>,
+) => {
+  for (const rootId of rootIds) {
+    if (isClosed()) {
+      return;
+    }
+    if (attachedRootIds.has(rootId)) {
+      continue;
+    }
+    let entry: RootEventEntry | null = null;
+    try {
+      entry = await getOrCreateRootEntry(rootId, configPath);
+    } catch {
+      entry = null;
+    }
+    if (!entry || isClosed()) {
+      continue;
+    }
+    entry.subscribers.add(subscriber);
+    attachedRootIds.add(rootId);
+  }
+};
+
 export const createRootEventsResponse = async (
   request: Request,
   rootId: string,
@@ -358,6 +387,102 @@ export const createRootEventsResponse = async (
   });
 };
 
+export const createGlobalEventsResponse = async (
+  request: Request,
+  configPath = resolveConfigPath(),
+) => {
+  const encoder = new TextEncoder();
+  let closed = false;
+  let keepalive: ReturnType<typeof setInterval> | null = null;
+  let removeAbort: (() => void) | null = null;
+  const attachedRootIds = new Set<string>();
+  let cleanup = () => {};
+
+  const stream = new ReadableStream<Uint8Array>({
+    async start(controller) {
+      const send = (chunk: string) => {
+        controller.enqueue(encoder.encode(chunk));
+      };
+      const subscriber: Subscriber = (event) => {
+        if (closed) return;
+        try {
+          send(formatChangedEvent(event));
+        } catch {
+          cleanup();
+        }
+      };
+      cleanup = () => {
+        if (closed) return;
+        closed = true;
+        if (keepalive) {
+          clearInterval(keepalive);
+          keepalive = null;
+        }
+        for (const rootId of attachedRootIds) {
+          const entry = rootEntries.get(rootId);
+          if (!entry) continue;
+          entry.subscribers.delete(subscriber);
+          closeEntryIfUnused(rootId);
+        }
+        attachedRootIds.clear();
+        if (removeAbort) {
+          removeAbort();
+          removeAbort = null;
+        }
+        try {
+          controller.close();
+        } catch {
+          return;
+        }
+      };
+
+      if (request.signal.aborted) {
+        cleanup();
+        return;
+      }
+
+      const onAbort = () => cleanup();
+      request.signal.addEventListener("abort", onAbort, { once: true });
+      removeAbort = () => request.signal.removeEventListener("abort", onAbort);
+
+      try {
+        const rootIds = await listRootIds(configPath).catch(() => []);
+        await attachSubscriberToRoots(
+          rootIds,
+          configPath,
+          () => closed,
+          subscriber,
+          attachedRootIds,
+        );
+        if (closed) return;
+        send(": connected\n\n");
+        keepalive = setInterval(() => {
+          if (closed) return;
+          try {
+            send(": keepalive\n\n");
+          } catch {
+            cleanup();
+          }
+        }, keepaliveMs);
+      } catch {
+        cleanup();
+      }
+    },
+    cancel() {
+      cleanup();
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream; charset=utf-8",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no",
+    },
+  });
+};
+
 export const getRootEventsDebugSnapshot = () => {
   let watcherCount = 0;
   let subscriberCount = 0;

package/src/server/routes.ts

@@ -11,7 +11,7 @@ import {
   toConfigFile,
   writeConfigText,
 } from "../shared/config";
-import { createRootEventsResponse } from "./prd-events";
+import { createGlobalEventsResponse, createRootEventsResponse } from "./prd-events";
 import {
   listRoots,
   readMarkdownByRoot,
@@ -70,6 +70,17 @@ export const handleApiRequest = async (request: Request, configPath = resolveCon
     return jsonError(404, "not_found", "Not found");
   }
 
+  if (segments[1] === "events" && segments.length === 2) {
+    if (request.method !== "GET") {
+      return jsonError(405, "method_not_allowed", "Method not allowed");
+    }
+    try {
+      return await createGlobalEventsResponse(request, configPath);
+    } catch (error) {
+      return handleTasksError(error);
+    }
+  }
+
   if (segments[1] === "roots" && segments.length === 2) {
     if (request.method === "GET") {
       try {

package/src/server/tasks.ts

@@ -685,6 +685,12 @@ export const listRoots = async (
   return { roots };
 };
 
+export const listRootIds = async (configPath = resolveConfigPath()) => {
+  const config = await loadConfigFile(configPath);
+  const normalized = await normalizeConfig(config, { path: configPath });
+  return buildRootEntries(normalized.roots).map((entry) => entry.id);
+};
+
 export const resolveRootById = async (rootId: string, configPath = resolveConfigPath()) => {
   const config = await loadConfigFile(configPath);
   const normalized = await normalizeConfig(config, { path: configPath });