collabmd 0.1.47 → 0.1.49

package/src/server/domain/ripgrep-search-service.js

@@ -1,4 +1,6 @@
 import { execFile as execFileCallback } from 'node:child_process';
+import { glob, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
 import { promisify } from 'node:util';
 
 import { getVaultFileKind } from '../../domain/file-kind.js';
@@ -17,6 +19,8 @@ const TEXT_SEARCH_GLOBS = Object.freeze([
   '*.md',
   '*.markdown',
   '*.mdx',
+  '*.html',
+  '*.htm',
   '*.base',
   '*.mmd',
   '*.mermaid',
@@ -24,9 +28,15 @@ const TEXT_SEARCH_GLOBS = Object.freeze([
   '*.plantuml',
   '*.dsl',
   '*.drawio',
-  '*.excalidraw',
 ]);
 
+function parseByteLimit(value) {
+  const match = String(value ?? '').trim().match(/^(\d+)([KMG])?$/iu);
+  if (!match) return 1024 * 1024;
+  const multipliers = { K: 1024, M: 1024 ** 2, G: 1024 ** 3 };
+  return Number(match[1]) * (multipliers[match[2]?.toUpperCase()] ?? 1);
+}
+
 function normalizePositiveInt(value, fallback, { min = 1, max = Number.MAX_SAFE_INTEGER } = {}) {
   const parsed = Number.parseInt(value ?? '', 10);
   if (!Number.isInteger(parsed) || parsed < min) {
@@ -216,6 +226,72 @@ export function parseRipgrepJson(stdout, {
   };
 }
 
+async function searchExcalidrawText({ maxFileSize, maxFiles, maxSnippetsPerFile, query, signal, vaultDir }) {
+  const files = [];
+  let matchCount = 0;
+  let truncated = false;
+  const normalizedQuery = query.toLocaleLowerCase();
+  const paths = glob('**/*.excalidraw', {
+    cwd: vaultDir,
+    exclude: ['**/.*', '**/node_modules/**'],
+  });
+
+  for await (const filePath of paths) {
+    signal?.throwIfAborted?.();
+    const absolutePath = join(vaultDir, filePath);
+    if ((await stat(absolutePath)).size > parseByteLimit(maxFileSize)) continue;
+
+    let scene;
+    try {
+      scene = JSON.parse(await readFile(absolutePath, 'utf8'));
+    } catch {
+      continue;
+    }
+
+    const snippets = [];
+    let fileMatchCount = 0;
+    for (const element of Array.isArray(scene?.elements) ? scene.elements : []) {
+      if (element?.isDeleted || element?.type !== 'text' || typeof element.text !== 'string') continue;
+      const text = element.text;
+      const normalizedText = text.toLocaleLowerCase();
+      let matchStart = normalizedText.indexOf(normalizedQuery);
+      while (matchStart >= 0) {
+        fileMatchCount += 1;
+        matchCount += 1;
+        if (snippets.length < maxSnippetsPerFile) {
+          const snippet = createSnippet(text, matchStart, matchStart + query.length);
+          snippets.push({
+            column: matchStart + 1,
+            line: 1,
+            matchEnd: snippet.matchEnd,
+            matchStart: snippet.matchStart,
+            text: snippet.text,
+          });
+        } else {
+          truncated = true;
+        }
+        matchStart = normalizedText.indexOf(normalizedQuery, matchStart + Math.max(query.length, 1));
+      }
+    }
+
+    if (fileMatchCount > 0) {
+      if (files.length >= maxFiles) {
+        truncated = true;
+        continue;
+      }
+      files.push({
+        file: filePath.replaceAll('\\', '/'),
+        kind: 'excalidraw',
+        matchCount: fileMatchCount,
+        snippets,
+        truncated: fileMatchCount > snippets.length,
+      });
+    }
+  }
+
+  return { files, matchCount, truncated };
+}
+
 export class RipgrepSearchService {
   constructor({
     execFileImpl = execFile,
@@ -307,7 +383,7 @@ export class RipgrepSearchService {
       maxFileSize: this.maxFileSize,
       maxSnippetsPerFile: this.maxSnippetsPerFile,
     });
-
+    let parsed;
     try {
       const result = await this.execFileImpl('rg', args, {
         cwd: this.vaultDir,
@@ -316,56 +392,53 @@ export class RipgrepSearchService {
         ...(signal ? { signal } : {}),
         timeout: this.timeoutMs,
       });
-      const parsed = parseRipgrepJson(result.stdout, {
+      parsed = parseRipgrepJson(result.stdout, {
         maxFiles,
         maxSnippetsPerFile: this.maxSnippetsPerFile,
         query: normalizedQuery,
       });
-      parsed.search = this.getClientConfig();
-
-      logPerfEvent(this.perfLoggingEnabled, 'search-query', {
-        durationMs: Date.now() - startedAt,
-        fileCount: parsed.files.length,
-        matchCount: parsed.matchCount,
-        truncated: parsed.truncated,
-      });
-      return parsed;
     } catch (error) {
       if (error?.code === 1) {
-        const empty = createEmptySearchResult({
+        parsed = createEmptySearchResult({
           query: normalizedQuery,
           searchAvailable: this.available,
         });
-        empty.search = this.getClientConfig();
-        logPerfEvent(this.perfLoggingEnabled, 'search-query', {
-          durationMs: Date.now() - startedAt,
-          fileCount: 0,
-          matchCount: 0,
-          truncated: false,
+      } else {
+        const isMaxBuffer = error?.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER';
+        parsed = parseRipgrepJson(error?.stdout ?? '', {
+          maxFiles,
+          maxSnippetsPerFile: this.maxSnippetsPerFile,
+          query: normalizedQuery,
         });
-        return empty;
+        if (isMaxBuffer && parsed.files.length > 0) {
+          parsed.truncated = true;
+        } else {
+          error.statusCode = error?.signal === 'SIGTERM' ? 504 : 500;
+          throw error;
+        }
       }
+    }
 
-      const isMaxBuffer = error?.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER';
-      const parsed = parseRipgrepJson(error?.stdout ?? '', {
-        maxFiles,
+    if (parsed.files.length < maxFiles) {
+      const excalidraw = await searchExcalidrawText({
+        maxFileSize: this.maxFileSize,
+        maxFiles: maxFiles - parsed.files.length,
         maxSnippetsPerFile: this.maxSnippetsPerFile,
         query: normalizedQuery,
+        signal,
+        vaultDir: this.vaultDir,
       });
-      if (isMaxBuffer && parsed.files.length > 0) {
-        parsed.search = this.getClientConfig();
-        parsed.truncated = true;
-        logPerfEvent(this.perfLoggingEnabled, 'search-query', {
-          durationMs: Date.now() - startedAt,
-          fileCount: parsed.files.length,
-          matchCount: parsed.matchCount,
-          truncated: true,
-        });
-        return parsed;
-      }
-
-      error.statusCode = error?.signal === 'SIGTERM' ? 504 : 500;
-      throw error;
+      parsed.files.push(...excalidraw.files);
+      parsed.matchCount += excalidraw.matchCount;
+      parsed.truncated ||= excalidraw.truncated;
     }
+    parsed.search = this.getClientConfig();
+    logPerfEvent(this.perfLoggingEnabled, 'search-query', {
+      durationMs: Date.now() - startedAt,
+      fileCount: parsed.files.length,
+      matchCount: parsed.matchCount,
+      truncated: parsed.truncated,
+    });
+    return parsed;
   }
 }

package/src/server/infrastructure/git/git-service.js

@@ -146,9 +146,18 @@ export class GitService {
     };
   }
 
+  async stageAll() {
+    await this.commandRunner.execGit(['add', '-A', '--']);
+    this.invalidateStatusCache();
+    return {
+      ok: true,
+      workspaceChange: createEmptyWorkspaceChange(),
+    };
+  }
+
   async unstageFile(path) {
     const normalizedPath = normalizeRelativeGitPath(path);
-    await this.commandRunner.execGit(['reset', 'HEAD', '--', normalizedPath]);
+    await this.commandRunner.execGit(['reset', '--', normalizedPath]);
     this.invalidateStatusCache();
     return {
       ok: true,
@@ -157,6 +166,15 @@ export class GitService {
     };
   }
 
+  async unstageAll() {
+    await this.commandRunner.execGit(['reset', '--']);
+    this.invalidateStatusCache();
+    return {
+      ok: true,
+      workspaceChange: createEmptyWorkspaceChange(),
+    };
+  }
+
   async commitStaged({ author = null, message } = {}) {
     const normalizedMessage = String(message ?? '').trim();
     if (!normalizedMessage) {

package/src/server/infrastructure/git/history-service.js

@@ -233,7 +233,7 @@ export class GitHistoryService {
         '-n',
         String(normalizedLimit + 1),
         '--follow',
-        '--find-renames=20%',
+        '--find-renames',
         '--date=iso-strict',
         '--format=%x1e%H%x1f%h%x1f%s%x1f%an%x1f%ae%x1f%aI%x1f%P',
         '--',

package/src/server/infrastructure/git/local-exclude.js

@@ -0,0 +1,25 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+export async function ensureCollabMetadataGitExclude(vaultDir) {
+  const excludePath = resolve(vaultDir, '.git/info/exclude');
+  let existingContent = '';
+
+  try {
+    existingContent = await readFile(excludePath, 'utf8');
+  } catch (error) {
+    if (error?.code !== 'ENOENT') {
+      throw error;
+    }
+  }
+
+  const lines = existingContent
+    .split(/\r?\n/u)
+    .map((line) => line.trim());
+  if (lines.includes('.collabmd') || lines.includes('.collabmd/')) {
+    return;
+  }
+
+  const prefix = existingContent && !existingContent.endsWith('\n') ? '\n' : '';
+  await writeFile(excludePath, `${existingContent}${prefix}.collabmd/\n`, 'utf8');
+}

package/src/server/infrastructure/git/parsers.js

@@ -1,4 +1,4 @@
-import { decodeQuotedPath, parseRenamePath, stripDiffPrefix } from './path-utils.js';
+import { decodeQuotedPath, stripDiffPrefix } from './path-utils.js';
 import { createEmptyBranchStatus, createStatusInfo } from './responses.js';
 
 function parseBranchLine(line) {
@@ -91,11 +91,8 @@ export function splitContentLines(content) {
 }
 
 export function parseStatusOutput(output) {
-  const lines = String(output ?? '')
-    .split(/\r?\n/u)
-    .filter(Boolean);
-  const [branchLine = '', ...statusLines] = lines;
-  const branch = parseBranchLine(branchLine);
+  const records = String(output ?? '').split('\0');
+  const branch = parseBranchLine(records.shift() || '');
   const sections = {
     staged: [],
     'working-tree': [],
@@ -103,14 +100,15 @@ export function parseStatusOutput(output) {
   };
   const uniquePaths = new Set();
 
-  for (const line of statusLines) {
-    if (line.length < 3) {
+  for (let index = 0; index < records.length; index += 1) {
+    const record = records[index];
+    if (record.length < 3) {
       continue;
     }
 
-    const indexStatus = line[0];
-    const workTreeStatus = line[1];
-    const rawPath = line.slice(3);
+    const indexStatus = record[0];
+    const workTreeStatus = record[1];
+    const path = record.slice(3);
 
     if (indexStatus === '!' && workTreeStatus === '!') {
       continue;
@@ -120,7 +118,7 @@ export function parseStatusOutput(output) {
       const file = {
         ...createStatusInfo('?'),
         oldPath: null,
-        path: decodeQuotedPath(rawPath),
+        path,
         scope: 'untracked',
       };
       sections.untracked.push(file);
@@ -128,13 +126,17 @@ export function parseStatusOutput(output) {
       continue;
     }
 
-    const parsedPath = parseRenamePath(rawPath);
+    const hasSourcePath = ['R', 'C'].includes(indexStatus) || ['R', 'C'].includes(workTreeStatus);
+    const oldPath = hasSourcePath ? records[index + 1] || null : null;
+    if (hasSourcePath) {
+      index += 1;
+    }
 
     if (indexStatus !== ' ') {
       const file = {
         ...createStatusInfo(indexStatus),
-        oldPath: parsedPath.oldPath,
-        path: parsedPath.path,
+        oldPath,
+        path,
         scope: 'staged',
       };
       sections.staged.push(file);
@@ -144,8 +146,8 @@ export function parseStatusOutput(output) {
     if (workTreeStatus !== ' ') {
       const file = {
         ...createStatusInfo(workTreeStatus),
-        oldPath: parsedPath.oldPath,
-        path: parsedPath.path,
+        oldPath,
+        path,
         scope: 'working-tree',
       };
       sections['working-tree'].push(file);

package/src/server/infrastructure/git/path-utils.js

@@ -34,22 +34,6 @@ export function normalizeRelativeGitPath(pathValue) {
   return normalized.join('/');
 }
 
-export function parseRenamePath(rawPath) {
-  const decodedPath = decodeQuotedPath(rawPath);
-  const separator = ' -> ';
-  const separatorIndex = decodedPath.indexOf(separator);
-  if (separatorIndex === -1) {
-    return {
-      oldPath: null,
-      path: decodedPath,
-    };
-  }
-
-  return {
-    oldPath: decodedPath.slice(0, separatorIndex),
-    path: decodedPath.slice(separatorIndex + separator.length),
-  };
-}
 
 export function stripDiffPrefix(pathValue) {
   const normalizedPath = String(pathValue ?? '').replace(/\s+$/u, '');

package/src/server/infrastructure/git/status-service.js

@@ -42,7 +42,7 @@ export class GitStatusService {
 
     const statusPromise = (async () => {
       const parsed = parseStatusOutput(
-        await this.commandRunner.execGit(['status', '--porcelain=v1', '--branch', '--untracked-files=all']),
+        await this.commandRunner.execGit(['status', '--porcelain=v1', '-z', '--branch', '--untracked-files=all']),
       );
       const sections = [
         { files: parsed.sections.staged, key: 'staged', label: 'Staged Changes' },

package/src/server/infrastructure/git/untracked-files.js

@@ -1,6 +1,7 @@
 import { createReadStream } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { createInterface } from 'node:readline';
 
 import { getVaultFileKind, isImageAttachmentFilePath } from '../../../domain/file-kind.js';
 import { mapWithConcurrency } from '../../shared/async-utils.js';
@@ -13,29 +14,19 @@ async function countFileLines(filePath) {
     return 0;
   }
 
-  return new Promise((resolve, reject) => {
-    const stream = createReadStream(filePath, { encoding: 'utf8' });
-    let lineCount = 0;
-    let sawData = false;
-    let lastCharacter = '\n';
+  const lines = createInterface({
+    crlfDelay: Infinity,
+    input: createReadStream(filePath, { encoding: 'utf8' }),
+  });
+  let lineCount = 0;
 
-    stream.on('data', (chunk) => {
-      if (!chunk) {
-        return;
-      }
+  for await (const line of lines) {
+    if (typeof line === 'string') {
+      lineCount += 1;
+    }
+  }
 
-      sawData = true;
-      lastCharacter = chunk[chunk.length - 1];
-      lineCount += chunk.match(/\n/gu)?.length ?? 0;
-    });
-    stream.on('error', reject);
-    stream.on('end', () => {
-      if (sawData && lastCharacter !== '\n') {
-        lineCount += 1;
-      }
-      resolve(lineCount);
-    });
-  });
+  return lineCount;
 }
 
 function buildSyntheticAddedFileDiff(pathValue, content) {

package/src/server/infrastructure/http/create-agent-api-handler.js

@@ -0,0 +1,171 @@
+import { fromJsonSchema } from '@modelcontextprotocol/server';
+
+import { getAgentToolDefinition } from '../../../domain/agent-tool-definitions.js';
+import { encodeAgentToolImage } from '../../shared/agent-tool-image.js';
+import { readRequestId } from './http-request-helpers.js';
+import { jsonResponse } from './http-response.js';
+import { parseJsonBody } from './request-body.js';
+
+const WEBMCP_TOOL_PATH = '/api/agent/tools/';
+const WEBMCP_INPUT_SCHEMAS = new Map();
+
+function createAgentError(code, message, statusCode) {
+  const error = new Error(message);
+  error.code = code;
+  error.statusCode = statusCode;
+  return error;
+}
+
+function sendAgentError(req, res, error) {
+  const statusCode = Number(error?.statusCode) || 500;
+  if (statusCode >= 500) console.error('[agent] Request failed:', error.message);
+  jsonResponse(req, res, statusCode, {
+    code: error?.code || 'AGENT_REQUEST_FAILED',
+    error: statusCode >= 500 ? 'Agent request failed' : error.message,
+    ...(Number.isFinite(error?.retryAfterMs) ? { retryAfterMs: error.retryAfterMs } : {}),
+  });
+}
+
+async function validateWebMcpInput(definition, input) {
+  let schema = WEBMCP_INPUT_SCHEMAS.get(definition.name);
+  if (!schema) {
+    schema = fromJsonSchema(definition.inputSchema);
+    WEBMCP_INPUT_SCHEMAS.set(definition.name, schema);
+  }
+  const validation = await schema['~standard'].validate(input);
+  if (validation.issues?.length) {
+    throw createAgentError('AGENT_INPUT_INVALID', 'WebMCP tool input does not match its schema', 400);
+  }
+}
+
+async function createWebMcpActor({ agentConnectionService, authService, config, req }) {
+  let subject;
+  if (config.auth.strategy === 'none') {
+    subject = {
+      collaborator: null,
+      subjectId: req.socket?.remoteAddress || 'unknown',
+      subjectType: 'anonymous',
+    };
+  } else {
+    const user = authService.getAuthenticatedUser?.(req) ?? null;
+    subject = await agentConnectionService.resolveManagementSubject(user);
+  }
+  const actorId = `webmcp:${subject.subjectType}:${subject.subjectId}`;
+  return {
+    collaborator: subject.collaborator,
+    connectionId: actorId,
+    origin: 'webmcp',
+    rateLimitKey: actorId,
+    requestId: readRequestId(req),
+    scopes: ['vault:edit', 'vault:read'],
+    sourceRef: 'webmcp',
+  };
+}
+
+async function mapWebMcpResult(definition, value) {
+  if (definition.resultKind === 'image' && value.svg) {
+    const { data, mimeType, structuredContent } = await encodeAgentToolImage(value);
+    return {
+      ...structuredContent,
+      image: { data, encoding: 'base64', mimeType },
+      scene: value.scene,
+    };
+  }
+  if (definition.resultKind === 'optional-image' && value.verification?.svg) {
+    const { verification, ...result } = value;
+    const { data, mimeType, structuredContent } = await encodeAgentToolImage(verification);
+    return {
+      ...result,
+      image: { data, encoding: 'base64', mimeType },
+      verification: {
+        ...structuredContent,
+        scene: verification.scene,
+      },
+    };
+  }
+  return value;
+}
+
+export function createAgentApiHandler({
+  agentConnectionService,
+  agentContentService,
+  authService,
+  config,
+  rateLimiter,
+}) {
+  return async function handleAgentApi(req, res, requestUrl) {
+    if (!requestUrl.pathname.startsWith('/api/agent')) return false;
+
+    try {
+      if (requestUrl.pathname.startsWith(WEBMCP_TOOL_PATH)) {
+        if (req.method !== 'POST') {
+          throw createAgentError('AGENT_METHOD_NOT_ALLOWED', 'WebMCP tools require POST', 405);
+        }
+        const name = decodeURIComponent(requestUrl.pathname.slice(WEBMCP_TOOL_PATH.length));
+        const definition = getAgentToolDefinition(name);
+        if (!definition?.webMcp) {
+          throw createAgentError('AGENT_TOOL_NOT_FOUND', 'WebMCP tool not found', 404);
+        }
+        const input = await parseJsonBody(req);
+        await validateWebMcpInput(definition, input);
+        const actor = await createWebMcpActor({
+          agentConnectionService,
+          authService,
+          config,
+          req,
+        });
+        rateLimiter(actor.rateLimitKey);
+        const cancellation = new AbortController();
+        const abort = () => cancellation.abort();
+        req.once('aborted', abort);
+        try {
+          const value = await agentContentService[definition.method](actor, {
+            ...input,
+            signal: cancellation.signal,
+          });
+          jsonResponse(req, res, 200, await mapWebMcpResult(definition, value));
+        } finally {
+          req.off('aborted', abort);
+        }
+        return true;
+      }
+
+      if (!config.agentAccess?.enabled) {
+        jsonResponse(req, res, 404, { error: 'Agent Access is not enabled' });
+        return true;
+      }
+      const user = authService.getAuthenticatedUser?.(req) ?? null;
+      if (requestUrl.pathname === '/api/agent/connections' && req.method === 'GET') {
+        jsonResponse(req, res, 200, {
+          connections: await agentConnectionService.listConnections(user),
+        });
+        return true;
+      }
+      if (requestUrl.pathname === '/api/agent/connections' && req.method === 'POST') {
+        const body = await parseJsonBody(req);
+        jsonResponse(req, res, 201, await agentConnectionService.createConnection({
+          clientKind: body?.clientKind,
+          label: body?.label,
+          scopes: body?.scopes,
+          user,
+        }));
+        return true;
+      }
+      if (requestUrl.pathname.startsWith('/api/agent/connections/') && req.method === 'DELETE') {
+        const connectionId = decodeURIComponent(
+          requestUrl.pathname.slice('/api/agent/connections/'.length).split('/')[0] || '',
+        );
+        jsonResponse(req, res, 200, await agentConnectionService.revokeConnection({
+          connectionId,
+          user,
+        }));
+        return true;
+      }
+      jsonResponse(req, res, 404, { error: 'Agent endpoint not found' });
+      return true;
+    } catch (error) {
+      sendAgentError(req, res, error);
+      return true;
+    }
+  };
+}

package/src/server/infrastructure/http/create-git-api-command-handler.js

@@ -84,6 +84,38 @@ export function createGitApiCommandHandler({
       return true;
     }
 
+    if (requestUrl.pathname === '/api/git/stage-all' && req.method === 'POST') {
+      try {
+        jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
+          action: 'stage-all',
+          req,
+          responsePayload: await workspaceMutationCoordinator.runManagedWorkspaceMutation(
+            () => gitService.stageAll(),
+          ),
+          workspaceMutationCoordinator,
+        }));
+      } catch (error) {
+        handleApiError(req, res, error, '[api] Failed to stage all git changes:', 'Failed to stage all git changes');
+      }
+      return true;
+    }
+
+    if (requestUrl.pathname === '/api/git/unstage-all' && req.method === 'POST') {
+      try {
+        jsonResponse(req, res, 200, await applyWorkspaceMutationEffects({
+          action: 'unstage-all',
+          req,
+          responsePayload: await workspaceMutationCoordinator.runManagedWorkspaceMutation(
+            () => gitService.unstageAll(),
+          ),
+          workspaceMutationCoordinator,
+        }));
+      } catch (error) {
+        handleApiError(req, res, error, '[api] Failed to unstage all git changes:', 'Failed to unstage all git changes');
+      }
+      return true;
+    }
+
     if (requestUrl.pathname === '/api/git/commit' && req.method === 'POST') {
       try {
         const body = await parseRequiredBody(req, res, 'message');