collabmd 0.1.47 → 0.1.49

package/src/server/infrastructure/http/create-request-handler.js

@@ -1,3 +1,6 @@
+import { createAgentApiHandler } from './create-agent-api-handler.js';
+import { createAgentMcpHandler } from '../mcp/create-agent-mcp-handler.js';
+import { createAgentToolRateLimiter } from '../../shared/agent-tool-rate-limiter.js';
 import { createAuthApiHandler } from './create-auth-api-handler.js';
 import { createGitApiCommandHandler } from './create-git-api-command-handler.js';
 import { createGitApiQueryHandler } from './create-git-api-query-handler.js';
@@ -38,6 +41,7 @@ export function createRequestHandler(
   hostedWorkspaceService = null,
   githubSetupFlow = null,
   structurizrWorkspaceService = null,
+  agentIntegration = null,
 ) {
   const handleStaticRequest = createStaticHandler(config, authService, searchService);
   const handleAuthApi = createAuthApiHandler({ authService });
@@ -73,6 +77,22 @@ export function createRequestHandler(
     basePath: config.basePath,
     service: structurizrWorkspaceService,
   });
+  const agentToolRateLimiter = createAgentToolRateLimiter(config.agentAccess.requestsPerMinute);
+  const handleAgentApi = createAgentApiHandler({
+    agentConnectionService: agentIntegration?.connectionService,
+    agentContentService: agentIntegration?.contentService,
+    authService,
+    config,
+    rateLimiter: agentToolRateLimiter,
+  });
+  const handleAgentMcp = config.agentAccess.enabled && agentIntegration
+    ? createAgentMcpHandler({
+        agentConnectionService: agentIntegration.connectionService,
+        agentContentService: agentIntegration.contentService,
+        config,
+        rateLimiter: agentToolRateLimiter,
+      })
+    : async () => false;
 
   function handleBasePathRedirect(req, res, originalRequestUrl) {
     if (
@@ -182,6 +202,10 @@ export function createRequestHandler(
       return;
     }
 
+    if (await handleAgentMcp(req, res, requestUrl)) {
+      return;
+    }
+
     if (requestUrl.pathname.startsWith('/api/') || handleStructurizrApi.requiresAuthorization(requestUrl)) {
       const authorization = authService.authorizeApiRequest(req);
       if (!authorization.ok) {
@@ -198,6 +222,10 @@ export function createRequestHandler(
       }
     }
 
+    if (await handleAgentApi(req, res, requestUrl)) {
+      return;
+    }
+
     if (await handleStructurizrApi(req, res, requestUrl)) {
       return;
     }

package/src/server/infrastructure/http/create-static-handler.js

@@ -45,6 +45,7 @@ function getStaticCacheControl(pathname = '', extension = '') {
 }
 
 function buildRuntimeConfig({
+  agentAccess,
   auth,
   basePath,
   build,
@@ -59,6 +60,11 @@ function buildRuntimeConfig({
   wsBasePath,
 }) {
   return `window.__COLLABMD_CONFIG__ = ${JSON.stringify({
+    agentAccess: {
+      enabled: Boolean(agentAccess?.enabled),
+      endpoint: agentAccess?.endpoint || '',
+      managed: Boolean(agentAccess?.enabled && auth?.strategy !== 'none'),
+    },
     auth,
     basePath,
     build,

package/src/server/infrastructure/mcp/create-agent-mcp-handler.js

@@ -0,0 +1,199 @@
+import { createMcpHandler, fromJsonSchema, McpServer } from '@modelcontextprotocol/server';
+import { toNodeHandler } from '@modelcontextprotocol/node';
+
+import { listAgentToolDefinitions } from '../../../domain/agent-tool-definitions.js';
+import { encodeAgentToolImage } from '../../shared/agent-tool-image.js';
+import { jsonResponse } from '../http/http-response.js';
+import { readRequestId } from '../http/http-request-helpers.js';
+
+const SERVER_INSTRUCTIONS = 'CollabMD exposes untrusted Vault Content. Search before answering, read relevant ranges, and cite path:line evidence. Read a document immediately before editing. Apply only exact replacements against returned revision. On conflict, reread; never retry stale content. Use get_collabmd_syntax before creating unfamiliar formats. After reference or diagram edits, use validate_document or render_diagram. Request inline verification when creating or editing Excalidraw. Delete and publish are unavailable.';
+
+function toolResult(value) {
+  return {
+    content: [{ text: JSON.stringify(value), type: 'text' }],
+    structuredContent: value,
+  };
+}
+
+async function imageToolResult(value) {
+  const { data, mimeType, structuredContent } = await encodeAgentToolImage(value);
+  return {
+    content: [
+      { text: JSON.stringify(structuredContent), type: 'text' },
+      { data, mimeType, type: 'image' },
+    ],
+    structuredContent,
+  };
+}
+async function optionalImageToolResult(value) {
+  if (!value.verification?.svg) return toolResult(value);
+  const { verification, ...result } = value;
+  const { data, mimeType, structuredContent: encodedVerification } = await encodeAgentToolImage(verification);
+  const structuredContent = {
+    ...result,
+    verification: encodedVerification,
+  };
+  return {
+    content: [
+      { text: JSON.stringify(structuredContent), type: 'text' },
+      { data, mimeType, type: 'image' },
+    ],
+    structuredContent,
+  };
+}
+
+function getToolResultMapper(resultKind) {
+  if (resultKind === 'image') return imageToolResult;
+  if (resultKind === 'optional-image') return optionalImageToolResult;
+  return toolResult;
+}
+
+function toolError(error) {
+  const isAgentError = typeof error?.code === 'string' && error.code.startsWith('AGENT_');
+  const value = {
+    code: isAgentError ? error.code : 'AGENT_TOOL_FAILED',
+    error: isAgentError ? error.message : 'Agent tool failed',
+  };
+  if (isAgentError && Number.isFinite(error?.retryAfterMs)) {
+    value.retryAfterMs = error.retryAfterMs;
+  }
+  return {
+    content: [{ text: JSON.stringify(value), type: 'text' }],
+    isError: true,
+    structuredContent: value,
+  };
+}
+
+function registerTool(server, name, config, handler, {
+  actor,
+  rateLimiter,
+  resultMapper = toolResult,
+}) {
+  server.registerTool(name, config, async (input, context) => {
+    try {
+      rateLimiter(actor.rateLimitKey);
+      return await resultMapper(await handler(input, context));
+    } catch (error) {
+      if (typeof error?.code !== 'string' || !error.code.startsWith('AGENT_')) {
+        console.error(`[mcp] ${name} failed (${actor.requestId}):`, error?.message || 'Unknown error');
+      }
+      return toolError(error);
+    }
+  });
+}
+
+function buildAgentServer({ actor, agentContentService, rateLimiter, version }) {
+  const server = new McpServer(
+    { name: 'collabmd', version },
+    { instructions: SERVER_INSTRUCTIONS },
+  );
+  for (const definition of listAgentToolDefinitions(actor.scopes)) {
+    registerTool(server, definition.name, {
+      annotations: definition.annotations,
+      description: definition.description,
+      inputSchema: fromJsonSchema(definition.inputSchema),
+      outputSchema: fromJsonSchema(definition.outputSchema),
+    }, (input, context) => agentContentService[definition.method](actor, {
+      ...input,
+      signal: context.signal,
+    }), {
+      actor,
+      rateLimiter,
+      resultMapper: getToolResultMapper(definition.resultKind),
+    });
+  }
+  return server;
+}
+
+function readHttpHostname(value) {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') return '';
+    return url.hostname.replace(/^\[|\]$/gu, '').toLowerCase();
+  } catch {
+    return '';
+  }
+}
+
+function readRequestHostname(req) {
+  return readHttpHostname(`http://${String(req.headers.host || '')}`);
+}
+
+export function createAgentMcpHandler({
+  agentConnectionService,
+  agentContentService,
+  config,
+  rateLimiter,
+}) {
+  const mcpHandler = createMcpHandler(({ authInfo }) => buildAgentServer({
+    actor: authInfo.extra.actor,
+    agentContentService,
+    rateLimiter,
+    version: config.build?.version || '0.1.0',
+  }));
+  const nodeHandler = toNodeHandler(mcpHandler, {
+    onerror: (error) => console.error('[mcp] Transport failed:', error.message),
+  });
+
+  return async function handleAgentMcp(req, res, requestUrl) {
+    if (requestUrl.pathname !== '/mcp') return false;
+    const authRequired = config.auth.strategy !== 'none';
+    const allowedHosts = config.agentAccess.allowedHosts;
+    const hostname = readRequestHostname(req);
+    const hasOrigin = Boolean(req.headers.origin);
+    const originHostname = hasOrigin ? readHttpHostname(String(req.headers.origin)) : '';
+    const browserOriginAllowed = hasOrigin
+      && hostname
+      && originHostname === hostname
+      && allowedHosts.includes(hostname);
+    if (
+      (authRequired && (!hostname || !allowedHosts.includes(hostname)))
+      || (hasOrigin && !browserOriginAllowed)
+    ) {
+      jsonResponse(req, res, 403, { error: 'MCP request origin or host is not allowed' });
+      return true;
+    }
+
+    let actor;
+    let token = '';
+    if (authRequired) {
+      const authorization = String(req.headers.authorization || '');
+      const match = authorization.match(/^Bearer\s+(.+)$/iu);
+      if (!match) {
+        res.setHeader('WWW-Authenticate', 'Bearer scope="vault:read"');
+        jsonResponse(req, res, 401, { error: 'Agent Connection token is required' });
+        return true;
+      }
+      token = match[1];
+      try {
+        actor = await agentConnectionService.authenticateToken(token);
+      } catch (error) {
+        res.setHeader('WWW-Authenticate', 'Bearer scope="vault:read"');
+        jsonResponse(req, res, Number(error?.statusCode) || 401, {
+          code: error?.code || 'AGENT_TOKEN_INVALID',
+          error: error?.message || 'Agent Connection token is invalid',
+        });
+        return true;
+      }
+    } else {
+      actor = {
+        collaborator: null,
+        connectionId: 'anonymous',
+        scopes: ['vault:edit', 'vault:read'],
+      };
+    }
+
+    actor.requestId = readRequestId(req);
+    actor.rateLimitKey = actor.connectionId === 'anonymous'
+      ? `anonymous:${req.socket?.remoteAddress || 'unknown'}`
+      : actor.connectionId;
+    req.auth = {
+      clientId: actor.connectionId,
+      extra: { actor },
+      scopes: actor.scopes,
+      token,
+    };
+    await nodeHandler(req, res);
+    return true;
+  };
+}

package/src/server/infrastructure/persistence/agent-connection-store.js

@@ -0,0 +1,120 @@
+import { mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
+
+function parseScopes(value) {
+  try {
+    const scopes = JSON.parse(value || '[]');
+    return Array.isArray(scopes) ? scopes : [];
+  } catch {
+    return [];
+  }
+}
+
+function rowToConnection(row) {
+  if (!row) return null;
+  return {
+    clientKind: row.client_kind,
+    createdAt: row.created_at,
+    expiresAt: row.expires_at,
+    id: row.id,
+    label: row.label,
+    revokedAt: row.revoked_at,
+    scopes: parseScopes(row.scopes_json),
+    subjectEmail: row.subject_email,
+    subjectId: row.subject_id,
+    subjectType: row.subject_type,
+    tokenHash: row.token_hash,
+  };
+}
+
+export class AgentConnectionStore {
+  constructor({ dbPath }) {
+    this.dbPath = dbPath;
+    this.db = null;
+    this.statements = new Map();
+  }
+
+  async initialize() {
+    if (this.db) return;
+    await mkdir(dirname(this.dbPath), { recursive: true });
+    const { DatabaseSync } = await import('node:sqlite');
+    this.db = new DatabaseSync(this.dbPath);
+    this.db.exec('PRAGMA journal_mode = WAL');
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS agent_connections (
+        id TEXT PRIMARY KEY,
+        subject_type TEXT NOT NULL,
+        subject_id TEXT NOT NULL,
+        subject_email TEXT NOT NULL DEFAULT '',
+        label TEXT NOT NULL,
+        client_kind TEXT NOT NULL,
+        scopes_json TEXT NOT NULL,
+        token_hash TEXT NOT NULL UNIQUE,
+        created_at INTEGER NOT NULL,
+        expires_at INTEGER NOT NULL,
+        revoked_at INTEGER
+      );
+      CREATE INDEX IF NOT EXISTS agent_connections_subject_idx
+        ON agent_connections(subject_type, subject_id, created_at DESC);
+    `);
+  }
+
+  prepare(key, sql) {
+    if (!this.statements.has(key)) this.statements.set(key, this.db.prepare(sql));
+    return this.statements.get(key);
+  }
+
+  async close() {
+    this.statements.clear();
+    this.db?.close();
+    this.db = null;
+  }
+
+  async create(connection) {
+    this.prepare(
+      'create',
+      `INSERT INTO agent_connections (
+        id, subject_type, subject_id, subject_email, label, client_kind,
+        scopes_json, token_hash, created_at, expires_at, revoked_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL)`,
+    ).run(
+      connection.id,
+      connection.subjectType,
+      connection.subjectId,
+      connection.subjectEmail,
+      connection.label,
+      connection.clientKind,
+      JSON.stringify(connection.scopes),
+      connection.tokenHash,
+      connection.createdAt,
+      connection.expiresAt,
+    );
+    return connection;
+  }
+
+  async getByTokenHash(tokenHash) {
+    return rowToConnection(this.prepare(
+      'getByTokenHash',
+      'SELECT * FROM agent_connections WHERE token_hash = ? LIMIT 1',
+    ).get(tokenHash));
+  }
+
+  async listBySubject(subjectType, subjectId) {
+    return this.prepare(
+      'listBySubject',
+      `SELECT * FROM agent_connections
+       WHERE subject_type = ? AND subject_id = ? AND revoked_at IS NULL
+       ORDER BY created_at DESC`,
+    ).all(subjectType, subjectId).map(rowToConnection);
+  }
+
+  async revoke(id, subjectType, subjectId, revokedAt) {
+    const result = this.prepare(
+      'revoke',
+      `UPDATE agent_connections SET revoked_at = ?
+       WHERE id = ? AND subject_type = ? AND subject_id = ? AND revoked_at IS NULL`,
+    ).run(revokedAt, id, subjectType, subjectId);
+    return Number(result.changes) > 0;
+  }
+
+}

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

@@ -3,7 +3,7 @@ import { isAbsolute, normalize, relative, resolve } from 'path';
 import { isVaultFilePath } from '../../../domain/file-kind.js';
 
 export const IGNORED_DIRECTORIES = new Set(['.git', '.obsidian', '.trash', 'node_modules', '.DS_Store']);
-export const VAULT_FILE_PATH_REQUIREMENT = '.md, .markdown, .mdx, .base, .excalidraw, .drawio, .mmd, .mermaid, .puml, .plantuml, .dsl, .png, .jpg, .jpeg, .webp, .gif, or .svg';
+export const VAULT_FILE_PATH_REQUIREMENT = '.md, .markdown, .mdx, .html, .htm, .base, .excalidraw, .drawio, .mmd, .mermaid, .puml, .plantuml, .dsl, .pdf, .png, .jpg, .jpeg, .webp, .gif, or .svg';
 export const INVALID_VAULT_FILE_PATH_ERROR = `Invalid file path — must end in ${VAULT_FILE_PATH_REQUIREMENT}`;
 export const INVALID_DIRECTORY_PATH_ERROR = 'Invalid directory path';
 
@@ -12,12 +12,18 @@ export function isIgnoredVaultEntry(name) {
 }
 
 function normalizeRequestedPath(requestedPath) {
-  const normalized = normalize(String(requestedPath ?? '').trim().replace(/\\/g, '/'));
-  if (!normalized || normalized === '.') {
+  const value = String(requestedPath ?? '').trim().replace(/\\/g, '/');
+  const segments = value.split('/');
+  if (
+    !value
+    || isAbsolute(value)
+    || segments.some((segment) => segment === '.' || segment === '..')
+  ) {
     return '';
   }
 
-  return normalized;
+  const normalized = normalize(value);
+  return normalized === '.' ? '' : normalized;
 }
 
 export function sanitizeVaultPath(vaultDir, requestedPath) {

package/src/server/infrastructure/persistence/pull-backup-store.js

@@ -1,6 +1,7 @@
 import { copyFile, mkdir, readFile, readdir, stat, writeFile } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
 
+import { ensureCollabMetadataGitExclude } from '../git/local-exclude.js';
 import { sanitizeVaultPath } from './path-utils.js';
 
 const PULL_BACKUP_STORAGE_ROOT = '.collabmd/pull-backups';
@@ -98,32 +99,6 @@ function formatSummary({
   ].join('\n');
 }
 
-async function ensureLocalGitExclude(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())
-    .filter(Boolean);
-  if (lines.includes('.collabmd') || lines.includes('.collabmd/')) {
-    return;
-  }
-
-  const prefix = existingContent.length > 0 && !existingContent.endsWith('\n')
-    ? '\n'
-    : '';
-  await writeFile(excludePath, `${existingContent}${prefix}.collabmd/\n`, 'utf8');
-}
-
 export class PullBackupStore {
   constructor({ vaultDir }) {
     this.vaultDir = resolve(vaultDir);
@@ -148,7 +123,7 @@ export class PullBackupStore {
     headRef = null,
     targetRef = null,
   } = {}) {
-    await ensureLocalGitExclude(this.vaultDir);
+    await ensureCollabMetadataGitExclude(this.vaultDir);
 
     const backupId = createBackupId(headRef, createdAt);
     const backupDir = this.getBackupPath(backupId);

package/src/server/infrastructure/persistence/vault-file-store.js

@@ -1,5 +1,5 @@
 import { createReadStream } from 'fs';
-import { mkdir, readFile, readdir, rename, rm, rmdir, stat, writeFile } from 'fs/promises';
+import { copyFile, mkdir, readFile, readdir, rename, rm, rmdir, stat, writeFile } from 'fs/promises';
 import { basename, dirname, extname, join, relative, resolve } from 'path';
 import sharp from 'sharp';
 
@@ -28,6 +28,7 @@ const EDITABLE_VAULT_CONTENT_PATH_ERRORS = {
   base: 'Invalid file path — must end in .base',
   drawio: 'Invalid file path — must end in .drawio',
   excalidraw: 'Invalid file path — must end in .excalidraw',
+  html: 'Invalid file path — must end in .html or .htm',
   markdown: 'Invalid file path',
   mermaid: 'Invalid file path — must end in .mmd or .mermaid',
   plantuml: 'Invalid file path — must end in .puml or .plantuml',
@@ -66,6 +67,7 @@ const TEXT_FILE_MIME_TYPES = Object.freeze({
   base: 'text/yaml; charset=utf-8',
   drawio: 'application/xml; charset=utf-8',
   excalidraw: 'application/json; charset=utf-8',
+  html: 'text/html; charset=utf-8',
   markdown: 'text/markdown; charset=utf-8',
   mermaid: 'text/plain; charset=utf-8',
   pdf: 'application/pdf',
@@ -706,7 +708,11 @@ export class VaultFileStore {
             : null;
 
           if (backupPath) {
-            await rename(operation.targetPath, backupPath);
+            if (operation.kind === 'write') {
+              await copyFile(operation.targetPath, backupPath);
+            } else {
+              await rename(operation.targetPath, backupPath);
+            }
           }
 
           try {
@@ -719,6 +725,9 @@ export class VaultFileStore {
             }
           } catch (error) {
             if (backupPath) {
+              if (operation.kind === 'write') {
+                await rm(operation.targetPath, { force: true });
+              }
               await rename(backupPath, operation.targetPath);
             }
             throw error;

package/src/server/shared/agent-tool-image.js

@@ -0,0 +1,22 @@
+import sharp from 'sharp';
+
+export async function encodeAgentToolImage(value) {
+  const { format, svg } = value;
+  const metadata = { ...value };
+  delete metadata.format;
+  delete metadata.scene;
+  delete metadata.svg;
+  const mimeType = format === 'svg' ? 'image/svg+xml' : 'image/png';
+  const image = format === 'svg'
+    ? Buffer.from(svg)
+    : await sharp(Buffer.from(svg)).png().toBuffer();
+  return {
+    data: image.toString('base64'),
+    mimeType,
+    structuredContent: {
+      ...metadata,
+      format,
+      mimeType,
+    },
+  };
+}

package/src/server/shared/agent-tool-rate-limiter.js

@@ -0,0 +1,20 @@
+export function createAgentToolRateLimiter(requestsPerMinute) {
+  const limit = Math.max(1, Number.parseInt(requestsPerMinute, 10) || 120);
+  const windows = new Map();
+  return (key) => {
+    const timestamp = Date.now();
+    let window = windows.get(key);
+    if (!window || timestamp >= window.resetAt) {
+      window = { count: 0, resetAt: timestamp + 60_000 };
+      windows.set(key, window);
+    }
+    if (window.count >= limit) {
+      const error = new Error('Agent tool request limit reached; retry after the current window');
+      error.code = 'AGENT_RATE_LIMITED';
+      error.retryAfterMs = Math.max(1, window.resetAt - timestamp);
+      error.statusCode = 429;
+      throw error;
+    }
+    window.count += 1;
+  };
+}

package/src/server/startup/git-remote-bootstrap.js

@@ -4,6 +4,8 @@ import { tmpdir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { promisify } from 'node:util';
 
+import { ensureCollabMetadataGitExclude } from '../infrastructure/git/local-exclude.js';
+
 const execFile = promisify(execFileCallback);
 const GIT_TIMEOUT_MS = 20_000;
 const GIT_MAX_BUFFER_BYTES = 5 * 1024 * 1024;
@@ -150,36 +152,6 @@ async function cloneIntoVault(vaultDir, repoUrl, options = {}) {
   });
 }
 
-async function ensureLocalGitIgnore(vaultDir) {
-  const excludeFilePath = join(vaultDir, '.git', 'info', 'exclude');
-  let existingContent = '';
-
-  try {
-    existingContent = await readFile(excludeFilePath, '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.length > 0 && !existingContent.endsWith('\n')
-    ? '\n'
-    : '';
-  await writeFile(
-    excludeFilePath,
-    `${existingContent}${prefix}.collabmd/\n`,
-    'utf8',
-  );
-}
-
 async function updateExistingCheckout(vaultDir, repoUrl, options = {}) {
   const originUrl = await getOriginUrl(vaultDir, options);
   if (originUrl !== repoUrl) {
@@ -384,7 +356,7 @@ export async function prepareConfigForStartup(config, options = {}) {
           ...options,
           commandEnv: config.git.commandEnv,
         });
-        await ensureLocalGitIgnore(config.vaultDir);
+        await ensureCollabMetadataGitExclude(config.vaultDir);
         await ensureRepositoryIdentity(config.vaultDir, config.git, {
           ...options,
           commandEnv: config.git.commandEnv,
@@ -404,7 +376,7 @@ export async function prepareConfigForStartup(config, options = {}) {
           ...options,
           commandEnv: config.git.commandEnv,
         });
-        await ensureLocalGitIgnore(config.vaultDir);
+        await ensureCollabMetadataGitExclude(config.vaultDir);
         await ensureRepositoryIdentity(config.vaultDir, config.git, {
           ...options,
           commandEnv: config.git.commandEnv,
@@ -422,7 +394,7 @@ export async function prepareConfigForStartup(config, options = {}) {
       ...options,
       commandEnv: config.git.commandEnv,
     });
-    await ensureLocalGitIgnore(config.vaultDir);
+    await ensureCollabMetadataGitExclude(config.vaultDir);
     await ensureRepositoryIdentity(config.vaultDir, config.git, {
       ...options,
       commandEnv: config.git.commandEnv,

package/dist/client/assets/CodeMirrorEditor-UCMRAMCV-BPH4FJkv.js

@@ -1 +0,0 @@
-import{i as e}from"./rolldown-runtime-Dd_uD5pT.js";import{B as t,L as n,N as r,Q as i,R as a,W as o,Z as s,c,dt as l,et as u,pt as d,t as f}from"./dist-RKBTaQMb.js";import"./chunk-SRAX5OIU-KFQikY-4.js";import{n as p,t as m}from"./jsx-runtime-BpzPEenQ.js";import{a as h,o as g,p as _,s as v}from"./dist-ByrG2qBA.js";var y=e(p(),1),b=m(),x=c.define({token(e){return e.match(/^%%.*$/)?`comment`:e.match(/^"(?:[^"\\]|\\.)*"/)?`string`:e.match(/^(flowchart|graph|sequenceDiagram|classDiagram|stateDiagram|erDiagram|gantt|pie|mindmap|journey|gitGraph|timeline|quadrantChart|sankey|xychart)\b/i)||e.match(/^(TB|TD|BT|RL|LR)\b/)||e.match(/^(subgraph|end|participant|actor|loop|alt|else|opt|par|critical|break|rect|note|over|activate|deactivate|title|section|class|style|linkStyle|classDef|click)\b/i)?`keyword`:e.match(/^[-.=<>|ox]+>/)||e.match(/^<[-.=<>|ox]+/)||e.match(/^--+|\.\.+|==+/)?`operator`:e.match(/^[[\](){}|<>]/)?`bracket`:e.match(/^[A-Za-z_][A-Za-z0-9_]*/)?`variableName`:e.match(/^\d+(\.\d+)?/)?`number`:e.match(/^[,:;]/)?`punctuation`:(e.eatSpace()||e.next(),null)}});function S(){return x}var C=t.theme({"&":{backgroundColor:`#1e1e1e`,color:`#d4d4d4`},".cm-content":{caretColor:`#fff`},".cm-cursor":{borderLeftColor:`#fff`},".cm-gutters":{backgroundColor:`#1e1e1e`,color:`#858585`,border:`none`},".cm-activeLineGutter":{backgroundColor:`#2a2a2a`},".cm-activeLine":{backgroundColor:`#2a2a2a`},".cm-errorLine":{backgroundColor:`rgba(255, 0, 0, 0.15)`}},{dark:!0}),w=f.define([{tag:n.keyword,color:`#569cd6`},{tag:n.string,color:`#ce9178`},{tag:n.comment,color:`#6a9955`},{tag:n.number,color:`#b5cea8`},{tag:n.operator,color:`#d4d4d4`},{tag:n.punctuation,color:`#d4d4d4`},{tag:n.variableName,color:`#9cdcfe`},{tag:n.bracket,color:`#ffd700`}]),T=t.theme({"&":{backgroundColor:`#ffffff`,color:`#1e1e1e`},".cm-content":{caretColor:`#000`},".cm-cursor":{borderLeftColor:`#000`},".cm-gutters":{backgroundColor:`#fff`,color:`#999`,border:`none`},".cm-activeLineGutter":{backgroundColor:`#e8e8e8`},".cm-activeLine":{backgroundColor:`#e8e8e8`},".cm-errorLine":{backgroundColor:`rgba(255, 0, 0, 0.1)`}}),E=f.define([{tag:n.keyword,color:`#0000ff`},{tag:n.string,color:`#a31515`},{tag:n.comment,color:`#008000`},{tag:n.number,color:`#098658`},{tag:n.operator,color:`#1e1e1e`},{tag:n.punctuation,color:`#1e1e1e`},{tag:n.variableName,color:`#001080`},{tag:n.bracket,color:`#af00db`}]),D=a.line({class:`cm-errorLine`}),O=(e,n)=>{if(!e||e<1||e>n.lines)return t.decorations.of(a.none);let r=n.line(e);return t.decorations.of(a.set([D.range(r.from)]))},k=e=>e===`dark`?[C,r(w)]:[T,r(E)],A=({value:e,onChange:n,onKeyboardSubmit:r,placeholder:a,theme:c,errorLine:f})=>{let p=(0,y.useRef)(null),m=(0,y.useRef)(null),x=(0,y.useRef)(n),C=(0,y.useRef)(r),w=(0,y.useRef)(new l),T=(0,y.useRef)(new l);return x.current=n,C.current=r,(0,y.useEffect)(()=>{if(!p.current)return;let n=w.current,r=new t({state:d.create({doc:e,extensions:[s.of([{key:`Mod-Enter`,run:()=>(C.current?.(),!0)},{key:`Mod-Shift-z`,run:_,preventDefault:!0}]),t.updateListener.of(e=>{e.docChanged&&x.current(e.state.doc.toString())}),g(),s.of([...h,...v]),i(),t.lineWrapping,n.of(k(c)),T.current.of([]),S(),o({drawRangeCursor:!0}),...a?[u(a)]:[]]}),parent:p.current});return m.current=r,r.focus(),()=>{r.destroy(),m.current=null}},[]),(0,y.useEffect)(()=>{let e=m.current;e&&e.dispatch({effects:w.current.reconfigure(k(c))})},[c]),(0,y.useEffect)(()=>{let e=m.current;e&&e.dispatch({effects:T.current.reconfigure(O(f,e.state.doc))})},[f]),(0,y.useEffect)(()=>{let t=m.current;if(!t)return;let n=t.state.doc.toString();e!==n&&t.dispatch({changes:{from:0,to:n.length,insert:e}})},[e]),(0,b.jsx)(`div`,{ref:p,className:`ttd-dialog-input ttd-dialog-input--codemirror`})};export{A as default};

package/dist/client/assets/abnfDiagram-VCTEODGH-BNDLzJ7L.js

@@ -1 +0,0 @@
-import{n as e}from"./chunk-XHIXRSVI-BFQ6B8BE.js";import{n as t}from"./chunk-Y2CYZVJY-DsF7k-Jl.js";import{m as n}from"./src-oBChb5qS.js";import"./chunk-DU6HZSFF-COXDzJK1.js";import"./chunk-CLGD4ZFX-DQLgbQrv.js";import{n as r,r as i,t as a}from"./chunk-SVP7TREG-CyHOmcac.js";import{t as o}from"./chunk-JWPE2WC7-DVXcaiue.js";import{t as s}from"./mermaid-parser.core-Bl0efOMt.js";var c=e().RailroadAbnf.parser.LangiumParser,l=t(e=>{let t=e.alternatives.map(u);return t.length===1?t[0]:{type:`choice`,alternatives:t}},`transformAlternation`),u=t(e=>{let t=e.elements.map(f);return t.length===1?t[0]:{type:`sequence`,elements:t}},`transformConcatenation`),d=t(e=>{if(e.includes(`*`)){let[t,n]=e.split(`*`);return{min:t?parseInt(t,10):0,max:n?parseInt(n,10):1/0}}let t=parseInt(e,10);return{min:t,max:t}},`parseRepeat`),f=t(e=>{let t=p(e.primary);if(!e.repeat)return t;let{min:n,max:r}=d(e.repeat);return n===0&&r===1?{type:`optional`,element:t}:{type:`repetition`,element:t,min:n,max:r}},`transformElement`),p=t(e=>{switch(e.$type){case`AbnfStringLiteral`:return{type:`terminal`,value:e.value};case`AbnfNumVal`:return{type:`terminal`,value:e.value};case`AbnfRuleName`:return{type:`nonterminal`,name:e.name};case`AbnfGroup`:return l(e.element);case`AbnfOptionalGroup`:return{type:`optional`,element:l(e.element)};default:throw Error(`Unsupported ABNF primary node: ${e.$type}`)}},`transformPrimary`),m=t(e=>({name:e.name,definition:l(e.definition)}),`transformRule`),h=t(e=>{o(e,a),e.title&&a.setTitle(e.title),e.rules.map(e=>a.addRule(m(e)))},`populateDb`),g={parser:{parse:t(e=>{a.clear(),n.debug(`[ABNF Parser] Starting Langium parse`);let t=c.parse(e);if(t.lexerErrors.length>0||t.parserErrors.length>0)throw new s(t);let r=t.value;n.debug(`[ABNF Parser] Parsed rules:`,r.rules.length),h(r),n.debug(`[ABNF Parser] Parse complete`)},`parse`),parser:{yy:a}},db:a,renderer:i,styles:r};export{g as diagram};

package/dist/client/assets/browser-utils--H_DkyEF.js

@@ -1 +0,0 @@
-function e(){return typeof window>`u`?globalThis:window}function t({accept:t=``,multiple:n=!1}={}){return new Promise(r=>{let i=document.createElement(`input`),a=e();i.type=`file`,i.accept=t,i.multiple=n,i.style.position=`fixed`,i.style.left=`-9999px`,document.body.appendChild(i);let o=!1,s=null,c=(e=[])=>{o||(o=!0,s&&a.clearTimeout(s),a.removeEventListener(`focus`,l),i.remove(),r(Array.from(e??[])))},l=()=>{s=a.setTimeout(()=>{o||i.files?.length||c()},250)};i.addEventListener(`change`,()=>c(i.files),{once:!0}),i.addEventListener(`cancel`,()=>c(),{once:!0}),a.addEventListener(`focus`,l,{once:!0}),i.click()})}function n(t,n){let r=e();return typeof r.requestIdleCallback==`function`?r.requestIdleCallback(t,{timeout:n}):r.setTimeout(()=>t({didTimeout:!1,timeRemaining:()=>0}),1)}function r(t){if(t===null)return;let n=e();if(typeof n.cancelIdleCallback==`function`){n.cancelIdleCallback(t);return}n.clearTimeout(t)}function i(e,t,n){if(!e||!t)return!1;let r=t.getBoundingClientRect(),i=e.getBoundingClientRect();return i.bottom>=r.top-n&&i.top<=r.bottom+n}function a(t,n,{removeDelayMs:r=3e4,revokeDelayMs:i=r}={}){let a=e(),o=URL.createObjectURL(t),s=document.createElement(`a`);s.href=o,s.download=n,s.style&&(s.style.display=`none`),document.body.appendChild(s),s.click(),r>0?a.setTimeout(()=>s.remove(),r):s.remove(),a.setTimeout(()=>URL.revokeObjectURL(o),i)}function o(e=``,t=`download`){let n=String(e).match(/filename\*=UTF-8''([^;]+)/iu);if(n)try{return decodeURIComponent(n[1])}catch{return t}return String(e).match(/filename="([^"]+)"/iu)?.[1]||t}export{t as a,o as i,a as n,n as o,i as r,r as t};

package/dist/client/assets/channel-CaoKA_We.js

@@ -1 +0,0 @@
-import{at as e,ot as t}from"./chunk-DU6HZSFF-COXDzJK1.js";var n=(n,r)=>t.lang.round(e.parse(n)[r]);export{n as t};