collabmd 0.1.47 → 0.1.49

package/src/client/export/export-pipeline.js

@@ -14,15 +14,18 @@ import {
   sanitizeSvgMarkup,
 } from '../application/preview-diagram-utils.js';
 import { compilePreviewDocument } from '../application/preview-render-compiler.js';
-import { stripVaultFileExtension } from '../../domain/file-kind.js';
-import { parseSceneJson, sceneToInitialData } from '../domain/excalidraw-scene.js';
+import { isMarkdownFilePath, stripVaultFileExtension } from '../../domain/file-kind.js';
+import { resolveVaultRelativePath } from '../../domain/vault-paths.js';
+import { resolveWikiTargetPath } from '../../domain/wiki-link-resolver.js';
+import { createExcalidrawExportOptions, parseSceneJson } from '../domain/excalidraw-scene.js';
 import { escapeHtml } from '../domain/vault-utils.js';
 import { downloadBlob } from '../browser-utils.js';
 import { resolveApiUrl, resolveAppUrl } from '../infrastructure/runtime-config.js';
+import { parseApiResponse } from '../infrastructure/api-client-utils.js';
 
 const EXPORT_PAGE_SOURCE = 'collabmd-export-page';
 const EXPORT_HOST_SOURCE = 'collabmd-export-host';
-const LIGHT_EXPORT_MERMAID_THEME = Object.freeze({
+const EXPORT_MERMAID_CONFIG = Object.freeze({
   htmlLabels: false,
   flowchart: {
     defaultRenderer: 'dagre-wrapper',
@@ -33,7 +36,6 @@ const LIGHT_EXPORT_MERMAID_THEME = Object.freeze({
     useMaxWidth: true,
   },
   startOnLoad: false,
-  theme: 'default',
 });
 const EXPORT_ASSET_FETCH_TIMEOUT_MS = 10_000;
 const EXPORT_ASSET_MAX_BYTES = 10 * 1024 * 1024;
@@ -77,6 +79,10 @@ function createAssetId(prefix = 'asset') {
   return `${prefix}-${assetCounter.toString(36)}`;
 }
 
+function normalizeExportTheme(theme) {
+  return theme === 'dark' ? 'dark' : 'light';
+}
+
 function createDocumentTitle(filePath, title = '') {
   const normalizedTitle = String(title ?? '').trim();
   if (normalizedTitle) {
@@ -87,6 +93,65 @@ function createDocumentTitle(filePath, title = '') {
   return stripVaultFileExtension(leaf) || 'document';
 }
 
+function createDocumentAnchorId(filePath) {
+  return `export-doc-${encodeURIComponent(String(filePath ?? '').toLowerCase()).replace(/%/gu, '-').replace(/\./gu, '-')}`;
+}
+
+function createExportHeadingSlug(value) {
+  return String(value ?? '').trim().toLowerCase().replace(/[^a-z0-9]+/gu, '-').replace(/^-|-$/gu, '');
+}
+
+function rewriteDirectoryDocumentLinks(container, { fileList, sourceFilePath }) {
+  const exportedPaths = new Set(fileList);
+  const sourceAnchorId = createDocumentAnchorId(sourceFilePath);
+
+  Array.from(container.querySelectorAll('[id]')).forEach((element) => {
+    element.id = `${sourceAnchorId}-${element.id}`;
+  });
+
+  Array.from(container.querySelectorAll('a[href]')).forEach((link) => {
+    const rawHref = String(link.getAttribute('href') || '').trim();
+    const wikiTarget = String(link.getAttribute('data-wiki-target') || '').trim();
+    if (wikiTarget) {
+      const [targetPath, targetHeading = ''] = wikiTarget.split('#', 2);
+      const resolved = targetPath ? resolveWikiTargetPath(targetPath, fileList) : sourceFilePath;
+      if (resolved && exportedPaths.has(resolved)) {
+        const headingSlug = createExportHeadingSlug(targetHeading);
+        const targetAnchorId = createDocumentAnchorId(resolved);
+        link.setAttribute('href', headingSlug ? `#${targetAnchorId}-${headingSlug}` : `#${targetAnchorId}`);
+        link.removeAttribute('target');
+        link.removeAttribute('rel');
+      }
+      return;
+    }
+
+    if (!rawHref || /^(?:[a-z][a-z\d+.-]*:|\/\/)/iu.test(rawHref)) {
+      return;
+    }
+
+    if (rawHref.startsWith('#')) {
+      link.setAttribute('href', `#${sourceAnchorId}-${rawHref.slice(1)}`);
+      return;
+    }
+
+    const [pathPart, fragment = ''] = rawHref.split('#', 2);
+    const resolved = resolveVaultRelativePath(sourceFilePath, pathPart);
+    if (!exportedPaths.has(resolved)) {
+      return;
+    }
+
+    const targetAnchorId = createDocumentAnchorId(resolved);
+    link.setAttribute('href', fragment ? `#${targetAnchorId}-${fragment}` : `#${targetAnchorId}`);
+    link.removeAttribute('target');
+    link.removeAttribute('rel');
+  });
+}
+
+function replaceChildrenFromHtml(target, html) {
+  const parsed = new DOMParser().parseFromString(`<body>${String(html ?? '')}</body>`, 'text/html');
+  target.replaceChildren(...parsed.body.childNodes);
+}
+
 function encodeSvgBase64DataUrl(svgMarkup) {
   const bytes = new TextEncoder().encode(String(svgMarkup ?? ''));
   const chunkSize = 0x8000;
@@ -117,7 +182,7 @@ function trimSvgCanvas(svgMarkup, { padding = 16 } = {}) {
   probe.style.top = '0';
   probe.style.visibility = 'hidden';
   probe.style.pointerEvents = 'none';
-  probe.innerHTML = svgMarkup;
+  replaceChildrenFromHtml(probe, svgMarkup);
   document.body.appendChild(probe);
 
   try {
@@ -167,7 +232,7 @@ async function svgMarkupToPngDataUrl(svgMarkup) {
     type: 'image/svg+xml;charset=utf-8',
   }));
   const svgProbe = document.createElement('div');
-  svgProbe.innerHTML = svgMarkup;
+  replaceChildrenFromHtml(svgProbe, svgMarkup);
   const svgElement = svgProbe.querySelector('svg');
 
   try {
@@ -291,11 +356,7 @@ async function fetchJson(url, init = {}) {
     },
     ...init,
   });
-  const data = await response.json().catch(() => null);
-  if (!response.ok) {
-    throw new Error(data?.error || `Request failed: ${response.status}`);
-  }
-  return data;
+  return parseApiResponse(response, `Request failed: ${response.status}`);
 }
 
 async function fetchTextFile(filePath) {
@@ -638,7 +699,7 @@ function createDiagramFigureElement({
   if (svgMarkup) {
     const surface = document.createElement('div');
     surface.className = 'export-diagram-surface';
-    surface.innerHTML = svgMarkup;
+    replaceChildrenFromHtml(surface, svgMarkup);
 
     const svgElement = surface.querySelector('svg');
     if (svgElement) {
@@ -678,7 +739,7 @@ async function ensureMermaidRuntime() {
       throw new Error('Mermaid runtime failed to initialize');
     }
 
-    runtime.initialize(LIGHT_EXPORT_MERMAID_THEME);
+    runtime.initialize({ ...EXPORT_MERMAID_CONFIG, theme: 'default' });
     return runtime;
   });
 
@@ -708,7 +769,10 @@ function prepareMermaidSource(source) {
 
 async function renderMermaidToSvgMarkup(source) {
   const mermaid = await ensureMermaidRuntime();
-  mermaid.initialize(LIGHT_EXPORT_MERMAID_THEME);
+  mermaid.initialize({
+    ...EXPORT_MERMAID_CONFIG,
+    theme: document.documentElement.dataset.theme === 'dark' ? 'dark' : 'default',
+  });
   const renderHost = document.createElement('div');
   renderHost.style.position = 'fixed';
   renderHost.style.left = '-10000px';
@@ -753,17 +817,7 @@ async function renderPlantUmlToSvgMarkup(source) {
 async function renderExcalidrawToSvgMarkup(filePath) {
   const rawScene = await fetchTextFile(filePath);
   const scene = parseSceneJson(rawScene);
-  const initialData = sceneToInitialData(scene, { theme: 'light' });
-  const svgElement = await exportExcalidrawToSvg({
-    appState: {
-      ...initialData.appState,
-      exportBackground: true,
-      exportWithDarkMode: false,
-    },
-    elements: initialData.elements.filter((element) => !element.isDeleted),
-    exportPadding: 24,
-    files: initialData.files || null,
-  });
+  const svgElement = await exportExcalidrawToSvg(createExcalidrawExportOptions(scene));
   return normalizeExportSvgMarkup(svgElement.outerHTML, { padding: 24 });
 }
 
@@ -861,6 +915,97 @@ async function resolveDiagramShell(snapshot, shell, { label, prefix, render }) {
   }));
 }
 
+function getBaseCellText(cell) {
+  if (cell?.text != null) {
+    return String(cell.text);
+  }
+  if (Array.isArray(cell?.value)) {
+    return cell.value.join(', ');
+  }
+  return cell?.value == null ? '' : String(cell.value);
+}
+
+async function resolveBaseEmbed(snapshot, placeholder) {
+  const response = await fetchJson(resolveApiUrl('/base/query'), {
+    body: JSON.stringify({
+      activeFilePath: snapshot.filePath,
+      path: placeholder.dataset.basePath || '',
+      search: '',
+      source: placeholder.dataset.baseSource || null,
+      sourcePath: placeholder.dataset.baseSourcePath || snapshot.filePath,
+      view: placeholder.dataset.baseView || '',
+    }),
+    headers: { 'Content-Type': 'application/json' },
+    method: 'POST',
+  });
+  const result = response.result;
+  if (!result || !Array.isArray(result.columns) || !Array.isArray(result.groups)) {
+    throw new Error('Base query returned no rendered view');
+  }
+
+  // ponytail: static tables preserve base data; share card/list renderers if those export layouts become necessary.
+  if (result.view?.type && result.view.type !== 'table') {
+    snapshot.warnings.push(`Base ${result.view.type} view exported as a static table`);
+  }
+
+  const shell = document.createElement('section');
+  shell.className = 'bases-shell bases-shell-static';
+  const toolbar = document.createElement('header');
+  toolbar.className = 'bases-toolbar';
+  const toolbarMain = document.createElement('div');
+  toolbarMain.className = 'bases-toolbar-main';
+  const title = document.createElement('strong');
+  title.textContent = result.view?.name || 'Base view';
+  const meta = document.createElement('div');
+  meta.className = 'bases-meta';
+  meta.textContent = `${result.totalRows ?? 0} results`;
+  toolbarMain.append(title, meta);
+  toolbar.appendChild(toolbarMain);
+  shell.appendChild(toolbar);
+
+  const content = document.createElement('div');
+  content.className = 'bases-content';
+  result.groups.forEach((group) => {
+    if (result.groups.length > 1) {
+      const heading = document.createElement('h3');
+      heading.textContent = group.label || group.key || 'Group';
+      content.appendChild(heading);
+    }
+    const tableShell = document.createElement('div');
+    tableShell.className = 'bases-table-shell';
+    const table = document.createElement('table');
+    table.className = 'bases-table';
+    const headRow = table.createTHead().insertRow();
+    result.columns.forEach((column) => {
+      const heading = document.createElement('th');
+      heading.scope = 'col';
+      heading.textContent = column.label || column.id || '';
+      headRow.appendChild(heading);
+    });
+    const body = table.createTBody();
+    (group.rows || []).forEach((row) => {
+      const tableRow = body.insertRow();
+      result.columns.forEach((column, columnIndex) => {
+        const cell = tableRow.insertCell();
+        const text = getBaseCellText(row.cells?.[column.id]);
+        if (columnIndex === 0 && row.path) {
+          const link = document.createElement('a');
+          link.href = buildWikiLinkHref(row.path);
+          link.dataset.wikiTarget = row.path;
+          link.textContent = text;
+          cell.appendChild(link);
+        } else {
+          cell.textContent = text;
+        }
+      });
+    });
+    tableShell.appendChild(table);
+    content.appendChild(tableShell);
+  });
+  shell.appendChild(content);
+  placeholder.replaceWith(shell);
+}
+
 async function resolveExcalidrawEmbed(snapshot, placeholder) {
   const target = String(placeholder.dataset.embedTarget ?? '').trim();
   if (!target) {
@@ -1026,6 +1171,20 @@ export async function resolveExportAssets(snapshot, {
     }
   }
 
+  const baseEmbeds = Array.from(container.querySelectorAll('.bases-embed-placeholder[data-base-key]'));
+  for (const placeholder of baseEmbeds) {
+    try {
+      await resolveBaseEmbed(snapshot, placeholder);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      snapshot.warnings.push(`Base export failed: ${message}`);
+      placeholder.replaceWith(Object.assign(document.createElement('p'), {
+        className: 'export-warning',
+        textContent: `Base export failed: ${message}`,
+      }));
+    }
+  }
+
   const excalidrawEmbeds = Array.from(container.querySelectorAll('.excalidraw-embed-placeholder[data-embed-key]'));
   for (const placeholder of excalidrawEmbeds) {
     try {
@@ -1057,9 +1216,11 @@ export async function resolveExportAssets(snapshot, {
 }
 
 export async function prepareExportSnapshot({
+  directoryFileList = [],
   fileList = [],
   filePath,
   markdownText = '',
+  theme = 'light',
   title = '',
 } = {}) {
   const normalizedFilePath = String(filePath ?? '').trim();
@@ -1070,6 +1231,7 @@ export async function prepareExportSnapshot({
     generatedAt: new Date().toISOString(),
     html: '',
     sourceMarkdown: normalizedMarkdown,
+    theme: normalizeExportTheme(theme),
     title: createDocumentTitle(normalizedFilePath, title),
     warnings: [],
   };
@@ -1082,13 +1244,78 @@ export async function prepareExportSnapshot({
   });
   const container = document.createElement('div');
   container.className = 'preview-content export-content';
-  container.innerHTML = compiled.html;
+  replaceChildrenFromHtml(container, compiled.html);
 
   await resolveExportAssets(snapshot, { container });
+  if (directoryFileList.length > 0) {
+    rewriteDirectoryDocumentLinks(container, {
+      fileList: directoryFileList,
+      sourceFilePath: normalizedFilePath,
+    });
+  }
   snapshot.html = container.innerHTML;
   return snapshot;
 }
 
+export async function prepareDirectoryExportSnapshot({
+  currentFilePath = '',
+  currentMarkdownText = '',
+  directoryPath,
+  fileList = [],
+  theme = 'light',
+} = {}) {
+  const normalizedDirectoryPath = String(directoryPath ?? '').replace(/\\/gu, '/').replace(/^\/+|\/+$/gu, '').trim();
+  const directoryPrefix = `${normalizedDirectoryPath}/`;
+  const markdownPaths = fileList
+    .filter((filePath) => isMarkdownFilePath(filePath) && String(filePath).startsWith(directoryPrefix))
+    .sort((left, right) => left.localeCompare(right, undefined, { sensitivity: 'base' }));
+  if (markdownPaths.length === 0) {
+    throw new Error('The selected folder contains no markdown notes');
+  }
+
+  const documents = [];
+  const warnings = [];
+  for (const filePath of markdownPaths) {
+    const markdownText = filePath === currentFilePath
+      ? String(currentMarkdownText ?? '')
+      : await fetchTextFile(filePath);
+    const documentSnapshot = await prepareExportSnapshot({
+      directoryFileList: markdownPaths,
+      fileList,
+      filePath,
+      markdownText,
+      theme,
+    });
+    warnings.push(...documentSnapshot.warnings.map((warning) => `${filePath}: ${warning}`));
+    documents.push(documentSnapshot);
+  }
+
+  const title = createDocumentTitle(normalizedDirectoryPath);
+  const tableOfContents = documents.map((documentSnapshot) => (
+    `<li><a href="#${createDocumentAnchorId(documentSnapshot.filePath)}">${escapeHtml(documentSnapshot.filePath)}</a></li>`
+  )).join('');
+  const html = [
+    `<nav class="export-directory-toc" aria-label="Exported notes"><h1>${escapeHtml(title)}</h1><ol>${tableOfContents}</ol></nav>`,
+    ...documents.map((documentSnapshot) => [
+      `<section class="export-document-section" id="${createDocumentAnchorId(documentSnapshot.filePath)}">`,
+      `<header class="export-document-heading"><h1>${escapeHtml(documentSnapshot.title)}</h1><p>${escapeHtml(documentSnapshot.filePath)}</p></header>`,
+      documentSnapshot.html,
+      '</section>',
+    ].join('')),
+  ].join('');
+
+  return {
+    assets: {},
+    filePath: normalizedDirectoryPath,
+    generatedAt: new Date().toISOString(),
+    html,
+    sourceMarkdown: '',
+    theme: normalizeExportTheme(theme),
+    title,
+    warnings,
+  };
+}
+
 function applyDocxTableStyles(table, {
   borderColor = '#d1d5db',
   cellPadding = '8px 10px',
@@ -1224,12 +1451,7 @@ function createDocxCodeBlockTable(pre) {
     paragraph.style.color = '#111827';
 
     const text = (line || '').replace(/\t/g, '    ');
-    if (!text) {
-      paragraph.innerHTML = '&nbsp;';
-    } else {
-      paragraph.textContent = text;
-      paragraph.innerHTML = paragraph.innerHTML.replace(/ /g, '&nbsp;');
-    }
+    paragraph.textContent = text ? text.replace(/ /gu, '\u00a0') : '\u00a0';
 
     contentNodes.push(paragraph);
   });
@@ -1244,7 +1466,7 @@ function createDocxCodeBlockTable(pre) {
 
 export function buildDocxHtmlDocument(snapshot) {
   const template = document.createElement('template');
-  template.innerHTML = snapshot.html;
+  replaceChildrenFromHtml(template.content, snapshot.html);
 
   Array.from(template.content.querySelectorAll('.table-wrapper')).forEach((wrapper) => {
     const table = wrapper.querySelector(':scope > table');
@@ -1411,20 +1633,21 @@ export function buildDocxHtmlDocument(snapshot) {
 
 export function buildHtmlDocument(snapshot) {
   const template = document.createElement('template');
-  template.innerHTML = snapshot.html;
+  replaceChildrenFromHtml(template.content, snapshot.html);
   Array.from(template.content.querySelectorAll('[data-export-docx-src]')).forEach((element) => {
     element.removeAttribute('data-export-docx-src');
   });
 
+  const theme = normalizeExportTheme(snapshot.theme);
   return `<!DOCTYPE html>
-<html lang="en" data-theme="light">
+<html lang="en" data-theme="${theme}">
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>${escapeHtml(snapshot.title)}</title>
   <style>${HTML_EXPORT_STYLES.replace(/<\/style/giu, '<\\/style')}</style>
 </head>
-<body data-theme="light">
+<body data-theme="${theme}">
   <main class="export-page-shell">
     <article class="preview-content export-content">${template.innerHTML}</article>
   </main>
@@ -1535,11 +1758,11 @@ export function postExportPageMessage(type, payload = {}) {
 }
 
 export async function waitForBootstrapPayload() {
-  const requestUrl = new URL(window.location.href);
-  const requestedAction = requestUrl.searchParams.get('action');
+  const searchParams = new URLSearchParams(window.location.search);
+  const requestedAction = searchParams.get('action');
   const action = ['html', 'pdf'].includes(requestedAction) ? requestedAction : 'docx';
-  const filePath = requestUrl.searchParams.get('file') || '';
-  const jobId = requestUrl.searchParams.get('job') || '';
+  const filePath = searchParams.get('file') || '';
+  const jobId = searchParams.get('job') || window.name || '';
 
   if (jobId && window.opener && !window.opener.closed) {
     postExportPageMessage('ready', { jobId });
@@ -1567,11 +1790,15 @@ export async function waitForBootstrapPayload() {
 
         cleanup();
         resolve({
-          action,
+          action: ['html', 'pdf'].includes(payload.action) ? payload.action : action,
+          currentFilePath: payload.currentFilePath || '',
+          currentMarkdownText: payload.currentMarkdownText || '',
+          directoryPath: payload.directoryPath || '',
           fileList: Array.isArray(payload.fileList) ? payload.fileList : [],
           filePath: payload.filePath || filePath,
-          title: payload.title || '',
           markdownText: payload.markdownText || '',
+          theme: normalizeExportTheme(payload.theme),
+          title: payload.title || '',
         });
       };
 
@@ -1584,6 +1811,7 @@ export async function waitForBootstrapPayload() {
     fileList: [],
     filePath,
     markdownText: filePath ? await fetchTextFile(filePath) : '',
+    theme: 'light',
     title: '',
   };
 }

package/src/client/infrastructure/agent-connection-api-client.js

@@ -0,0 +1,23 @@
+import { resolveApiUrl } from '../domain/runtime-paths.js';
+import { parseApiResponse } from './api-client-utils.js';
+
+export const agentConnectionApiClient = {
+  listConnections() {
+    return fetch(resolveApiUrl('/agent/connections'))
+      .then((response) => parseApiResponse(response, 'Failed to load Agent Connections'));
+  },
+
+  createConnection(payload) {
+    return fetch(resolveApiUrl('/agent/connections'), {
+      body: JSON.stringify(payload),
+      headers: { 'Content-Type': 'application/json' },
+      method: 'POST',
+    }).then((response) => parseApiResponse(response, 'Failed to create Agent Connection'));
+  },
+
+  revokeConnection(connectionId) {
+    return fetch(resolveApiUrl(`/agent/connections/${encodeURIComponent(connectionId)}`), {
+      method: 'DELETE',
+    }).then((response) => parseApiResponse(response, 'Failed to revoke Agent Connection'));
+  },
+};

package/src/client/infrastructure/auth-client.js

@@ -1,6 +1,7 @@
 import '../styles/features/auth-gate.css';
 
 import { getHashParamsFromRaw } from '../domain/hash-routes.js';
+import { parseApiResponse } from './api-client-utils.js';
 import { getRuntimeConfig } from './runtime-config.js';
 
 const DEFAULT_AUTH_CONFIG = {
@@ -66,12 +67,7 @@ async function fetchAuthStatus(config) {
     },
   });
 
-  const payload = await response.json().catch(() => ({}));
-  if (!response.ok) {
-    throw new Error(payload.error || 'Failed to read auth status');
-  }
-
-  return payload;
+  return parseApiResponse(response, 'Failed to read auth status');
 }
 
 function syncOidcIdentityToLocalState(status) {
@@ -100,13 +96,7 @@ async function submitPassword(config, password) {
     },
     body: JSON.stringify({ password }),
   });
-  const payload = await response.json().catch(() => ({}));
-
-  if (!response.ok) {
-    throw new Error(payload.error || 'Authentication failed');
-  }
-
-  return payload;
+  return parseApiResponse(response, 'Authentication failed');
 }
 
 function createOverlayShell() {

package/src/client/infrastructure/editor-session.js

@@ -274,6 +274,10 @@ export class EditorSession {
     this.viewAdapter.requestMeasure();
   }
 
+  formatDocument(filePath) {
+    return this.viewAdapter.formatDocument(filePath);
+  }
+
   runEditorCommand(commandId) {
     return this.viewAdapter.runEditorCommand(commandId);
   }
@@ -286,6 +290,13 @@ export class EditorSession {
     return this.viewAdapter.insertText(text);
   }
 
+  applyTextReplacements(replacements) {
+    if (!this.collaborationClient.initialSyncComplete) {
+      throw new Error('The collaborative document is not synchronized');
+    }
+    return this.viewAdapter.applyTextReplacements(replacements);
+  }
+
   replaceText(text) {
     return this.viewAdapter.replaceText(text);
   }
@@ -302,6 +313,10 @@ export class EditorSession {
     return this.viewAdapter.flashRemoteRange(range);
   }
 
+  isInitialSyncComplete() {
+    return this.collaborationClient.initialSyncComplete;
+  }
+
   waitForInitialSync(timeoutMs = 1500) {
     return this.collaborationClient.waitForInitialSync(timeoutMs);
   }