collabmd 0.1.18

package/src/client/domain/room.js

@@ -0,0 +1,49 @@
+const USER_NAMES = [
+  'Alice', 'Bob', 'Charlie', 'Dana', 'Eve', 'Frank', 'Grace', 'Hank', 'Iris', 'Jack',
+  'Kim', 'Leo', 'Maya', 'Nate', 'Olivia', 'Pete', 'Quinn', 'Ruby', 'Sam', 'Tara',
+];
+const USER_COLORS = [
+  '#ef4444', '#f97316', '#eab308', '#22c55e', '#06b6d4',
+  '#3b82f6', '#8b5cf6', '#ec4899', '#14b8a6', '#f59e0b',
+  '#6366f1', '#10b981', '#f43f5e', '#0ea5e9', '#a855f7',
+];
+export const USER_NAME_MAX_LENGTH = 24;
+
+function pickRandom(items) {
+  return items[Math.floor(Math.random() * items.length)];
+}
+
+function generatePeerId() {
+  const array = new Uint8Array(8);
+  (globalThis.crypto ?? {}).getRandomValues?.(array);
+  return Array.from(array, (b) => b.toString(16).padStart(2, '0')).join('');
+}
+
+// A stable peer ID for this browser tab, shared across lobby and per-file sessions.
+let _localPeerId = null;
+
+export function getLocalPeerId() {
+  if (!_localPeerId) {
+    _localPeerId = generatePeerId();
+  }
+  return _localPeerId;
+}
+
+export function normalizeUserName(value) {
+  const normalized = String(value ?? '')
+    .trim()
+    .replace(/\s+/g, ' ')
+    .slice(0, USER_NAME_MAX_LENGTH);
+  return normalized || null;
+}
+
+export function createRandomUser(preferredName = null) {
+  const color = pickRandom(USER_COLORS);
+
+  return {
+    color,
+    colorLight: `${color}33`,
+    name: normalizeUserName(preferredName) ?? pickRandom(USER_NAMES),
+    peerId: getLocalPeerId(),
+  };
+}

package/src/client/domain/runtime-paths.js

@@ -0,0 +1,136 @@
+function trimTrailingSlash(value) {
+  return value.endsWith('/') ? value.slice(0, -1) : value;
+}
+
+function normalizeBasePath(value) {
+  const normalized = trimTrailingSlash(String(value ?? '').trim());
+  if (!normalized || normalized === '/') {
+    return '';
+  }
+
+  if (/^[a-zA-Z][a-zA-Z\d+.-]*:/u.test(normalized)) {
+    try {
+      return normalizeBasePath(new URL(normalized).pathname);
+    } catch {
+      return '';
+    }
+  }
+
+  return normalized.startsWith('/') ? normalized : `/${normalized}`;
+}
+
+function normalizeRoutePath(value, fallbackPath) {
+  const normalized = trimTrailingSlash(String(value ?? '').trim());
+  if (!normalized || normalized === '/') {
+    return fallbackPath;
+  }
+
+  return normalized.startsWith('/') ? normalized : `/${normalized}`;
+}
+
+function applyBasePath(basePath, pathValue) {
+  const normalizedBasePath = normalizeBasePath(basePath);
+  const normalizedPath = String(pathValue ?? '').trim();
+
+  if (!normalizedPath) {
+    return normalizedBasePath || '/';
+  }
+
+  if (/^[a-zA-Z][a-zA-Z\d+.-]*:/u.test(normalizedPath)) {
+    return normalizedPath;
+  }
+
+  if (
+    normalizedBasePath
+    && (normalizedPath === normalizedBasePath || normalizedPath.startsWith(`${normalizedBasePath}/`))
+  ) {
+    return normalizedPath;
+  }
+
+  if (normalizedPath === '/') {
+    return normalizedBasePath || '/';
+  }
+
+  if (normalizedPath.startsWith('/')) {
+    return normalizedBasePath ? `${normalizedBasePath}${normalizedPath}` : normalizedPath;
+  }
+
+  return normalizedBasePath ? `${normalizedBasePath}/${normalizedPath}` : `/${normalizedPath}`;
+}
+
+export function getClientRuntimeConfig() {
+  const rawConfig = {
+    auth: {
+      enabled: false,
+      implemented: true,
+      requiresLogin: false,
+      sessionEndpoint: '/api/auth/session',
+      statusEndpoint: '/api/auth/status',
+      strategy: 'none',
+    },
+    basePath: '',
+    environment: 'development',
+    gitEnabled: true,
+    publicWsBaseUrl: '',
+    wsBasePath: '/ws',
+    ...(window.__COLLABMD_CONFIG__ ?? {}),
+  };
+  const basePath = normalizeBasePath(rawConfig.basePath);
+  const authConfig = {
+    enabled: false,
+    implemented: true,
+    requiresLogin: false,
+    sessionEndpoint: '/api/auth/session',
+    statusEndpoint: '/api/auth/status',
+    strategy: 'none',
+    ...(rawConfig.auth ?? {}),
+  };
+
+  return {
+    ...rawConfig,
+    auth: {
+      ...authConfig,
+      sessionEndpoint: applyBasePath(basePath, authConfig.sessionEndpoint),
+      statusEndpoint: applyBasePath(basePath, authConfig.statusEndpoint),
+    },
+    basePath,
+    wsBasePath: normalizeRoutePath(rawConfig.wsBasePath, '/ws'),
+  };
+}
+
+export function resolveAppPath(pathValue = '/', config = getClientRuntimeConfig()) {
+  return applyBasePath(config.basePath, pathValue);
+}
+
+export function resolveAppUrl(pathValue = '/', config = getClientRuntimeConfig()) {
+  return new URL(resolveAppPath(pathValue, config), window.location.origin).toString();
+}
+
+export function resolveApiUrl(pathValue = '/', config = getClientRuntimeConfig()) {
+  const normalizedPath = String(pathValue ?? '').trim();
+  if (!normalizedPath || normalizedPath === '/') {
+    return resolveAppPath('/api', config);
+  }
+
+  if (normalizedPath.startsWith('/api')) {
+    return resolveAppPath(normalizedPath, config);
+  }
+
+  return resolveAppPath(`/api${normalizedPath.startsWith('/') ? normalizedPath : `/${normalizedPath}`}`, config);
+}
+
+export function resolveWsBaseUrl(config = getClientRuntimeConfig()) {
+  const params = new URLSearchParams(window.location.search);
+  const customServerUrl = params.get('server');
+
+  if (customServerUrl) {
+    return trimTrailingSlash(customServerUrl);
+  }
+
+  if (config.publicWsBaseUrl) {
+    return trimTrailingSlash(config.publicWsBaseUrl);
+  }
+
+  const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+  return `${protocol}//${window.location.host}${resolveAppPath(config.wsBasePath, config)}`;
+}

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

@@ -0,0 +1 @@
+export { VaultApiClient, vaultApiClient } from '../infrastructure/vault-api-client.js';

package/src/client/domain/vault-paths.js

@@ -0,0 +1,80 @@
+import {
+  isMermaidFilePath,
+  isPlantUmlFilePath,
+  stripVaultFileExtension,
+} from '../../domain/file-kind.js';
+
+export function normalizeVaultPathInput(value) {
+  const segments = String(value ?? '')
+    .trim()
+    .replace(/\\/g, '/')
+    .replace(/^\/+/u, '')
+    .split('/')
+    .map((segment) => segment.trim())
+    .filter(Boolean);
+
+  if (segments.some((segment) => segment === '.' || segment === '..')) {
+    return '';
+  }
+
+  return segments.join('/');
+}
+
+export function composeVaultChildPath(parentDir, childPath) {
+  const normalizedParent = normalizeVaultPathInput(parentDir);
+  const normalizedChild = normalizeVaultPathInput(childPath);
+
+  if (!normalizedParent) {
+    return normalizedChild;
+  }
+
+  if (!normalizedChild) {
+    return normalizedParent;
+  }
+
+  return `${normalizedParent}/${normalizedChild}`;
+}
+
+export function ensureVaultExtension(pathValue, extension) {
+  return pathValue.toLowerCase().endsWith(extension.toLowerCase())
+    ? pathValue
+    : `${pathValue}${extension}`;
+}
+
+export function createMarkdownStarter(filePath) {
+  const title = stripVaultFileExtension(String(filePath ?? '').split('/').pop() || '') || 'Untitled';
+  return `# ${title}\n\n`;
+}
+
+export function createMermaidStarter(filePath) {
+  const normalizedPath = normalizeVaultPathInput(filePath);
+  const nextPath = isMermaidFilePath(normalizedPath)
+    ? normalizedPath
+    : `${normalizedPath}.mmd`;
+  return {
+    content: [
+      'flowchart TD',
+      '  A[Start] --> B{Decide}',
+      '  B -->|Yes| C[Ship it]',
+      '  B -->|No| D[Revise]',
+      '',
+    ].join('\n'),
+    path: nextPath,
+  };
+}
+
+export function createPlantUmlStarter(filePath) {
+  const normalizedPath = normalizeVaultPathInput(filePath);
+  const nextPath = isPlantUmlFilePath(normalizedPath)
+    ? normalizedPath
+    : `${normalizedPath}.puml`;
+  return {
+    content: [
+      '@startuml',
+      'Alice -> Bob: Hello',
+      '@enduml',
+      '',
+    ].join('\n'),
+    path: nextPath,
+  };
+}

package/src/client/domain/vault-utils.js

@@ -0,0 +1,49 @@
+import { resolveWikiTargetPath } from '../../domain/wiki-link-resolver.js';
+
+/**
+ * Shared utilities for vault file operations and HTML escaping.
+ */
+
+/**
+ * Escapes HTML special characters to prevent XSS when inserting user-supplied
+ * text into the DOM via innerHTML.
+ *
+ * @param {string} text — raw text to escape
+ * @returns {string} HTML-safe string
+ */
+export function escapeHtml(text) {
+  return String(text)
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+/**
+ * Resolves a wiki-link target (e.g. "My Note") to an existing vault file path.
+ *
+ * Matching rules (in order):
+ *   1. Exact path match (with .md appended if missing)
+ *   2. Filename match at any directory depth
+ *   3. Path without .md extension matches the target
+ *
+ * @param {string} target — the raw wiki-link target text
+ * @param {string[]} files — list of vault file paths
+ * @returns {string | undefined} matched file path, or undefined if unresolved
+ */
+export function resolveWikiTarget(target, files) {
+  return resolveWikiTargetPath(target, files) ?? undefined;
+}
+
+/**
+ * Clamps a numeric value between a minimum and maximum bound.
+ *
+ * @param {number} value
+ * @param {number} min
+ * @param {number} max
+ * @returns {number}
+ */
+export function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}

package/src/client/domain/wiki-link-completions.js

@@ -0,0 +1,78 @@
+/**
+ * CodeMirror autocomplete source for [[wiki-links]].
+ *
+ * Triggers when the user types `[[` and suggests vault file paths.
+ * Completing a suggestion inserts the full `[[path]]` text.
+ */
+
+/**
+ * Creates a wiki-link completion source.
+ *
+ * @param {() => string[]} getFileList — returns the current list of vault file paths
+ * @returns {import('@codemirror/autocomplete').CompletionSource}
+ */
+export function wikiLinkCompletions(getFileList) {
+  return (context) => {
+    // Look backwards from the cursor for `[[` that hasn't been closed
+    const line = context.state.doc.lineAt(context.pos);
+    const textBefore = line.text.slice(0, context.pos - line.from);
+
+    // Find the last `[[` that isn't already closed with `]]`
+    const openIndex = textBefore.lastIndexOf('[[');
+    if (openIndex === -1) {
+      return null;
+    }
+
+    // Check there's no `]]` between the `[[` and the cursor
+    const afterOpen = textBefore.slice(openIndex + 2);
+    if (afterOpen.includes(']]')) {
+      return null;
+    }
+
+    const query = afterOpen.toLowerCase();
+    const from = line.from + openIndex + 2;
+    const files = getFileList();
+
+    // Build completion options: show file paths without .md extension
+    const options = files
+      .map((filePath) => {
+        const label = filePath.replace(/\.md$/i, '');
+        // Match against full path and just the filename
+        const fileName = label.split('/').pop();
+        return { filePath, label, fileName };
+      })
+      .filter(({ label, fileName }) =>
+        label.toLowerCase().includes(query) || fileName.toLowerCase().includes(query),
+      )
+      .map(({ label, fileName }) => ({
+        label,
+        // Show just the filename as detail when in a subdirectory
+        detail: label.includes('/') ? `  ${fileName}` : undefined,
+        apply: (view, completion, from, to) => {
+          // Replace from the query start to cursor, and also consume any trailing `]]`
+          const docText = view.state.doc.toString();
+          let end = to;
+          // If there's already a `]]` right after cursor, consume it
+          if (docText.slice(to, to + 2) === ']]') {
+            end = to + 2;
+          }
+          view.dispatch({
+            changes: { from, to: end, insert: `${completion.label}]]` },
+            selection: { anchor: from + completion.label.length + 2 },
+          });
+        },
+        type: 'text',
+        boost: label.toLowerCase().startsWith(query) ? 1 : 0,
+      }));
+
+    if (options.length === 0) {
+      return null;
+    }
+
+    return {
+      from,
+      options,
+      filter: false, // we already filtered
+    };
+  };
+}