pmx-canvas 0.1.13 → 0.1.15

package/src/server/diagram-presets.ts

@@ -43,11 +43,13 @@ export const EXCALIDRAW_MCP_TRANSPORT: ExternalMcpTransportConfig = {
 
 export interface DiagramPresetOpenInput {
   elements: unknown;
+  nodeId?: string;
   title?: string;
   x?: number;
   y?: number;
   width?: number;
   height?: number;
+  timeoutMs?: number;
 }
 
 export interface ExcalidrawOpenMcpAppInput {
@@ -55,11 +57,13 @@ export interface ExcalidrawOpenMcpAppInput {
   toolName: string;
   serverName: string;
   toolArguments: { elements: string };
+  nodeId?: string;
   title?: string;
   x?: number;
   y?: number;
   width?: number;
   height?: number;
+  timeoutMs?: number;
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -111,6 +115,21 @@ function finiteNumber(value: unknown): number | null {
   return typeof value === 'number' && Number.isFinite(value) ? value : null;
 }
 
+function positiveFiniteNumber(value: unknown): number | null {
+  const num = finiteNumber(value);
+  return num !== null && num > 0 ? num : null;
+}
+
+function labelFromBoundText(element: Record<string, unknown>): Record<string, unknown> | null {
+  const text = typeof element.text === 'string' ? element.text : '';
+  if (text.trim().length === 0) return null;
+  const fontSize = positiveFiniteNumber(element.fontSize);
+  return {
+    text,
+    ...(fontSize ? { fontSize } : {}),
+  };
+}
+
 function elementHasCameraUpdate(elements: Array<Record<string, unknown>>): boolean {
   return elements.some((element) => element.type === 'cameraUpdate');
 }
@@ -134,39 +153,38 @@ function normalizeExcalidrawBoundText(elements: Array<Record<string, unknown>>):
   }
 
   let changed = false;
-  const boundElementIdsByContainer = new Map<string, Set<string>>();
+  const labelsByContainer = new Map<string, Record<string, unknown>>();
 
   for (const element of elements) {
     if (element.type !== 'text' || typeof element.id !== 'string' || typeof element.containerId !== 'string') continue;
     const container = elementsById.get(element.containerId);
-    if (!container) continue;
-    const ids = boundElementIdsByContainer.get(element.containerId) ?? new Set<string>();
-    ids.add(element.id);
-    boundElementIdsByContainer.set(element.containerId, ids);
+    if (!container || (container.type !== 'rectangle' && container.type !== 'ellipse' && container.type !== 'diamond')) continue;
+    const label = labelFromBoundText(element);
+    if (!label) continue;
+    labelsByContainer.set(element.containerId, label);
   }
 
-  const normalized = elements.map((element) => {
-    if (typeof element.id !== 'string') return element;
-    const boundTextIds = boundElementIdsByContainer.get(element.id);
-    if (!boundTextIds || boundTextIds.size === 0) return element;
-
-    const existing = Array.isArray(element.boundElements)
-      ? element.boundElements.filter(isRecord)
-      : [];
-    const existingTextIds = new Set(
-      existing
-        .filter((boundElement) => boundElement.type === 'text' && typeof boundElement.id === 'string')
-        .map((boundElement) => boundElement.id as string),
-    );
-    const missing = [...boundTextIds].filter((id) => !existingTextIds.has(id));
-    if (missing.length === 0) return element;
+  const normalized: Array<Record<string, unknown>> = [];
+  for (const element of elements) {
+    if (element.type === 'text' && typeof element.containerId === 'string') {
+      if (labelsByContainer.has(element.containerId)) {
+        changed = true;
+        continue;
+      }
+    }
+
+    if (typeof element.id !== 'string' || !labelsByContainer.has(element.id)) {
+      normalized.push(element);
+      continue;
+    }
 
     changed = true;
-    return {
-      ...element,
-      boundElements: [...existing, ...missing.map((id) => ({ type: 'text', id }))],
-    };
-  });
+    const { boundElements: _boundElements, ...container } = element;
+    normalized.push({
+      ...container,
+      label: labelsByContainer.get(element.id),
+    });
+  }
 
   return changed ? normalized : elements;
 }
@@ -333,10 +351,12 @@ export function buildExcalidrawOpenMcpAppInput(input: DiagramPresetOpenInput): E
     serverName: EXCALIDRAW_SERVER_NAME,
     toolArguments: { elements },
   };
+  if (typeof input.nodeId === 'string' && input.nodeId.trim().length > 0) out.nodeId = input.nodeId.trim();
   if (typeof input.title === 'string' && input.title.trim().length > 0) out.title = input.title.trim();
   if (typeof input.x === 'number' && Number.isFinite(input.x)) out.x = input.x;
   if (typeof input.y === 'number' && Number.isFinite(input.y)) out.y = input.y;
   if (typeof input.width === 'number' && Number.isFinite(input.width)) out.width = input.width;
   if (typeof input.height === 'number' && Number.isFinite(input.height)) out.height = input.height;
+  if (typeof input.timeoutMs === 'number' && Number.isFinite(input.timeoutMs) && input.timeoutMs > 0) out.timeoutMs = input.timeoutMs;
   return out;
 }

package/src/server/index.ts

@@ -20,6 +20,7 @@ import {
   fitCanvasView,
   deleteCanvasSnapshot,
   executeCanvasBatch,
+  gcCanvasSnapshots,
   groupCanvasNodes,
   listCanvasSnapshots,
   refreshCanvasWebpageNode,
@@ -33,6 +34,8 @@ import {
   ungroupCanvasNodes,
   validateCanvasNodePatch,
   hasStructuredNodeUpdateFields,
+  hasTraceNodeDataFields,
+  mergeTraceNodeDataFields,
 } from './canvas-operations.js';
 import { validateCanvasLayout } from './canvas-validation.js';
 import { describeCanvasSchema, validateStructuredCanvasPayload } from './canvas-schema.js';
@@ -158,6 +161,12 @@ export class PmxCanvas extends EventEmitter {
     type: CanvasNodeState['type'];
     title?: string;
     content?: string;
+    toolName?: string;
+    category?: string;
+    status?: string;
+    duration?: string;
+    resultSummary?: string;
+    error?: string;
     x?: number;
     y?: number;
     width?: number;
@@ -243,9 +252,10 @@ export class PmxCanvas extends EventEmitter {
       patch.title !== undefined ||
       patch.content !== undefined ||
       typeof patch.arrangeLocked === 'boolean' ||
-      typeof patch.strictSize === 'boolean'
+      typeof patch.strictSize === 'boolean' ||
+      (existing.type === 'trace' && hasTraceNodeDataFields(patch))
     ) {
-      resolvedPatch.data = {
+      const nextData = {
         ...existing.data,
         ...(patch.data && typeof patch.data === 'object' && !Array.isArray(patch.data) ? patch.data : {}),
         ...(typeof patch.title === 'string' ? { title: patch.title } : {}),
@@ -253,6 +263,9 @@ export class PmxCanvas extends EventEmitter {
         ...(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({
@@ -447,8 +460,8 @@ export class PmxCanvas extends EventEmitter {
     return result;
   }
 
-  listSnapshots() {
-    return listCanvasSnapshots();
+  listSnapshots(options?: Parameters<typeof listCanvasSnapshots>[0]) {
+    return listCanvasSnapshots(options);
   }
 
   saveSnapshot(name: string) {
@@ -467,6 +480,10 @@ export class PmxCanvas extends EventEmitter {
     return deleteCanvasSnapshot(id);
   }
 
+  gcSnapshots(options?: Parameters<typeof gcCanvasSnapshots>[0]): ReturnType<typeof gcCanvasSnapshots> {
+    return gcCanvasSnapshots(options);
+  }
+
   diffSnapshot(idOrName: string): { ok: boolean; text?: string; diff?: ReturnType<typeof diffLayouts>; error?: string } {
     const snapData = canvasState.getSnapshotData(idOrName);
     if (!snapData) return { ok: false, error: `Snapshot "${idOrName}" not found` };
@@ -520,21 +537,36 @@ export class PmxCanvas extends EventEmitter {
     transport: ExternalMcpTransportConfig;
     toolName: string;
     toolArguments?: Record<string, unknown>;
+    nodeId?: string;
     serverName?: string;
     title?: string;
     x?: number;
     y?: number;
     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 nodeIdSeed = `ext-app-${toolCallId}`;
+    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;
@@ -566,7 +598,7 @@ export class PmxCanvas extends EventEmitter {
       success: toolResult.isError !== true,
       result: toolResult,
     });
-    const nodeId = this.findCanvasExtAppNodeId(toolCallId);
+    const nodeId = input.nodeId ?? this.findCanvasExtAppNodeId(toolCallId);
     return {
       ok: true,
       ...(nodeId ? { id: nodeId } : {}),
@@ -592,6 +624,31 @@ export class PmxCanvas extends EventEmitter {
     return result;
   }
 
+  addHtmlNode(input: {
+    html: string;
+    title?: string;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    strictSize?: boolean;
+  }): string {
+    const { id } = addCanvasNode({
+      type: 'html',
+      ...(typeof input.title === 'string' ? { title: input.title } : {}),
+      data: { html: input.html },
+      ...(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 } : {}),
+      ...(input.strictSize ? { strictSize: true } : {}),
+      defaultWidth: 720,
+      defaultHeight: 640,
+    });
+    emitPrimaryWorkbenchEvent('canvas-layout-update', { layout: canvasState.getLayout() });
+    return id;
+  }
+
   addGraphNode(input: GraphNodeInput): { id: string; url: string; spec: JsonRenderSpec } {
     const result = createCanvasGraphNode(input);
     emitPrimaryWorkbenchEvent('canvas-layout-update', { layout: canvasState.getLayout() });
@@ -666,7 +723,7 @@ export {
   screenshotCanvasAutomationWebView,
 } from './server.js';
 export { canvasState } from './canvas-state.js';
-export type { CanvasSnapshot } from './canvas-state.js';
+export type { CanvasSnapshot, CanvasSnapshotGcResult, CanvasSnapshotListOptions } from './canvas-state.js';
 export { findOpenCanvasPosition } from './placement.js';
 export { searchNodes, buildSpatialContext, detectClusters, findNeighborhoods } from './spatial-analysis.js';
 export type { SpatialCluster, SpatialContext, SpatialNeighbor, NodeSpatialInfo } from './spatial-analysis.js';

package/src/server/mcp-app-runtime.ts

@@ -12,6 +12,7 @@ import type {
   TextResourceContents,
   Tool,
 } from '@modelcontextprotocol/sdk/types.js';
+import type { RequestOptions } from '@modelcontextprotocol/sdk/shared/protocol.js';
 import {
   EXTENSION_ID,
   RESOURCE_MIME_TYPE,
@@ -47,6 +48,7 @@ export interface OpenMcpAppInput {
   toolName: string;
   toolArguments?: Record<string, unknown>;
   serverName?: string;
+  timeoutMs?: number;
 }
 
 export interface OpenMcpAppResult {
@@ -184,6 +186,12 @@ function normalizeServerName(raw: string | undefined, transport: ExternalMcpTran
   return trimmed.length > 0 ? trimmed : defaultServerName(transport);
 }
 
+function requestOptions(timeoutMs: number | undefined): RequestOptions | undefined {
+  return typeof timeoutMs === 'number' && Number.isFinite(timeoutMs) && timeoutMs > 0
+    ? { timeout: timeoutMs }
+    : undefined;
+}
+
 function buildTransport(config: ExternalMcpTransportConfig): RuntimeTransport {
   if (config.type === 'http') {
     return new StreamableHTTPClientTransport(new URL(config.url), {
@@ -209,15 +217,16 @@ function buildTransport(config: ExternalMcpTransportConfig): RuntimeTransport {
 async function createSession(
   transportConfig: ExternalMcpTransportConfig,
   serverName?: string,
+  timeoutMs?: number,
 ): Promise<McpAppSession> {
   const transport = buildTransport(transportConfig);
   const client = new Client(
     { name: 'pmx-canvas-app-host', version: '0.1.0' },
     { capabilities: clientCapabilities },
   );
-  await client.connect(transport);
+  await client.connect(transport, requestOptions(timeoutMs));
 
-  const toolList = await client.listTools();
+  const toolList = await client.listTools(undefined, requestOptions(timeoutMs));
   const session: McpAppSession = {
     id: randomId('mcp-app-session'),
     serverName: normalizeServerName(serverName, transportConfig),
@@ -350,7 +359,8 @@ function prepareResourceHtml(html: string, meta: McpUiResourceMeta | undefined):
 }
 
 export async function openMcpApp(input: OpenMcpAppInput): Promise<OpenMcpAppResult> {
-  const session = await createSession(input.transport, input.serverName);
+  const options = requestOptions(input.timeoutMs);
+  const session = await createSession(input.transport, input.serverName, input.timeoutMs);
   try {
     const tool = await findTool(session, input.toolName);
     const resourceUri = getToolUiResourceUri(tool);
@@ -362,9 +372,9 @@ export async function openMcpApp(input: OpenMcpAppInput): Promise<OpenMcpAppResu
     const rawToolResult = await session.client.callTool({
       name: tool.name,
       arguments: toolInput,
-    });
+    }, undefined, options);
     const toolResult = normalizeExtAppToolResult({ result: rawToolResult });
-    const readResult = await session.client.readResource({ uri: resourceUri });
+    const readResult = await session.client.readResource({ uri: resourceUri }, options);
     const resourceMeta = resourceMetaFromReadResult(readResult);
     const html = prepareResourceHtml(htmlContentFromReadResult(readResult, resourceUri), resourceMeta);