collabmd 0.1.47 → 0.1.49

package/src/client/infrastructure/vault-api-client.js

@@ -26,21 +26,30 @@ async function triggerDownload(url, {
   return response;
 }
 
-export class VaultApiClient {
+export const vaultApiClient = {
   async readTree() {
     const response = await fetch(resolveApiUrl('/files'));
     return parseApiResponse(response, 'Failed to load file tree');
-  }
+  },
+  async callAgentTool(name, input, { signal } = {}) {
+    const response = await fetch(resolveApiUrl(`/agent/tools/${encodeURIComponent(name)}`), {
+      body: JSON.stringify(input),
+      headers: { 'Content-Type': 'application/json' },
+      method: 'POST',
+      signal,
+    });
+    return parseApiResponse(response, `Failed to execute ${name}`);
+  },
 
   async readCommentOverview() {
     const response = await fetch(resolveApiUrl('/comments/overview'));
     return parseApiResponse(response, 'Failed to load comment overview');
-  }
+  },
 
   async readFile(path) {
     const response = await fetch(resolveApiUrl(`/file?path=${encodeURIComponent(path)}`));
     return parseApiResponse(response, 'Failed to read file');
-  }
+  },
 
   async readBacklinks(filePath, { signal } = {}) {
     const response = await fetch(
@@ -49,7 +58,7 @@ export class VaultApiClient {
     );
     const data = await parseApiResponse(response, 'Failed to load backlinks');
     return Array.isArray(data.backlinks) ? data.backlinks : [];
-  }
+  },
 
   async syncStructurizrWorkspace({ path, source }) {
     const response = await fetch(resolveApiUrl('/structurizr/sync'), {
@@ -63,7 +72,7 @@ export class VaultApiClient {
       method: 'POST',
     });
     return parseApiResponse(response, 'Failed to sync Structurizr workspace');
-  }
+  },
 
   async renderSvg(source) {
     const response = await fetch(resolveApiUrl('/plantuml/render'), {
@@ -79,7 +88,7 @@ export class VaultApiClient {
     }
 
     return data.svg;
-  }
+  },
 
   async searchText({ limit = 50, query = '', signal = null } = {}) {
     const searchParams = new URLSearchParams({
@@ -90,7 +99,7 @@ export class VaultApiClient {
       signal,
     });
     return parseApiResponse(response, 'Failed to search files');
-  }
+  },
 
   async queryBase({
     activeFilePath = '',
@@ -113,7 +122,7 @@ export class VaultApiClient {
       method: 'POST',
     });
     return parseApiResponse(response, 'Failed to query base');
-  }
+  },
 
   async exportBaseCsv({
     activeFilePath = '',
@@ -144,7 +153,7 @@ export class VaultApiClient {
       blob: await response.blob(),
       contentDisposition: response.headers.get('content-disposition') || '',
     };
-  }
+  },
 
   async queryBasePropertyValues({
     activeFilePath = '',
@@ -169,7 +178,7 @@ export class VaultApiClient {
       method: 'POST',
     });
     return parseApiResponse(response, 'Failed to load base property values');
-  }
+  },
 
   async transformBase({
     activeFilePath = '',
@@ -192,7 +201,7 @@ export class VaultApiClient {
       method: 'POST',
     });
     return parseApiResponse(response, 'Failed to transform base');
-  }
+  },
 
   async createFile({ content, path, requestId = null }) {
     const response = await fetch(resolveApiUrl('/file'), {
@@ -201,7 +210,7 @@ export class VaultApiClient {
       method: 'POST',
     });
     return parseApiResponse(response, 'Failed to create file');
-  }
+  },
 
   async writeFile({ content, path, requestId = null }) {
     const response = await fetch(resolveApiUrl('/file'), {
@@ -210,7 +219,7 @@ export class VaultApiClient {
       method: 'PUT',
     });
     return parseApiResponse(response, 'Failed to write file');
-  }
+  },
 
   async renameFile({ oldPath, newPath, requestId = null }) {
     const response = await fetch(resolveApiUrl('/file'), {
@@ -219,7 +228,7 @@ export class VaultApiClient {
       method: 'PATCH',
     });
     return parseApiResponse(response, 'Failed to rename file');
-  }
+  },
 
   async deleteFile(path, { requestId = null } = {}) {
     const response = await fetch(resolveApiUrl(`/file?path=${encodeURIComponent(path)}`), {
@@ -227,7 +236,7 @@ export class VaultApiClient {
       method: 'DELETE',
     });
     return parseApiResponse(response, 'Failed to delete file');
-  }
+  },
 
   async createDirectory(path, { requestId = null } = {}) {
     const response = await fetch(resolveApiUrl('/directory'), {
@@ -236,7 +245,7 @@ export class VaultApiClient {
       method: 'POST',
     });
     return parseApiResponse(response, 'Failed to create folder');
-  }
+  },
 
   async renameDirectory({ oldPath, newPath, requestId = null }) {
     const response = await fetch(resolveApiUrl('/directory'), {
@@ -245,7 +254,7 @@ export class VaultApiClient {
       method: 'PATCH',
     });
     return parseApiResponse(response, 'Failed to rename folder');
-  }
+  },
 
   async deleteDirectory(path, { recursive = false, requestId = null } = {}) {
     const searchParams = new URLSearchParams({
@@ -260,7 +269,7 @@ export class VaultApiClient {
       method: 'DELETE',
     });
     return parseApiResponse(response, 'Failed to delete folder');
-  }
+  },
 
   async uploadImageAttachment({ file, fileName = '', sourcePath }) {
     const response = await fetch(resolveApiUrl('/attachments'), {
@@ -273,7 +282,7 @@ export class VaultApiClient {
       method: 'POST',
     });
     return parseApiResponse(response, 'Failed to upload image');
-  }
+  },
 
   async uploadFile({ file, path, requestId = null }) {
     const response = await fetch(resolveApiUrl('/file/upload'), {
@@ -285,7 +294,7 @@ export class VaultApiClient {
       method: 'POST',
     });
     return parseApiResponse(response, 'Failed to upload file');
-  }
+  },
 
   async downloadFile(path) {
     const fallbackFileName = getVaultPathLeaf(path) || 'download';
@@ -293,7 +302,7 @@ export class VaultApiClient {
       fallbackError: 'Failed to download file',
       fallbackFileName,
     });
-  }
+  },
 
   async downloadDirectory(path) {
     const directoryName = getVaultPathLeaf(path) || 'vault';
@@ -301,7 +310,5 @@ export class VaultApiClient {
       fallbackError: 'Failed to download folder',
       fallbackFileName: `${directoryName}.zip`,
     });
-  }
-}
-
-export const vaultApiClient = new VaultApiClient();
+  },
+};

package/src/client/infrastructure/webmcp-tool-registry.js

@@ -0,0 +1,283 @@
+import {
+  listWebMcpToolDefinitions,
+  toWebMcpToolName,
+} from '../../domain/agent-tool-definitions.js';
+import { createExcalidrawExportOptions } from '../domain/excalidraw-scene.js';
+
+const MAX_RENDER_DIMENSION = 4096;
+const ACTIVE_CONTEXT_TOOL_NAME = 'collabmd_get_active_context';
+const EXCALIDRAW_WORKFLOW_NOTE = 'Call collabmd_get_active_context first. Use create_excalidraw only for a new path; for an existing diagram, inspect_excalidraw then edit_excalidraw with its exact revision and inline verification.';
+
+async function renderExactExcalidrawScene(scene, {
+  format = 'png',
+  padding = 32,
+  scale = 1,
+} = {}) {
+  const {
+    exportToBlob,
+    exportToSvg,
+  } = await import('@excalidraw/excalidraw');
+  const options = createExcalidrawExportOptions(scene, { padding, scale });
+  let data;
+  let height;
+  let mimeType;
+  let width;
+  if (format === 'svg') {
+    const svg = await exportToSvg(options);
+    const markup = svg.outerHTML;
+    data = new TextEncoder().encode(markup).toBase64();
+    height = Math.max(1, Math.ceil(Number.parseFloat(svg.getAttribute('height')) || 1));
+    mimeType = 'image/svg+xml';
+    width = Math.max(1, Math.ceil(Number.parseFloat(svg.getAttribute('width')) || 1));
+  } else {
+    const blob = await exportToBlob({
+      ...options,
+      maxWidthOrHeight: MAX_RENDER_DIMENSION,
+      mimeType: 'image/png',
+    });
+    const bitmap = await createImageBitmap(blob);
+    data = new Uint8Array(await blob.arrayBuffer()).toBase64();
+    height = bitmap.height;
+    mimeType = 'image/png';
+    width = bitmap.width;
+    bitmap.close();
+  }
+  return {
+    format,
+    height,
+    image: { data, encoding: 'base64', mimeType },
+    mimeType,
+    renderer: 'excalidraw-official-browser',
+    rendererVersion: 'bundled',
+    scale,
+    warnings: [],
+    width,
+  };
+}
+
+function stripSceneSnapshots(result) {
+  if (!result || typeof result !== 'object') return result;
+  const cleanResult = { ...result };
+  delete cleanResult.scene;
+  if (!cleanResult.verification?.scene) return cleanResult;
+  const verification = { ...cleanResult.verification };
+  delete verification.scene;
+  return { ...cleanResult, verification };
+}
+
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw signal.reason ?? new DOMException('Tool execution was cancelled', 'AbortError');
+  }
+}
+
+async function replaceSnapshotRendering(result, renderScene, input = {}) {
+  const scene = result?.verification?.scene ?? result?.scene;
+  if (!scene) return result;
+  const renderOptions = {
+    ...(result.verification?.scene ? input.verify : input),
+    ...(result.verification?.scene ? result.verification : result),
+  };
+  try {
+    const rendered = await renderScene(scene, renderOptions);
+    const cleanResult = stripSceneSnapshots(result);
+    if (result.verification?.scene) {
+      const { image, ...metadata } = rendered;
+      return {
+        ...cleanResult,
+        image,
+        verification: {
+          ...cleanResult.verification,
+          ...metadata,
+        },
+      };
+    }
+    return {
+      ...cleanResult,
+      ...rendered,
+    };
+  } catch (error) {
+    console.error('[webmcp] Exact Excalidraw rendering failed:', error.message);
+    const cleanResult = stripSceneSnapshots(result);
+    if (result?.verification?.scene) {
+      return {
+        ...cleanResult,
+        verification: {
+          ...cleanResult.verification,
+          warnings: [...(cleanResult.verification?.warnings ?? []), 'exact-render-unavailable'],
+        },
+      };
+    }
+    return {
+      ...cleanResult,
+      warnings: [...(cleanResult.warnings ?? []), 'exact-render-unavailable'],
+    };
+  }
+}
+
+function addWebMcpExecution(result, execution) {
+  if (!execution || Object.keys(execution).length === 0 || !result || typeof result !== 'object') {
+    return result;
+  }
+  return { ...result, webMcp: execution };
+}
+
+function createActiveContextResult(context = {}) {
+  const activeDiagramPath = context.activeDiagramPath || null;
+  const activePath = context.activePath || null;
+  return {
+    activeDiagramPath,
+    activePath,
+    preferredDiagramPath: activeDiagramPath,
+    workflow: activeDiagramPath
+      ? `Current diagram is ${activeDiagramPath}. Inspect it, edit with the returned exact revision, request inline verification, then use the returned canvas paint acknowledgement.`
+      : 'No diagram is active. Use create_excalidraw with a new .excalidraw path and request inline verification. Inspect then revision-edit any existing path; do not retry stale edits without rereading.',
+  };
+}
+
+function getWebMcpDescription(definition) {
+  return definition.name.includes('excalidraw')
+    ? `${definition.description} ${EXCALIDRAW_WORKFLOW_NOTE}`
+    : definition.description;
+}
+
+function runOptionalHook(hook, payload) {
+  return typeof hook === 'function' ? hook(payload) : null;
+}
+
+async function runAcknowledgementHook(hook, payload) {
+  try {
+    return await runOptionalHook(hook, payload);
+  } catch (error) {
+    console.error('[webmcp] Failed to acknowledge an applied mutation:', error.message);
+    return { status: 'unavailable' };
+  }
+}
+
+function createActiveContextTool(getActiveContext) {
+  return {
+    annotations: {
+      readOnlyHint: true,
+      untrustedContentHint: false,
+    },
+    description: 'Return current CollabMD file and active-diagram context plus the safe create-or-edit workflow. Call before Excalidraw tools.',
+    execute: async () => createActiveContextResult(getActiveContext?.()),
+    inputSchema: {
+      additionalProperties: false,
+      properties: {},
+      required: [],
+      type: 'object',
+    },
+    name: ACTIVE_CONTEXT_TOOL_NAME,
+  };
+}
+
+
+export class WebMcpToolRegistry {
+  constructor({
+    acknowledgeToolCall = null,
+    callTool,
+    getActiveContext = null,
+    getIsTabActive,
+    modelContext = globalThis.document?.modelContext ?? null,
+    onDidMutate = null,
+    prepareToolCall = null,
+    renderExcalidrawScene = renderExactExcalidrawScene,
+  }) {
+    this.acknowledgeToolCall = acknowledgeToolCall;
+    this.callTool = callTool;
+    this.getActiveContext = getActiveContext;
+    this.getIsTabActive = getIsTabActive;
+    this.modelContext = modelContext;
+    this.onDidMutate = onDidMutate;
+    this.prepareToolCall = prepareToolCall;
+    this.renderExcalidrawScene = renderExcalidrawScene;
+    this.registration = null;
+  }
+
+  async refresh() {
+    if (
+      typeof this.modelContext?.registerTool !== 'function'
+      || typeof this.callTool !== 'function'
+      || !this.getIsTabActive()
+    ) {
+      this.unregister();
+      return false;
+    }
+    if (this.registration) return true;
+
+    const controller = new AbortController();
+    const registration = { controller };
+    this.registration = registration;
+
+    try {
+      const tools = listWebMcpToolDefinitions().map((definition) => ({
+        annotations: {
+          readOnlyHint: definition.annotations.readOnlyHint,
+          untrustedContentHint: Boolean(definition.untrustedContentHint),
+        },
+        description: getWebMcpDescription(definition),
+        execute: async (input = {}, { signal } = {}) => {
+          throwIfAborted(signal);
+          let preparation = null;
+          if (typeof this.prepareToolCall === 'function') {
+            preparation = await this.prepareToolCall({
+              input,
+              name: definition.name,
+              signal,
+            });
+            throwIfAborted(signal);
+          }
+          const serverResult = await this.callTool(definition.name, input, { signal });
+          let result = await replaceSnapshotRendering(
+            serverResult,
+            this.renderExcalidrawScene,
+            input,
+          );
+          throwIfAborted(signal);
+          const execution = preparation ? { preparation } : {};
+          if (!definition.annotations.readOnlyHint) {
+            const acknowledgement = await runAcknowledgementHook(this.acknowledgeToolCall, {
+              input,
+              name: definition.name,
+              preparation,
+              result,
+              signal,
+            });
+            if (acknowledgement) execution.acknowledgement = acknowledgement;
+            result = addWebMcpExecution(result, execution);
+            try {
+              this.onDidMutate?.({ name: definition.name, result });
+            } catch (error) {
+              console.error('[webmcp] Failed to report an applied mutation:', error.message);
+            }
+          } else {
+            result = addWebMcpExecution(result, execution);
+          }
+          return result;
+        },
+        inputSchema: definition.inputSchema,
+        name: toWebMcpToolName(definition.name),
+      }));
+      tools.push(createActiveContextTool(this.getActiveContext));
+      await Promise.all(tools.map((tool) => (
+        this.modelContext.registerTool(tool, { signal: controller.signal })
+      )));
+      return true;
+    } catch (error) {
+      if (!controller.signal.aborted) {
+        controller.abort();
+        console.error('[webmcp] Failed to register tools:', error.message);
+      }
+      if (this.registration === registration) {
+        this.registration = null;
+      }
+      return false;
+    }
+  }
+
+  unregister() {
+    this.registration?.controller.abort();
+    this.registration = null;
+  }
+}

package/src/client/infrastructure/workspace-sync-client.js

@@ -342,10 +342,12 @@ export class WorkspaceSyncClient {
   }
 
   disconnect() {
-    this.entries.unobserve(this.handleEntriesChange);
-    this.events.unobserve(this.handleEventsChange);
-    this.provider?.disconnect();
-    this.provider?.destroy();
+    if (this.provider) {
+      this.entries.unobserve(this.handleEntriesChange);
+      this.events.unobserve(this.handleEventsChange);
+      this.provider.disconnect();
+      this.provider.destroy();
+    }
     this.provider = null;
     this._didInitialSync = false;
     this.seenEventIds.clear();