pmx-canvas 0.1.36 → 0.2.1

package/src/server/index.ts

@@ -31,7 +31,6 @@ import type {
   PmxAxWorkItemStatus,
 } from './ax-state.js';
 import type { AxTimelineQuery } from './canvas-db.js';
-import { findCanvasExtAppNodeId } from './ext-app-lookup.js';
 import { onFileNodeChanged } from './file-watcher.js';
 import { findOpenCanvasPosition, computeGroupBounds } from './placement.js';
 import { searchNodes, buildSpatialContext } from './spatial-analysis.js';
@@ -40,27 +39,18 @@ import { recomputeCodeGraph, buildCodeGraphSummary, formatCodeGraph } from './co
 import {
   addCanvasNode,
   addCanvasEdge,
-  appendCanvasJsonRenderStream,
-  createCanvasStreamingJsonRenderNode,
-  MARKDOWN_NODE_DEFAULT_SIZE,
-  MCP_APP_NODE_DEFAULT_SIZE,
-  IMAGE_NODE_DEFAULT_SIZE,
-  LEDGER_NODE_DEFAULT_SIZE,
   applyCanvasNodeUpdates,
   arrangeCanvasNodes,
   clearCanvas,
   createCanvasGraphNode,
   createCanvasGroup,
   createCanvasJsonRenderNode,
-  buildStructuredNodeUpdate,
   fitCanvasView,
   deleteCanvasSnapshot,
-  executeCanvasBatch,
   gcCanvasSnapshots,
   groupCanvasNodes,
   listCanvasSnapshots,
   refreshCanvasWebpageNode,
-  removeCanvasNode,
   removeCanvasEdge,
   resolveHtmlContent,
   restoreCanvasSnapshot,
@@ -69,11 +59,19 @@ import {
   syncCanvasRuntimeBackends,
   setCanvasContextPins,
   ungroupCanvasNodes,
-  validateCanvasNodePatch,
-  hasStructuredNodeUpdateFields,
-  hasTraceNodeDataFields,
-  mergeTraceNodeDataFields,
 } from './canvas-operations.js';
+import {
+  buildNodePatch,
+  createBasicCanvasNode,
+  removeNodeCore,
+  setGroupChildrenFromApi,
+} from './operations/ops/nodes.js';
+import { streamJsonRenderCore } from './operations/ops/json-render.js';
+import {
+  executeOperation,
+  runCanvasBatchOperation,
+  type OpenMcpAppCoreResult,
+} from './operations/index.js';
 import { validateCanvasLayout } from './canvas-validation.js';
 import { describeCanvasSchema, validateStructuredCanvasPayload } from './canvas-schema.js';
 import { serializeCanvasNode, type SerializedCanvasNode } from './canvas-serialization.js';
@@ -86,13 +84,9 @@ import {
 } from './web-artifacts.js';
 import {
   closeMcpAppSession,
-  openMcpApp as openExternalMcpApp,
   type ExternalMcpTransportConfig,
 } from './mcp-app-runtime.js';
 import {
-  buildExcalidrawOpenMcpAppInput,
-  ensureExcalidrawCheckpointId,
-  isExcalidrawCreateView,
   type DiagramPresetOpenInput,
 } from './diagram-presets.js';
 import {
@@ -259,29 +253,9 @@ export class PmxCanvas extends EventEmitter {
       if (!groupNode) throw new Error(`Group node "${groupId}" was not created.`);
       return toSdkNode(groupNode);
     }
-    const { id, needsCodeGraphRecompute } = addCanvasNode({
-      ...input,
-      defaultWidth: input.type === 'markdown'
-        ? MARKDOWN_NODE_DEFAULT_SIZE.width
-        : input.type === 'mcp-app'
-          ? MCP_APP_NODE_DEFAULT_SIZE.width
-          : input.type === 'image'
-            ? IMAGE_NODE_DEFAULT_SIZE.width
-            : input.type === 'ledger'
-              ? LEDGER_NODE_DEFAULT_SIZE.width
-              : 360,
-      defaultHeight: input.type === 'markdown'
-        ? MARKDOWN_NODE_DEFAULT_SIZE.height
-        : input.type === 'mcp-app'
-          ? MCP_APP_NODE_DEFAULT_SIZE.height
-          : input.type === 'image'
-            ? IMAGE_NODE_DEFAULT_SIZE.height
-            : input.type === 'ledger'
-              ? LEDGER_NODE_DEFAULT_SIZE.height
-              : 200,
-      fileMode: 'path',
-      ...(input.strictSize ? { strictSize: true } : {}),
-    });
+    // Thin wrapper over the shared operation core (plan-005); the SDK keeps
+    // fileMode 'path' as an explicit visible parameter instead of forked code.
+    const { node, needsCodeGraphRecompute } = createBasicCanvasNode(input, { fileMode: 'path' });
 
     emitPrimaryWorkbenchEvent('canvas-layout-update', { layout: canvasState.getLayout() });
 
@@ -291,8 +265,6 @@ export class PmxCanvas extends EventEmitter {
       });
     }
 
-    const node = canvasState.getNode(id);
-    if (!node) throw new Error(`Node "${id}" was not created.`);
     return toSdkNode(node);
   }
 
@@ -339,58 +311,18 @@ export class PmxCanvas extends EventEmitter {
   updateNode(id: string, patch: Partial<CanvasNodeState> & Record<string, unknown>): void {
     const existing = canvasState.getNode(id);
     if (!existing) return;
-    const resolvedPatch: Partial<CanvasNodeState> = {};
-    if (patch.position) resolvedPatch.position = patch.position;
-    if (patch.size) resolvedPatch.size = patch.size;
-    if (patch.collapsed !== undefined) resolvedPatch.collapsed = patch.collapsed;
-    if (patch.pinned !== undefined) resolvedPatch.pinned = patch.pinned;
-    if (patch.dockPosition !== undefined) resolvedPatch.dockPosition = patch.dockPosition;
-
-    if (hasStructuredNodeUpdateFields(patch)) {
-      resolvedPatch.data = buildStructuredNodeUpdate(existing, patch).data;
-    } else if (
-      patch.data !== undefined ||
-      patch.title !== undefined ||
-      patch.content !== undefined ||
-      typeof patch.arrangeLocked === 'boolean' ||
-      typeof patch.strictSize === 'boolean' ||
-      (existing.type === 'trace' && hasTraceNodeDataFields(patch))
-    ) {
-      const nextData = {
-        ...existing.data,
-        ...(patch.data && typeof patch.data === 'object' && !Array.isArray(patch.data) ? patch.data : {}),
-        ...(typeof patch.title === 'string' ? { title: patch.title } : {}),
-        ...(typeof patch.content === 'string' ? { content: patch.content } : {}),
-        ...(typeof patch.arrangeLocked === 'boolean' ? { arrangeLocked: patch.arrangeLocked } : {}),
-        ...(typeof patch.strictSize === 'boolean' ? { strictSize: patch.strictSize } : {}),
-      };
-      resolvedPatch.data = existing.type === 'trace'
-        ? mergeTraceNodeDataFields(nextData, patch)
-        : nextData;
-    }
-
-    const error = validateCanvasNodePatch({
-      ...(resolvedPatch.position ? { position: resolvedPatch.position } : {}),
-      ...(resolvedPatch.size ? { size: resolvedPatch.size } : {}),
-    });
-    if (error) {
-      throw new Error(error);
-    }
+    // Thin wrapper over the shared patch core (plan-005): the SDK now carries
+    // the same superset semantics as HTTP/MCP (webpage titleSource/url, html
+    // top-level fields, axCapabilities merge, group children).
+    const { patch: resolvedPatch, groupChildIds } = buildNodePatch(existing, patch);
     canvasState.updateNode(id, resolvedPatch);
+    if (groupChildIds !== undefined) setGroupChildrenFromApi(id, groupChildIds);
     emitPrimaryWorkbenchEvent('canvas-layout-update', { layout: canvasState.getLayout() });
   }
 
+  /** Remove a node. Missing id throws (plan-005 unifies this across surfaces). */
   removeNode(id: string): void {
-    const existing = canvasState.getNode(id);
-    const appSessionId =
-      existing?.type === 'mcp-app' && typeof existing.data.appSessionId === 'string'
-        ? existing.data.appSessionId
-        : null;
-    if (appSessionId) {
-      closeMcpAppSession(appSessionId);
-    }
-    const { removed, needsCodeGraphRecompute } = removeCanvasNode(id);
-    if (!removed) return;
+    const { needsCodeGraphRecompute } = removeNodeCore(id);
     emitPrimaryWorkbenchEvent('canvas-layout-update', { layout: canvasState.getLayout() });
 
     if (needsCodeGraphRecompute) {
@@ -930,13 +862,6 @@ export class PmxCanvas extends EventEmitter {
     return validateCanvasLayout(canvasState.getLayout());
   }
 
-  private findCanvasExtAppNodeId(toolCallId: string): string | null {
-    return findCanvasExtAppNodeId(toolCallId, {
-      getNode: (id) => canvasState.getNode(id),
-      listNodes: () => canvasState.getLayout().nodes,
-    });
-  }
-
   describeSchema() {
     return describeCanvasSchema();
   }
@@ -950,14 +875,22 @@ export class PmxCanvas extends EventEmitter {
   }
 
   async runBatch(operations: Array<{ op: string; assign?: string; args?: Record<string, unknown> }>) {
-    const result = await executeCanvasBatch(operations);
-    emitPrimaryWorkbenchEvent('canvas-layout-update', { layout: canvasState.getLayout() });
-    return result;
+    // Delegates to the canvas.batch registry meta-op (plan-008 Wave 2). The op
+    // emits the single final canvas-layout-update itself (via the registry
+    // emitter, which server.ts wires to emitPrimaryWorkbenchEvent) — do NOT
+    // emit again here or the frame would fire twice.
+    return await runCanvasBatchOperation(operations);
   }
 
   async buildWebArtifact(
-    input: WebArtifactBuildInput & { openInCanvas?: boolean },
+    input: WebArtifactBuildInput & { openInCanvas?: boolean; includeLogs?: boolean },
   ): Promise<WebArtifactCanvasBuildResult> {
+    // The registry's webartifact.build op wraps buildWebArtifactOnCanvas and
+    // returns a wire ENVELOPE (path/bytes/…); the SDK's documented return is the
+    // full WebArtifactCanvasBuildResult, so the SDK calls the build runtime
+    // directly here (the op core is the same buildWebArtifactOnCanvas; the node
+    // creation emits its own canvas-layout-update). The op and the SDK share the
+    // single build runtime — no behavior divergence.
     return buildWebArtifactOnCanvas(input);
   }
 
@@ -973,75 +906,21 @@ export class PmxCanvas extends EventEmitter {
     width?: number;
     height?: number;
     timeoutMs?: number;
-  }): Promise<{ ok: true; id?: string; nodeId: string | null; toolCallId: string; sessionId: string; resourceUri: string }> {
-    const targetNode = input.nodeId ? canvasState.getNode(input.nodeId) : undefined;
-    if (input.nodeId && !targetNode) {
-      throw new Error(`Node "${input.nodeId}" not found.`);
-    }
-    if (targetNode && (targetNode.type !== 'mcp-app' || targetNode.data.mode !== 'ext-app')) {
-      throw new Error(`Node "${input.nodeId}" is not an external app node.`);
-    }
-
-    const opened = await openExternalMcpApp({
-      transport: input.transport,
-      toolName: input.toolName,
-      ...(input.toolArguments ? { toolArguments: input.toolArguments } : {}),
-      ...(input.serverName ? { serverName: input.serverName } : {}),
-      ...(typeof input.timeoutMs === 'number' ? { timeoutMs: input.timeoutMs } : {}),
-    });
-    const toolCallId = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-    const previousSessionId = targetNode?.data.appSessionId;
-    if (typeof previousSessionId === 'string' && previousSessionId.trim().length > 0) {
-      closeMcpAppSession(previousSessionId);
-    }
-    const nodeIdSeed = input.nodeId ?? `ext-app-${toolCallId}`;
-    const toolResult = isExcalidrawCreateView(opened.serverName, opened.toolName)
-      ? ensureExcalidrawCheckpointId(opened.toolResult, nodeIdSeed)
-      : opened.toolResult;
-    emitPrimaryWorkbenchEvent('ext-app-open', {
-      toolCallId,
-      nodeId: nodeIdSeed,
-      title: input.title ?? opened.tool.title ?? opened.tool.name,
-      html: opened.html,
-      toolInput: opened.toolInput,
-      serverName: opened.serverName,
-      toolName: opened.toolName,
-      appSessionId: opened.sessionId,
-      transportConfig: input.transport,
-      resourceUri: opened.resourceUri,
-      toolDefinition: opened.tool,
-      sessionStatus: 'ready',
-      sessionError: null,
-      ...(opened.resourceMeta ? { resourceMeta: opened.resourceMeta } : {}),
-      ...(typeof input.x === 'number' ? { x: input.x } : {}),
-      ...(typeof input.y === 'number' ? { y: input.y } : {}),
-      ...(typeof input.width === 'number' ? { width: input.width } : {}),
-      ...(typeof input.height === 'number' ? { height: input.height } : {}),
-    });
-    emitPrimaryWorkbenchEvent('ext-app-result', {
-      toolCallId,
-      nodeId: nodeIdSeed,
-      serverName: opened.serverName,
-      toolName: opened.toolName,
-      success: toolResult.isError !== true,
-      result: toolResult,
-    });
-    const nodeId = input.nodeId ?? this.findCanvasExtAppNodeId(toolCallId);
-    return {
-      ok: true,
-      ...(nodeId ? { id: nodeId } : {}),
-      nodeId,
-      toolCallId,
-      sessionId: opened.sessionId,
-      resourceUri: opened.resourceUri,
-    };
+  }): Promise<OpenMcpAppCoreResult> {
+    // Delegate to the mcpapp.open registry op (plan-008 Wave 4). The op handler
+    // is the relocated legacy body (toolCallId, openExternalMcpApp, prior-session
+    // close, ext-app-open + ext-app-result via ctx.emit → the registry emitter
+    // wired to emitPrimaryWorkbenchEvent). mutates:false, so the registry adds no
+    // canvas-layout-update; the two ext-app-* frames fire exactly once.
+    return await executeOperation('mcpapp.open', input) as OpenMcpAppCoreResult;
   }
 
   async addDiagram(
     input: DiagramPresetOpenInput,
-  ): Promise<{ ok: true; id?: string; nodeId: string | null; toolCallId: string; sessionId: string; resourceUri: string }> {
-    const built = buildExcalidrawOpenMcpAppInput(input);
-    return this.openMcpApp(built);
+  ): Promise<OpenMcpAppCoreResult> {
+    // Delegate to the diagram.open registry op, which builds the Excalidraw
+    // OpenMcpApp input and dispatches to the shared open core (one ext-app-* pair).
+    return await executeOperation('diagram.open', input) as OpenMcpAppCoreResult;
   }
 
   addJsonRenderNode(
@@ -1077,32 +956,17 @@ export class PmxCanvas extends EventEmitter {
     elementCount: number;
     streamStatus: 'open' | 'closed';
   } {
-    let nodeId = input.nodeId;
-    let url = '';
-    if (!nodeId) {
-      const created = createCanvasStreamingJsonRenderNode({
-        ...(input.title !== undefined ? { title: input.title } : {}),
-        ...(input.x !== undefined ? { x: input.x } : {}),
-        ...(input.y !== undefined ? { y: input.y } : {}),
-        ...(input.width !== undefined ? { width: input.width } : {}),
-        ...(input.height !== undefined ? { height: input.height } : {}),
-        ...(input.strictSize ? { strictSize: true } : {}),
-      });
-      nodeId = created.id;
-      url = created.url;
-    } else {
-      url = String(canvasState.getNode(nodeId)?.data.url ?? '');
-    }
-    const result = appendCanvasJsonRenderStream(
-      nodeId,
-      Array.isArray(input.patches) ? input.patches : [],
-      input.done === true,
-    );
-    if (!result.ok) throw new Error(result.error);
+    // Thin wrapper over the shared create-or-append core (plan-005). The op
+    // handler and this SDK method now share one implementation; the SDK emits
+    // the layout update itself (it does not flow through the registry's
+    // `mutates` path). `streamJsonRenderCore` throws OperationError (an Error
+    // subclass with the same message) on a bad append target. The core's
+    // result carries an extra `ok: true`; the SDK's wire shape omits it.
+    const result = streamJsonRenderCore(input);
     emitPrimaryWorkbenchEvent('canvas-layout-update', { layout: canvasState.getLayout() });
     return {
-      id: nodeId,
-      url,
+      id: result.id,
+      url: result.url,
       applied: result.applied,
       skipped: result.skipped,
       specVersion: result.specVersion,