pmx-canvas 0.3.4 → 0.4.1

package/src/client/state/sse-bridge.ts

@@ -22,10 +22,11 @@ import {
   restoreLayout,
   sessionId,
   traceEnabled,
-  updateNode,
   updateNodeData,
+  workbenchConnectionEpoch,
 } from './canvas-store';
 import { fetchAxSurfaceState } from './intent-bridge';
+import { DEFAULT_POSITIONS, makeNodeState } from './node-factory';
 import { invalidateTokenCache } from '../theme/tokens';
 import { resetAttentionBridge, syncAttentionFromSse } from './attention-bridge';
 import { dissolveIntent, resetIntents, settleIntent, upsertIntent } from './intent-store';
@@ -36,10 +37,36 @@ let savedLayout: Map<string, Partial<CanvasNodeState>> | null = null;
 let reconnectAttempts = 0;
 let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
 
+// ── Proxy-safe polling transport ──────────────────────────────
+// Some proxies (e.g. the Amp orb portal) buffer streaming responses and only
+// flush them on close, so the SSE stream delivers NOTHING — the connection
+// "opens" (headers pass through) but no event ever arrives. Fallback: if the
+// stream produces no event at all within the watchdog window, switch to
+// polling GET /api/workbench/poll, which returns buffered events (or a full
+// connect snapshot) as a normal response every couple of seconds. The same
+// EVENT_HANDLERS map serves both transports. `?transport=poll` forces polling
+// from the start; `?transport=sse` disables the fallback.
+const SSE_FIRST_EVENT_WATCHDOG_MS = 3000;
+const POLL_INTERVAL_MS = 2000;
+const POLL_ERROR_INTERVAL_MS = 5000;
+let pollingMode = false;
+let pollTimer: ReturnType<typeof setTimeout> | null = null;
+let pollSeq: number | null = null;
+let pollGeneration = 0;
+let sseFirstEventWatchdog: ReturnType<typeof setTimeout> | null = null;
+
+function forcedTransport(): 'poll' | 'sse' | null {
+  if (typeof location === 'undefined') return null;
+  const value = new URLSearchParams(location.search).get('transport');
+  return value === 'poll' || value === 'sse' ? value : null;
+}
+
 // Maps responseNodeId → thread prompt node ID so response deltas/completions
 // are routed into the thread's turns array instead of creating separate nodes.
-// Entries are added on response-start and removed on response-complete.
-// Not cleaned on SSE reconnect — orphaned entries are benign (small, bounded by active streams).
+// Entries are added on response-start and removed on response-complete. Streams
+// still in flight when the connection drops would otherwise leak entries, so
+// connectSSE() — the shared entry path for both transports — clears the map
+// alongside the rest of the per-connection state.
 const responseToThreadMap = new Map<string, string>();
 
 // ── Helpers ───────────────────────────────────────────────────
@@ -71,44 +98,15 @@ function applyLayoutOverrides(node: CanvasNodeState): CanvasNodeState {
   };
 }
 
-// ── Default positions by type ─────────────────────────────────
-const DEFAULT_POSITIONS: Record<CanvasNodeState['type'], { x: number; y: number; w: number; h: number }> &
-  Record<'prompt' | 'response', { x: number; y: number; w: number; h: number }> = {
-  status: { x: 40, y: 80, w: 300, h: 120 },
-  markdown: { x: 380, y: 80, w: 720, h: 600 },
-  context: { x: 1130, y: 80, w: 320, h: 400 },
-  'mcp-app': { x: 380, y: 720, w: 960, h: 600 },
-  webpage: { x: 380, y: 80, w: 520, h: 420 },
-  'json-render': { x: 380, y: 720, w: 840, h: 620 },
-  graph: { x: 380, y: 720, w: 760, h: 520 },
-  ledger: { x: 1130, y: 520, w: 320, h: 280 },
-  trace: { x: 40, y: 900, w: 200, h: 56 },
-  file: { x: 380, y: 80, w: 720, h: 600 },
-  image: { x: 380, y: 80, w: 720, h: 520 },
-  html: { x: 380, y: 80, w: 720, h: 640 },
-  group: { x: 220, y: 60, w: 840, h: 560 },
-  prompt: { x: 380, y: 1260, w: 520, h: 400 },
-  response: { x: 380, y: 1480, w: 720, h: 400 },
-};
-
+// Default geometry lives in the shared node factory (node-factory.ts); this
+// wrapper just layers the connection-local saved-layout overrides on top.
 function makeNode(
   id: string,
   type: CanvasNodeState['type'],
   data: Record<string, unknown>,
   dockPosition: 'left' | 'right' | null = null,
 ): CanvasNodeState {
-  const pos = DEFAULT_POSITIONS[type];
-  return applyLayoutOverrides({
-    id,
-    type,
-    position: { x: pos.x, y: pos.y },
-    size: { width: pos.w, height: pos.h },
-    zIndex: type === 'status' ? 0 : 1,
-    collapsed: false,
-    pinned: false,
-    dockPosition,
-    data,
-  });
+  return applyLayoutOverrides(makeNodeState(id, type, data, { dockPosition }));
 }
 
 function getMarkdownPlacement(): { x: number; y: number } {
@@ -205,26 +203,20 @@ function ensureExtAppNode(data: Record<string, unknown>): void {
     customX === undefined || customY === undefined
       ? findOpenCanvasPosition([...nodes.value.values()], width, height)
       : null;
-  const node = applyLayoutOverrides({
-    id,
-    type: 'mcp-app' as const,
-    position: {
-      x: customX ?? autoPos?.x ?? pos.x,
-      y: customY ?? autoPos?.y ?? pos.y,
-    },
-    size: {
-      width,
-      height,
-    },
-    zIndex: 1,
-    collapsed: false,
-    pinned: false,
-    dockPosition: null,
-    data: {
-      mode: 'ext-app',
-      ...data,
-    },
-  });
+  const node = applyLayoutOverrides(
+    makeNodeState(
+      id,
+      'mcp-app',
+      { mode: 'ext-app', ...data },
+      {
+        position: {
+          x: customX ?? autoPos?.x ?? pos.x,
+          y: customY ?? autoPos?.y ?? pos.y,
+        },
+        size: { width, height },
+      },
+    ),
+  );
   addNode(node);
   if (!node.dockPosition) {
     focusNode(id, { recordHistory: false });
@@ -402,6 +394,8 @@ function parseCanvasAnnotation(raw: Record<string, unknown>): CanvasAnnotation |
 function handleConnected(data: Record<string, unknown>): void {
   sessionId.value = (data.sessionId as string) || '';
   connectionStatus.value = 'connected';
+  // Reconnect marker for holders of server-minted URLs (Finding S).
+  workbenchConnectionEpoch.value += 1;
   if (typeof data.theme === 'string') {
     applyCanvasTheme(data.theme);
   }
@@ -637,24 +631,21 @@ function handleCanvasPromptCreated(data: Record<string, unknown>): void {
   if (!nodes.value.has(nodeId)) {
     const pos = position ?? DEFAULT_POSITIONS.prompt;
     addNode(
-      applyLayoutOverrides({
-        id: nodeId,
-        type: 'prompt' as const,
-        position: { x: pos.x, y: pos.y },
-        size: { width: DEFAULT_POSITIONS.prompt.w, height: 400 },
-        zIndex: 1,
-        collapsed: false,
-        pinned: false,
-        dockPosition: null,
-        data: {
-          text,
-          turns: text ? [{ role: 'user', text, status: 'pending' }] : [],
-          threadStatus: text ? 'pending' : 'draft',
-          status: text ? 'pending' : 'draft',
-          parentNodeId,
-          contextNodeIds,
-        },
-      }),
+      applyLayoutOverrides(
+        makeNodeState(
+          nodeId,
+          'prompt',
+          {
+            text,
+            turns: text ? [{ role: 'user', text, status: 'pending' }] : [],
+            threadStatus: text ? 'pending' : 'draft',
+            status: text ? 'pending' : 'draft',
+            parentNodeId,
+            contextNodeIds,
+          },
+          { position: { x: pos.x, y: pos.y } },
+        ),
+      ),
     );
     focusNode(nodeId);
   }
@@ -706,17 +697,14 @@ function handleCanvasResponseStart(data: Record<string, unknown>): void {
 
   if (!nodes.value.has(responseNodeId)) {
     addNode(
-      applyLayoutOverrides({
-        id: responseNodeId,
-        type: 'response' as const,
-        position: pos,
-        size: { width: DEFAULT_POSITIONS.response.w, height: DEFAULT_POSITIONS.response.h },
-        zIndex: 1,
-        collapsed: false,
-        pinned: false,
-        dockPosition: null,
-        data: { content: '', status: 'streaming', promptNodeId },
-      }),
+      applyLayoutOverrides(
+        makeNodeState(
+          responseNodeId,
+          'response',
+          { content: '', status: 'streaming', promptNodeId },
+          { position: pos },
+        ),
+      ),
     );
   }
 
@@ -991,17 +979,124 @@ export const EVENT_HANDLERS: Record<string, (data: Record<string, unknown>) => v
   'ax-intent-clear': handleAxIntentClear,
 };
 
+/** Dispatch one event (from either transport) through the shared handler map. */
+function dispatchWorkbenchEvent(event: string, payload: unknown): void {
+  const handler = EVENT_HANDLERS[event as keyof typeof EVENT_HANDLERS];
+  if (!handler) return;
+  // The map's handlers each declare their own payload type; over the wire the
+  // payload is untyped JSON either way (SSE previously passed JSON.parse output
+  // straight in). The double cast states that honestly without `any`.
+  const invoke = handler as unknown as (value: unknown) => void;
+  try {
+    invoke(payload);
+  } catch (err) {
+    console.warn(`[sse-bridge] Handler for "${event}" failed:`, err);
+  }
+}
+
+/**
+ * Polling transport loop. Each response is short-lived, so it flushes through
+ * any buffering proxy. Snapshot responses (fresh client / server restart /
+ * ring eviction) carry the same event list an SSE connect sends, so replaying
+ * them through the handlers matches existing reconnect semantics.
+ */
+function startPollingTransport(): () => void {
+  pollingMode = true;
+  pollGeneration += 1;
+  const generation = pollGeneration;
+  connectionStatus.value = 'connecting';
+  // Server-run identity from the last poll response. The event seq counter
+  // restarts at 0 on every server boot, so a cursor from a previous run can
+  // look "usable" to a new run and silently skip its earlier events.
+  let lastPollSessionId: string | null = null;
+  let dispatchedOnce = false;
+
+  const pollOnce = async (): Promise<void> => {
+    if (generation !== pollGeneration) return;
+    try {
+      const params = new URLSearchParams();
+      if (pollSeq !== null) params.set('since', String(pollSeq));
+      const sid = sessionId.value;
+      if (sid) params.set('session', sid);
+      const query = params.toString();
+      const response = await fetch(`/api/workbench/poll${query ? `?${query}` : ''}`);
+      if (generation !== pollGeneration) return;
+      if (!response.ok) throw new Error(`poll failed with HTTP ${response.status}`);
+      const body = (await response.json()) as {
+        ok: boolean;
+        seq: number;
+        snapshot: boolean;
+        sessionId?: string;
+        events: Array<{ event: string; payload: unknown }>;
+      };
+      if (generation !== pollGeneration) return;
+      if (!body.ok) throw new Error('poll returned ok: false');
+      const priorSession = lastPollSessionId;
+      lastPollSessionId = body.sessionId ?? null;
+      if (priorSession !== null && body.sessionId && priorSession !== body.sessionId && !body.snapshot) {
+        // The server identity changed under our cursor (restart): a non-snapshot
+        // batch may have silently skipped the new run's earlier events. Discard
+        // it, drop the cursor, and re-poll immediately for a full snapshot.
+        pollSeq = null;
+        pollTimer = setTimeout(() => void pollOnce(), 0);
+        return;
+      }
+      if (body.snapshot && dispatchedOnce) {
+        // A mid-polling snapshot (ring eviction or server restart) replaces
+        // client state wholesale — run the same per-connection resets an SSE
+        // reconnect performs so in-flight stream routes and transient state
+        // from the previous window can't leak (H5 orphan class).
+        savedLayout = restoreLayout();
+        ensureStatusNode();
+        hasInitialServerLayout.value = false;
+        resetAttentionBridge();
+        resetIntents();
+        responseToThreadMap.clear();
+      }
+      for (const entry of body.events) dispatchWorkbenchEvent(entry.event, entry.payload);
+      dispatchedOnce = true;
+      pollSeq = body.seq;
+      connectionStatus.value = 'connected';
+      pollTimer = setTimeout(() => void pollOnce(), POLL_INTERVAL_MS);
+    } catch (err) {
+      if (generation !== pollGeneration) return;
+      console.warn('[sse-bridge] poll transport error:', err);
+      connectionStatus.value = 'disconnected';
+      pollTimer = setTimeout(() => void pollOnce(), POLL_ERROR_INTERVAL_MS);
+    }
+  };
+  void pollOnce();
+
+  return () => {
+    pollGeneration += 1;
+    pollingMode = false;
+    pollSeq = null;
+    if (pollTimer) {
+      clearTimeout(pollTimer);
+      pollTimer = null;
+    }
+  };
+}
+
 export function connectSSE(): () => void {
   savedLayout = restoreLayout();
   ensureStatusNode();
   hasInitialServerLayout.value = false;
   resetAttentionBridge();
   resetIntents();
+  // Response→thread routes belong to the dropped connection's in-flight
+  // streams; clear them so orphans can't accumulate across reconnect cycles.
+  responseToThreadMap.clear();
   if (reconnectTimer) {
     clearTimeout(reconnectTimer);
     reconnectTimer = null;
   }
 
+  const transport = forcedTransport();
+  if (transport === 'poll' || pollingMode) {
+    return startPollingTransport();
+  }
+
   const sid = sessionId.value;
   const url = sid ? `/api/workbench/events?session=${sid}` : '/api/workbench/events';
   connectionStatus.value = 'connecting';
@@ -1009,10 +1104,28 @@ export function connectSSE(): () => void {
   const source = new EventSource(url);
   eventSource = source;
 
-  for (const [event, handler] of Object.entries(EVENT_HANDLERS)) {
+  // Proxy detection: a buffered stream "opens" (headers pass through) but never
+  // delivers a single event — not even the immediate `connected` frame. Key the
+  // watchdog on the FIRST EVENT, not onopen.
+  let gotFirstEvent = false;
+  if (sseFirstEventWatchdog) clearTimeout(sseFirstEventWatchdog);
+  sseFirstEventWatchdog = null;
+  if (transport !== 'sse') {
+    sseFirstEventWatchdog = setTimeout(() => {
+      sseFirstEventWatchdog = null;
+      if (gotFirstEvent || eventSource !== source) return;
+      console.warn('[sse-bridge] No SSE event within watchdog window — switching to polling transport.');
+      source.close();
+      eventSource = null;
+      startPollingTransport();
+    }, SSE_FIRST_EVENT_WATCHDOG_MS);
+  }
+
+  for (const [event] of Object.entries(EVENT_HANDLERS)) {
     source.addEventListener(event, (e) => {
+      gotFirstEvent = true;
       try {
-        handler(JSON.parse((e as MessageEvent).data));
+        dispatchWorkbenchEvent(event, JSON.parse((e as MessageEvent).data));
       } catch (err) {
         // H5: Surface malformed SSE data during debugging instead of silently swallowing
         console.warn(`[sse-bridge] Failed to parse "${event}" event:`, err);
@@ -1043,6 +1156,19 @@ export function connectSSE(): () => void {
       clearTimeout(reconnectTimer);
       reconnectTimer = null;
     }
+    if (sseFirstEventWatchdog) {
+      clearTimeout(sseFirstEventWatchdog);
+      sseFirstEventWatchdog = null;
+    }
+    if (pollingMode) {
+      pollGeneration += 1;
+      pollingMode = false;
+      pollSeq = null;
+      if (pollTimer) {
+        clearTimeout(pollTimer);
+        pollTimer = null;
+      }
+    }
     source.close();
     eventSource = null;
   };

package/src/client/uuid-polyfill.ts

@@ -0,0 +1,14 @@
+// crypto.randomUUID is only defined in SECURE CONTEXTS. Embedded hosts that
+// serve the canvas over plain http inside an iframe (portal/proxy setups) get
+// `crypto` without `randomUUID`, which would throw on every per-mount nonce
+// (AX tokens, frame tokens, session ids). Polyfill with the standard v4
+// fallback; a strict no-op wherever the native implementation exists. These
+// ids are nonces/correlation ids, not cryptographic secrets, so Math.random
+// quality is acceptable for the fallback path.
+if (typeof crypto !== 'undefined' && typeof crypto.randomUUID !== 'function') {
+  (crypto as { randomUUID?: () => string }).randomUUID = () =>
+    'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+      const r = (Math.random() * 16) | 0;
+      return (c === 'x' ? r : (r & 0x3) | 0x8).toString(16);
+    });
+}

package/src/server/canvas-db.ts

@@ -823,14 +823,6 @@ export function readBlobFromDB(db: Database, sha256: string): string | null {
   return gunzipSync(row.data).toString('utf-8');
 }
 
-export function hasBlobInDB(db: Database, sha256: string): boolean {
-  interface CountRow {
-    c: number;
-  }
-  const row = db.query<CountRow, [string]>('SELECT COUNT(*) as c FROM blobs WHERE sha256 = ?').get(sha256);
-  return (row?.c ?? 0) > 0;
-}
-
 // ── AX Timeline Persistence (NOT snapshotted; bounded by retention) ──
 
 function safeParseJson(raw: string | null | undefined): unknown {

package/src/server/canvas-schema.ts

@@ -937,7 +937,7 @@ export function describeCanvasSchema(): {
     htmlPrimitives: listHtmlPrimitiveDescriptors(),
     mcp: {
       tools: [
-        // 15 composites
+        // 16 composites (canvas_snapshot folded the legacy snapshot standalones in v0.4.0)
         'canvas_node',
         'canvas_render',
         'canvas_edge',
@@ -947,6 +947,7 @@ export function describeCanvasSchema(): {
         'canvas_query',
         'canvas_webview',
         'canvas_app',
+        'canvas_snapshot',
         'canvas_ax_state',
         'canvas_ax_work',
         'canvas_ax_gate',
@@ -960,13 +961,6 @@ export function describeCanvasSchema(): {
         'canvas_ax_interaction',
         'canvas_ingest_activity',
         'canvas_screenshot',
-        // 6 snapshot tools (deprecated; fold into canvas_snapshot composite in v0.4)
-        'canvas_snapshot',
-        'canvas_list_snapshots',
-        'canvas_restore',
-        'canvas_delete_snapshot',
-        'canvas_gc_snapshots',
-        'canvas_diff',
       ],
       resources: ['canvas://schema'],
       nodeTypeRouting: buildMcpNodeTypeRouting(nodeTypes),