collabmd 0.1.44 → 0.1.46

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

@@ -1,6 +1,7 @@
-import { createGitRequestError } from './errors.js';
+import { createRequestError as createGitRequestError } from '../http/http-errors.js';
 import { getVaultFileKind, isImageAttachmentFilePath } from '../../../domain/file-kind.js';
 import { normalizeRelativeGitPath } from './path-utils.js';
+import { getImageMimeType } from './image-mime.js';
 import {
   countPatchLines,
   parseGitLogHeader,
@@ -9,11 +10,7 @@ import {
   parseUnifiedDiff,
 } from './parsers.js';
 import {
-  createCommitDiffResponse,
   createEmptyStats,
-  createFileHistoryResponse,
-  createFileSnapshotResponse,
-  createHistoryResponse,
 } from './responses.js';
 
 const EMPTY_TREE_HASH = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
@@ -127,13 +124,13 @@ export class GitHistoryService {
     const normalizedOffset = normalizeHistoryOffset(offset);
 
     if (!isGitRepo) {
-      return createHistoryResponse({
+      return {
         commits: [],
         hasMore: false,
         isGitRepo: false,
         limit: normalizedLimit,
         offset: normalizedOffset,
-      });
+      };
     }
 
     const cacheKey = JSON.stringify({
@@ -149,12 +146,13 @@ export class GitHistoryService {
     return this.runRequest(cacheKey, async () => {
       const hasHeadCommit = await this.hasHeadCommit();
       if (!hasHeadCommit) {
-        return setCachedValue(this.historyCache, cacheKey, createHistoryResponse({
+        return setCachedValue(this.historyCache, cacheKey, {
           commits: [],
           hasMore: false,
+          isGitRepo: true,
           limit: normalizedLimit,
           offset: normalizedOffset,
-        }), this.responseCacheTtlMs);
+        }, this.responseCacheTtlMs);
       }
 
       const output = await this.commandRunner.execGit([
@@ -175,12 +173,13 @@ export class GitHistoryService {
         .map((chunk) => this.parseHistoryChunk(chunk));
 
       const hasMore = commits.length > normalizedLimit;
-      const response = createHistoryResponse({
+      const response = {
         commits: commits.slice(0, normalizedLimit),
         hasMore,
+        isGitRepo: true,
         limit: normalizedLimit,
         offset: normalizedOffset,
-      });
+      };
 
       return setCachedValue(this.historyCache, cacheKey, response, this.responseCacheTtlMs);
     });
@@ -193,14 +192,14 @@ export class GitHistoryService {
     const normalizedPath = normalizeRelativeGitPath(path);
 
     if (!isGitRepo) {
-      return createFileHistoryResponse({
+      return {
         commits: [],
         hasMore: false,
         isGitRepo: false,
         limit: normalizedLimit,
         offset: normalizedOffset,
         path: normalizedPath,
-      });
+      };
     }
 
     const cacheKey = JSON.stringify({
@@ -217,13 +216,14 @@ export class GitHistoryService {
     return this.runRequest(cacheKey, async () => {
       const hasHeadCommit = await this.hasHeadCommit();
       if (!hasHeadCommit) {
-        return setCachedValue(this.historyCache, cacheKey, createFileHistoryResponse({
+        return setCachedValue(this.historyCache, cacheKey, {
           commits: [],
           hasMore: false,
+          isGitRepo: true,
           limit: normalizedLimit,
           offset: normalizedOffset,
           path: normalizedPath,
-        }), this.responseCacheTtlMs);
+        }, this.responseCacheTtlMs);
       }
 
       const logArgs = [
@@ -254,13 +254,14 @@ export class GitHistoryService {
 
       const commits = this.mergeFileHistoryChunks(nameStatusOutput, numstatOutput);
       const hasMore = commits.length > normalizedLimit;
-      const response = createFileHistoryResponse({
+      const response = {
         commits: commits.slice(0, normalizedLimit),
         hasMore,
+        isGitRepo: true,
         limit: normalizedLimit,
         offset: normalizedOffset,
         path: normalizedPath,
-      });
+      };
 
       return setCachedValue(this.historyCache, cacheKey, response, this.responseCacheTtlMs);
     });
@@ -269,13 +270,19 @@ export class GitHistoryService {
   async getCommit({ allowLargePatch = false, hash, metaOnly = false, path = null } = {}) {
     const isGitRepo = await this.commandRunner.isGitRepo();
     if (!isGitRepo) {
-      return createCommitDiffResponse({
+      return {
         commit: null,
         files: [],
         isGitRepo: false,
         metaOnly,
         path: null,
-      });
+        source: 'commit',
+        summary: {
+          additions: 0,
+          deletions: 0,
+          filesChanged: 0,
+        },
+      };
     }
 
     const normalizedHash = this.normalizeCommitHash(hash);
@@ -301,13 +308,16 @@ export class GitHistoryService {
       const summary = createSummaryFromFiles(meta.files);
 
       if (metaOnly) {
-        const metaResponse = createCommitDiffResponse({
+        const metaResponse = {
+          baseRef: meta.baseRef,
           commit: meta.commit,
           files: meta.files,
+          isGitRepo: true,
           metaOnly: true,
           path: normalizedPath,
+          source: 'commit',
           summary,
-        });
+        };
         return setCachedValue(this.commitCache, cacheKey, metaResponse, this.responseCacheTtlMs);
       }
 
@@ -326,7 +336,8 @@ export class GitHistoryService {
         !allowLargePatch
         && (fileSummary.additions + fileSummary.deletions) > this.maxInitialPatchLines
       ) {
-        const guardedResponse = createCommitDiffResponse({
+        const guardedResponse = {
+          baseRef: meta.baseRef,
           commit: meta.commit,
           files: [{
             ...baseFile,
@@ -335,10 +346,12 @@ export class GitHistoryService {
             patchLineCount: fileSummary.additions + fileSummary.deletions,
             tooLarge: true,
           }],
+          isGitRepo: true,
           metaOnly: false,
           path: normalizedPath,
+          source: 'commit',
           summary,
-        });
+        };
         return setCachedValue(this.commitCache, cacheKey, guardedResponse, this.responseCacheTtlMs);
       }
 
@@ -385,13 +398,16 @@ export class GitHistoryService {
           tooLarge: false,
         };
 
-      const response = createCommitDiffResponse({
+      const response = {
+        baseRef: meta.baseRef,
         commit: meta.commit,
         files: [detailedFile],
+        isGitRepo: true,
         metaOnly: false,
         path: normalizedPath,
+        source: 'commit',
         summary,
-      });
+      };
       return setCachedValue(this.commitCache, cacheKey, response, this.responseCacheTtlMs);
     });
   }
@@ -402,13 +418,13 @@ export class GitHistoryService {
     const normalizedPath = normalizeRelativeGitPath(path);
 
     if (!isGitRepo) {
-      return createFileSnapshotResponse({
+      return {
         content: '',
         fileKind: getVaultFileKind(normalizedPath),
         hash: normalizedHash,
         isGitRepo: false,
         path: normalizedPath,
-      });
+      };
     }
 
     if (isImageAttachmentFilePath(normalizedPath)) {
@@ -438,12 +454,53 @@ export class GitHistoryService {
         throw createGitRequestError(404, 'Commit file not found');
       }
 
-      return setCachedValue(this.commitCache, cacheKey, createFileSnapshotResponse({
+      return setCachedValue(this.commitCache, cacheKey, {
         content,
         fileKind,
         hash: normalizedHash,
+        isGitRepo: true,
+        path: normalizedPath,
+      }, this.responseCacheTtlMs);
+    });
+  }
+
+  async getFileAttachment({ hash, path } = {}) {
+    const isGitRepo = await this.commandRunner.isGitRepo();
+    const normalizedHash = this.normalizeAttachmentRef(hash);
+    const normalizedPath = normalizeRelativeGitPath(path);
+
+    if (!isGitRepo) {
+      throw createGitRequestError(404, 'Git repository not found');
+    }
+
+    if (!isImageAttachmentFilePath(normalizedPath)) {
+      throw createGitRequestError(400, 'Unsupported image attachment path');
+    }
+
+    const cacheKey = JSON.stringify({
+      hash: normalizedHash,
+      path: normalizedPath,
+      type: 'file-attachment',
+    });
+    const cached = getCachedValue(this.commitCache, cacheKey);
+    if (cached) {
+      return cached;
+    }
+
+    return this.runRequest(cacheKey, async () => {
+      let content;
+      try {
+        content = await this.commandRunner.execGitBuffer(['cat-file', 'blob', `${normalizedHash}:${normalizedPath}`]);
+      } catch {
+        throw createGitRequestError(404, 'Commit image not found');
+      }
+
+      return setCachedValue(this.commitCache, cacheKey, {
+        content,
+        hash: normalizedHash,
+        mimeType: getImageMimeType(normalizedPath),
         path: normalizedPath,
-      }), this.responseCacheTtlMs);
+      }, this.responseCacheTtlMs);
     });
   }
 
@@ -481,6 +538,14 @@ export class GitHistoryService {
     return normalizedHash;
   }
 
+  normalizeAttachmentRef(hash) {
+    const normalizedHash = String(hash ?? '').trim();
+    if (normalizedHash === 'HEAD') {
+      return normalizedHash;
+    }
+    return this.normalizeCommitHash(normalizedHash);
+  }
+
   parseHistoryChunk(chunk) {
     const [headerLine = '', ...statLines] = String(chunk ?? '')
       .split(/\r?\n/u)
@@ -575,6 +640,7 @@ export class GitHistoryService {
         authoredAt: chunk.authoredAt,
         deletions: Number(numstatEntry?.deletions || 0),
         filesChanged: 1,
+        fileKind: getVaultFileKind(nameStatusEntry?.path),
         hash: chunk.hash,
         isMergeCommit: chunk.isMergeCommit,
         oldPath: nameStatusEntry?.oldPath ?? null,
@@ -666,6 +732,7 @@ export class GitHistoryService {
       const numstatEntry = numstatEntries[index];
       return {
         ...entry,
+        fileKind: getVaultFileKind(entry.path),
         stats: numstatEntry
           ? {
             additions: numstatEntry.additions,

package/src/server/infrastructure/git/image-mime.js

@@ -0,0 +1,14 @@
+const IMAGE_MIME_TYPES = Object.freeze({
+  '.gif': 'image/gif',
+  '.jpeg': 'image/jpeg',
+  '.jpg': 'image/jpeg',
+  '.png': 'image/png',
+  '.svg': 'image/svg+xml',
+  '.webp': 'image/webp',
+});
+
+export function getImageMimeType(filePath) {
+  const normalizedPath = String(filePath ?? '').toLowerCase();
+  const extension = Object.keys(IMAGE_MIME_TYPES).find((candidate) => normalizedPath.endsWith(candidate));
+  return extension ? IMAGE_MIME_TYPES[extension] : 'application/octet-stream';
+}

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

@@ -1,4 +1,4 @@
-import { createGitRequestError } from './errors.js';
+import { createRequestError as createGitRequestError } from '../http/http-errors.js';
 
 export function decodeQuotedPath(pathValue) {
   const rawValue = String(pathValue ?? '').trim();

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

@@ -54,98 +54,3 @@ export function createEmptyStatusResponse() {
     summary: createEmptySummary(),
   };
 }
-
-export function createDiffResponse({
-  files = [],
-  isGitRepo = true,
-  metaOnly = false,
-  path = null,
-  scope = 'working-tree',
-  summary = {
-    additions: 0,
-    deletions: 0,
-    filesChanged: 0,
-  },
-} = {}) {
-  return {
-    files,
-    isGitRepo,
-    metaOnly,
-    path,
-    scope,
-    summary,
-  };
-}
-
-export function createHistoryResponse({
-  commits = [],
-  hasMore = false,
-  isGitRepo = true,
-  limit = 30,
-  offset = 0,
-} = {}) {
-  return {
-    commits,
-    hasMore,
-    isGitRepo,
-    limit,
-    offset,
-  };
-}
-
-export function createFileHistoryResponse({
-  commits = [],
-  hasMore = false,
-  isGitRepo = true,
-  limit = 30,
-  offset = 0,
-  path = null,
-} = {}) {
-  return {
-    commits,
-    hasMore,
-    isGitRepo,
-    limit,
-    offset,
-    path,
-  };
-}
-
-export function createCommitDiffResponse({
-  commit = null,
-  files = [],
-  isGitRepo = true,
-  metaOnly = false,
-  path = null,
-  summary = {
-    additions: 0,
-    deletions: 0,
-    filesChanged: 0,
-  },
-} = {}) {
-  return {
-    commit,
-    files,
-    isGitRepo,
-    metaOnly,
-    path,
-    source: 'commit',
-    summary,
-  };
-}
-
-export function createFileSnapshotResponse({
-  content = '',
-  fileKind = null,
-  hash = null,
-  isGitRepo = true,
-  path = null,
-} = {}) {
-  return {
-    content,
-    fileKind,
-    hash,
-    isGitRepo,
-    path,
-  };
-}

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

@@ -2,11 +2,17 @@ import { createReadStream } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 
+import { getVaultFileKind, isImageAttachmentFilePath } from '../../../domain/file-kind.js';
 import { mapWithConcurrency } from '../../shared/async-utils.js';
 import { createEmptyStats } from './responses.js';
 import { splitContentLines } from './parsers.js';
+import { getImageMimeType } from './image-mime.js';
 
 async function countFileLines(filePath) {
+  if (isImageAttachmentFilePath(filePath)) {
+    return 0;
+  }
+
   return new Promise((resolve, reject) => {
     const stream = createReadStream(filePath, { encoding: 'utf8' });
     let lineCount = 0;
@@ -36,6 +42,7 @@ function buildSyntheticAddedFileDiff(pathValue, content) {
   const normalizedContent = String(content ?? '').replace(/\r\n/g, '\n');
   const file = {
     code: 'U',
+    fileKind: getVaultFileKind(pathValue),
     hunks: [],
     isBinary: false,
     oldPath: null,
@@ -89,7 +96,27 @@ export class GitUntrackedFileService {
   async buildSyntheticDiffs(files = []) {
     const results = await mapWithConcurrency(files, 2, async (file) => {
       try {
-        const content = await readFile(join(this.vaultDir, file.path), 'utf8');
+        const absolutePath = join(this.vaultDir, file.path);
+        if (isImageAttachmentFilePath(file.path)) {
+          const content = await readFile(absolutePath);
+          return {
+            ...file,
+            binaryMessage: 'Binary image file',
+            byteLength: content.byteLength,
+            code: file.code || 'U',
+            fileKind: 'image',
+            hunks: [],
+            isBinary: true,
+            mimeType: getImageMimeType(file.path),
+            oldPath: file.oldPath ?? null,
+            path: file.path,
+            stats: createEmptyStats(),
+            status: file.status || 'untracked',
+            synthetic: true,
+          };
+        }
+
+        const content = await readFile(absolutePath, 'utf8');
         return buildSyntheticAddedFileDiff(file.path, content);
       } catch {
         return null;

package/src/server/infrastructure/github/github-app-client.js

@@ -1,16 +1,11 @@
 import { createSign } from 'node:crypto';
 
+import { createRequestError } from '../http/http-errors.js';
+
 function base64UrlJson(value) {
   return Buffer.from(JSON.stringify(value)).toString('base64url');
 }
 
-function createRequestError(statusCode, message, code) {
-  const error = new Error(message);
-  error.statusCode = statusCode;
-  error.code = code;
-  return error;
-}
-
 function normalizeBaseUrl(value) {
   return String(value ?? 'https://api.github.com').trim().replace(/\/+$/u, '') || 'https://api.github.com';
 }
@@ -80,7 +75,9 @@ export class GitHubAppClient {
 
   createAppJwt() {
     if (!this.isConfigured()) {
-      throw createRequestError(503, 'GitHub App setup is not configured.', 'HOSTED_GITHUB_APP_NOT_CONFIGURED');
+      throw createRequestError(503, 'GitHub App setup is not configured.', {
+        code: 'HOSTED_GITHUB_APP_NOT_CONFIGURED',
+      });
     }
 
     return createGitHubAppJwt({
@@ -91,7 +88,9 @@ export class GitHubAppClient {
 
   createInstallationSetupUrl({ state } = {}) {
     if (!this.appSlug) {
-      throw createRequestError(503, 'GitHub App slug is not configured.', 'HOSTED_GITHUB_APP_NOT_CONFIGURED');
+      throw createRequestError(503, 'GitHub App slug is not configured.', {
+        code: 'HOSTED_GITHUB_APP_NOT_CONFIGURED',
+      });
     }
 
     const setupUrl = new URL(`/apps/${encodeURIComponent(this.appSlug)}/installations/new`, this.htmlBaseUrl);
@@ -131,7 +130,7 @@ export class GitHubAppClient {
       throw createRequestError(
         response.status,
         payload?.message || 'GitHub API request failed.',
-        'HOSTED_GITHUB_API_FAILED',
+        { code: 'HOSTED_GITHUB_API_FAILED' },
       );
     }
 
@@ -141,7 +140,9 @@ export class GitHubAppClient {
   async createInstallationAccessToken(installationId, { appJwt = null } = {}) {
     const normalizedInstallationId = String(installationId ?? '').trim();
     if (!normalizedInstallationId) {
-      throw createRequestError(400, 'GitHub installation id is required.', 'HOSTED_GITHUB_INSTALLATION_REQUIRED');
+      throw createRequestError(400, 'GitHub installation id is required.', {
+        code: 'HOSTED_GITHUB_INSTALLATION_REQUIRED',
+      });
     }
 
     const payload = await this.request(`/app/installations/${encodeURIComponent(normalizedInstallationId)}/access_tokens`, {
@@ -150,7 +151,9 @@ export class GitHubAppClient {
     });
     const token = String(payload?.token ?? '').trim();
     if (!token) {
-      throw createRequestError(502, 'GitHub did not return an installation access token.', 'HOSTED_GITHUB_TOKEN_MISSING');
+      throw createRequestError(502, 'GitHub did not return an installation access token.', {
+        code: 'HOSTED_GITHUB_TOKEN_MISSING',
+      });
     }
     return token;
   }
@@ -158,7 +161,9 @@ export class GitHubAppClient {
   async getInstallation(installationId, { appJwt = null } = {}) {
     const normalizedInstallationId = String(installationId ?? '').trim();
     if (!normalizedInstallationId) {
-      throw createRequestError(400, 'GitHub installation id is required.', 'HOSTED_GITHUB_INSTALLATION_REQUIRED');
+      throw createRequestError(400, 'GitHub installation id is required.', {
+        code: 'HOSTED_GITHUB_INSTALLATION_REQUIRED',
+      });
     }
 
     return this.request(`/app/installations/${encodeURIComponent(normalizedInstallationId)}`, {
@@ -176,7 +181,9 @@ export class GitHubAppClient {
   async resolveVaultSourceFromInstallation(installationId) {
     const normalizedInstallationId = String(installationId ?? '').trim();
     if (!normalizedInstallationId) {
-      throw createRequestError(400, 'GitHub installation id is required.', 'HOSTED_GITHUB_INSTALLATION_REQUIRED');
+      throw createRequestError(400, 'GitHub installation id is required.', {
+        code: 'HOSTED_GITHUB_INSTALLATION_REQUIRED',
+      });
     }
 
     const appJwt = this.createAppJwt();
@@ -189,7 +196,7 @@ export class GitHubAppClient {
       throw createRequestError(
         409,
         'GitHub App installation must grant access to exactly one selected repository.',
-        'HOSTED_GITHUB_REPOSITORY_SELECTION_REQUIRED',
+        { code: 'HOSTED_GITHUB_REPOSITORY_SELECTION_REQUIRED' },
       );
     }
 

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

@@ -1,5 +1,12 @@
+import { basename } from 'node:path';
+
 import { handleApiError } from './http-request-helpers.js';
-import { jsonResponse } from './http-response.js';
+import {
+  createSafeAsciiFilename,
+  encodeContentDispositionFilename,
+  jsonResponse,
+  sendResponse,
+} from './http-response.js';
 
 function resolveDiffScope(requestUrl) {
   const scope = String(requestUrl.searchParams.get('scope') || '').trim().toLowerCase();
@@ -106,6 +113,29 @@ export function createGitApiQueryHandler({ gitService }) {
       return true;
     }
 
+    if (requestUrl.pathname === '/api/git/file-attachment' && req.method === 'GET') {
+      try {
+        const attachment = await gitService.getFileAttachment({
+          hash: requestUrl.searchParams.get('hash'),
+          path: requestUrl.searchParams.get('path'),
+        });
+        const fileName = basename(String(attachment.path || 'image'));
+        sendResponse(req, res, {
+          body: attachment.content,
+          headers: {
+            'Cache-Control': 'private, max-age=300, stale-while-revalidate=3600',
+            'Content-Disposition': `inline; filename="${createSafeAsciiFilename(fileName)}"; filename*=UTF-8''${encodeContentDispositionFilename(fileName)}`,
+            'Content-Type': attachment.mimeType || 'application/octet-stream',
+            'X-Content-Type-Options': 'nosniff',
+          },
+          statusCode: 200,
+        });
+      } catch (error) {
+        handleApiError(req, res, error, '[api] Failed to read git file attachment:', 'Failed to read git file attachment');
+      }
+      return true;
+    }
+
     if (requestUrl.pathname === '/api/git/pull-backups' && req.method === 'GET') {
       try {
         jsonResponse(req, res, 200, {