pmx-canvas 0.4.6 → 0.4.8

package/src/server/demo.ts

@@ -13,6 +13,14 @@ interface DemoStateFixture {
   edges: CanvasEdge[];
   annotations?: CanvasAnnotation[];
   contextPins?: string[];
+  /**
+   * Canvas-bound AX state (work items and friends), restored verbatim so the
+   * `data.axStep.workItemId` stamped on the ⑧ agent-at-work step nodes resolves
+   * to a real work item — without it the seeded Start/Done controls 404.
+   * Timeline rows (events/evidence/steering) are deliberately absent: snapshots
+   * do not restore them either.
+   */
+  ax?: unknown;
 }
 
 const demoState = demoStateJson as DemoStateFixture;
@@ -29,6 +37,22 @@ export function seedDemoCanvas(): { nodes: number; edges: number; groups: number
     for (const annotation of annotations) canvasState.addAnnotation(annotation);
     canvasState.setContextPins(pins);
     canvasState.setViewport(demoState.viewport);
+    // After the nodes exist: the AX partition is normalized against the current
+    // node set, so applying it first would strip every work item's `nodeIds`.
+    //
+    // Only when the canvas-bound AX partition is EMPTY. applyPersistedAxState
+    // REPLACES it (work items, gates, review annotations, and the policy
+    // singleton) and the seed is flushed to disk — and the caller's
+    // only-seed-when-empty guard counts NODES only. Work items need no nodes,
+    // so an agent tracking a plan on a bare board would have it destroyed by
+    // `--demo`.
+    const axPartitionEmpty =
+      canvasState.getWorkItems().length === 0 &&
+      canvasState.getApprovalGates().length === 0 &&
+      canvasState.getReviewAnnotations().length === 0;
+    if (demoState.ax !== undefined && axPartitionEmpty) {
+      canvasState.applyPersistedAxState(structuredClone(demoState.ax));
+    }
   });
   canvasState.flushToDisk();
 

package/src/server/file-content.ts

@@ -0,0 +1,152 @@
+/**
+ * Shared disk reader for `file` canvas nodes.
+ *
+ * Both entry points that put a file on the canvas — `buildFileNodeData`
+ * (creation) and the file watcher (live updates) — go through here so their
+ * notion of "what this file is" can never drift. Reading a file blind with
+ * `readFileSync(path, 'utf-8')` turned binaries into mojibake and had no size
+ * ceiling at all, so a multi-GB file was pulled into memory as a string.
+ */
+
+import { closeSync, openSync, readSync, statSync } from 'node:fs';
+import { extname } from 'node:path';
+
+/** Text past this many bytes is stored truncated instead of whole. */
+export const MAX_FILE_TEXT_BYTES = 2 * 1024 * 1024;
+
+/** Bytes sniffed to classify a file without reading all of it. */
+const SNIFF_BYTES = 8192;
+
+const PDF_MAGIC = Buffer.from('%PDF-', 'ascii');
+
+export type FileNodeContent =
+  /** Missing, unreadable, or not a regular file — the node stays path-backed. */
+  | { kind: 'unavailable' }
+  | { kind: 'binary'; byteSize: number; mtimeMs: number; mimeType?: string }
+  | { kind: 'text'; byteSize: number; mtimeMs: number; text: string; lineCount: number; truncated: boolean };
+
+function isPdfFile(prefix: Buffer, filePath: string): boolean {
+  if (prefix.subarray(0, PDF_MAGIC.length).equals(PDF_MAGIC)) return true;
+  return extname(filePath).toLowerCase() === '.pdf';
+}
+
+/**
+ * PDF check straight from a path, for the byte route's server-derived
+ * Content-Type. Reads only the magic-byte prefix. Any read failure is "not a
+ * PDF" — the caller then serves an opaque download rather than an inline type.
+ */
+export function isPdfFilePath(filePath: string): boolean {
+  let fd: number | null = null;
+  try {
+    fd = openSync(filePath, 'r');
+    const prefix = Buffer.alloc(PDF_MAGIC.length);
+    const read = readSync(fd, prefix, 0, PDF_MAGIC.length, 0);
+    return isPdfFile(prefix.subarray(0, read), filePath);
+  } catch {
+    return false;
+  } finally {
+    if (fd !== null) {
+      try {
+        closeSync(fd);
+      } catch {
+        // best effort
+      }
+    }
+  }
+}
+
+/**
+ * Classify a file and read at most `MAX_FILE_TEXT_BYTES` of it.
+ *
+ * Never throws: an unreadable path is reported as `unavailable`, matching the
+ * pre-existing behavior where a bad path still rendered as a file node.
+ */
+export function readFileNodeContent(filePath: string): FileNodeContent {
+  let fd: number | null = null;
+  try {
+    const stat = statSync(filePath);
+    if (!stat.isFile()) return { kind: 'unavailable' };
+    const byteSize = stat.size;
+    const mtimeMs = stat.mtimeMs;
+
+    fd = openSync(filePath, 'r');
+
+    // Classify from a prefix only — never read a huge file just to type it.
+    const sniff = Buffer.alloc(Math.min(SNIFF_BYTES, byteSize));
+    const prefix = sniff.subarray(0, sniff.length > 0 ? readSync(fd, sniff, 0, sniff.length, 0) : 0);
+
+    // A PDF need not carry a NUL byte in its header, so the magic bytes decide
+    // first; `.pdf` is the secondary signal for the same call.
+    if (isPdfFile(prefix, filePath)) {
+      return { kind: 'binary', byteSize, mtimeMs, mimeType: 'application/pdf' };
+    }
+    if (prefix.includes(0x00)) {
+      return { kind: 'binary', byteSize, mtimeMs };
+    }
+
+    const readLength = Math.min(byteSize, MAX_FILE_TEXT_BYTES);
+    const buffer = Buffer.alloc(readLength);
+    let filled = 0;
+    while (filled < readLength) {
+      const read = readSync(fd, buffer, filled, readLength - filled, filled);
+      if (read <= 0) break;
+      filled += read;
+    }
+
+    // `stream: true` makes the decoder hold back a multi-byte sequence the cap
+    // sliced in half instead of emitting U+FFFD; we never flush, so the partial
+    // trailing bytes are simply dropped and the text ends on a real character.
+    const text = new TextDecoder('utf-8').decode(buffer.subarray(0, filled), { stream: true });
+
+    return {
+      kind: 'text',
+      byteSize,
+      mtimeMs,
+      text,
+      lineCount: text.split('\n').length,
+      truncated: byteSize > MAX_FILE_TEXT_BYTES,
+    };
+  } catch {
+    return { kind: 'unavailable' };
+  } finally {
+    if (fd !== null) closeSync(fd);
+  }
+}
+
+/**
+ * Map a read result onto `file` node data in place, clearing the fields the new
+ * state contradicts (a file that turns binary must not keep stale decoded text).
+ */
+export function applyFileContentToNodeData(
+  data: Record<string, unknown>,
+  content: FileNodeContent,
+): Record<string, unknown> {
+  if (content.kind === 'unavailable') return data;
+
+  data.byteSize = content.byteSize;
+  data.updatedAt = new Date(content.mtimeMs).toISOString();
+
+  if (content.kind === 'binary') {
+    data.binary = true;
+    delete data.fileContent;
+    delete data.lineCount;
+    delete data.truncated;
+    if (content.mimeType) {
+      data.mimeType = content.mimeType;
+    } else {
+      delete data.mimeType;
+    }
+    return data;
+  }
+
+  data.fileContent = content.text;
+  data.lineCount = content.lineCount;
+  delete data.binary;
+  delete data.mimeType;
+  if (content.truncated) {
+    data.truncated = true;
+  } else {
+    delete data.truncated;
+  }
+  return data;
+}

package/src/server/file-watcher.ts

@@ -6,9 +6,10 @@
  * edits a file, the canvas node updates automatically.
  */
 
-import { watch, existsSync, readFileSync, statSync } from 'node:fs';
+import { watch, existsSync, statSync } from 'node:fs';
 import type { FSWatcher } from 'node:fs';
 import { canvasState } from './canvas-state.js';
+import { applyFileContentToNodeData, readFileNodeContent } from './file-content.js';
 
 function logFileWatcherWarning(action: string, error: unknown, details?: Record<string, unknown>): void {
   console.warn(`[file-watcher] ${action}`, { error, ...(details ?? {}) });
@@ -97,21 +98,17 @@ function handleFileChange(filePath: string): void {
     if (stat.mtimeMs === entry.lastMtime) return;
     entry.lastMtime = stat.mtimeMs;
 
-    const content = readFileSync(filePath, 'utf-8');
-    const lineCount = content.split('\n').length;
-    const updatedAt = new Date(stat.mtimeMs).toISOString();
+    // Shared with node creation, so a file that becomes binary or crosses the
+    // text cap updates the same fields here (and drops stale decoded text).
+    const content = readFileNodeContent(filePath);
+    if (content.kind === 'unavailable') return;
 
     // Update all nodes watching this file
     for (const nodeId of entry.nodeIds) {
       const node = canvasState.getNode(nodeId);
       if (!node) continue;
       canvasState.updateNode(nodeId, {
-        data: {
-          ...node.data,
-          fileContent: content,
-          lineCount,
-          updatedAt,
-        },
+        data: applyFileContentToNodeData({ ...node.data }, content),
       });
       onFileChanged?.(nodeId);
     }