collabmd 0.1.43 → 0.1.45

package/src/client/infrastructure/browser-notification-port.js

@@ -1,40 +1,49 @@
 export class BrowserNotificationPort {
-  constructor({
-    NotificationImpl = globalThis.Notification,
-    focusWindow = () => globalThis.window?.focus?.(),
-  } = {}) {
-    this.NotificationImpl = NotificationImpl;
-    this.focusWindow = focusWindow;
+  getApi() {
+    return typeof globalThis.Notification === 'function'
+      ? globalThis.Notification
+      : null;
   }
 
   getPermission() {
-    if (typeof this.NotificationImpl !== 'function') {
-      return 'unsupported';
-    }
-
-    return this.NotificationImpl.permission;
+    return this.getApi()?.permission ?? 'unsupported';
   }
 
   async requestPermission() {
-    if (typeof this.NotificationImpl !== 'function') {
+    const api = this.getApi();
+    if (!api || typeof api.requestPermission !== 'function') {
       return 'unsupported';
     }
 
-    return this.NotificationImpl.requestPermission();
+    if (api.permission !== 'default') {
+      return api.permission;
+    }
+
+    try {
+      return await api.requestPermission();
+    } catch {
+      return api.permission ?? 'default';
+    }
   }
 
-  createNotification({ body, onClick, tag, title }) {
-    if (typeof this.NotificationImpl !== 'function') {
+  show({ body, onClick, tag, title } = {}) {
+    const api = this.getApi();
+    if (!api || api.permission !== 'granted' || !body) {
       return null;
     }
 
-    const notification = new this.NotificationImpl(title, { body, tag });
-    if (typeof onClick === 'function') {
-      notification.addEventListener('click', () => {
-        this.focusWindow();
-        onClick();
+    try {
+      const notification = new api(title, {
+        body,
+        renotify: true,
+        tag,
       });
+      if (onClick) {
+        notification.onclick = onClick;
+      }
+      return notification;
+    } catch {
+      return null;
     }
-    return notification;
   }
 }

package/src/client/infrastructure/browser-preferences-port.js

@@ -1,79 +1,91 @@
+function readStorage(storage, key, fallback) {
+  try {
+    const value = storage.getItem(key);
+    return value == null ? fallback : value;
+  } catch {
+    return fallback;
+  }
+}
+
+function writeStorage(storage, key, value) {
+  try {
+    storage.setItem(key, value);
+  } catch {
+    // Ignore storage errors.
+  }
+}
+
+const MAX_RECENT_FILES = 20;
+
 export class BrowserPreferencesPort {
   constructor({
-    chatNotificationsKey,
+    fileTreeShowExtensionsKey,
     lineWrappingKey,
+    recentFilesKey = 'collabmd-recent-files',
     sidebarVisibleKey,
     userNameKey,
     storage = globalThis.localStorage,
   }) {
-    this.chatNotificationsKey = chatNotificationsKey;
+    this.fileTreeShowExtensionsKey = fileTreeShowExtensionsKey;
     this.lineWrappingKey = lineWrappingKey;
+    this.recentFilesKey = recentFilesKey;
     this.sidebarVisibleKey = sidebarVisibleKey;
     this.storage = storage;
     this.userNameKey = userNameKey;
   }
 
   getUserName() {
-    try {
-      return this.storage.getItem(this.userNameKey) || '';
-    } catch {
-      return '';
-    }
+    return readStorage(this.storage, this.userNameKey, '') || '';
   }
 
   setUserName(name) {
-    try {
-      this.storage.setItem(this.userNameKey, name);
-    } catch {
-      // Ignore storage errors.
-    }
+    writeStorage(this.storage, this.userNameKey, name);
+  }
+
+  getFileTreeShowExtensions() {
+    return readStorage(this.storage, this.fileTreeShowExtensionsKey, null) === 'true';
+  }
+
+  setFileTreeShowExtensions(showFileExtensions) {
+    writeStorage(this.storage, this.fileTreeShowExtensionsKey, showFileExtensions ? 'true' : 'false');
   }
 
   getLineWrappingEnabled() {
-    try {
-      return this.storage.getItem(this.lineWrappingKey) !== 'false';
-    } catch {
-      return true;
-    }
+    return readStorage(this.storage, this.lineWrappingKey, null) !== 'false';
   }
 
   setLineWrappingEnabled(enabled) {
-    try {
-      this.storage.setItem(this.lineWrappingKey, String(enabled));
-    } catch {
-      // Ignore storage errors.
-    }
+    writeStorage(this.storage, this.lineWrappingKey, String(enabled));
   }
 
-  getSidebarVisible() {
+  getRecentFiles() {
+    const stored = readStorage(this.storage, this.recentFilesKey, '[]');
     try {
-      return this.storage.getItem(this.sidebarVisibleKey);
+      const recentFiles = JSON.parse(stored);
+      return Array.isArray(recentFiles)
+        ? [...new Set(recentFiles.filter((filePath) => typeof filePath === 'string' && filePath))]
+        : [];
     } catch {
-      return null;
+      return [];
     }
   }
 
-  setSidebarVisible(showSidebar) {
-    try {
-      this.storage.setItem(this.sidebarVisibleKey, showSidebar ? 'true' : 'false');
-    } catch {
-      // Ignore storage errors.
-    }
+  recordRecentFile(filePath) {
+    if (!filePath) return;
+
+    const recentFiles = [
+      filePath,
+      ...this.getRecentFiles().filter((recentFilePath) => recentFilePath !== filePath),
+    ];
+    writeStorage(this.storage, this.recentFilesKey, JSON.stringify(recentFiles.slice(0, MAX_RECENT_FILES)));
   }
 
-  getChatNotificationsEnabled() {
-    try {
-      return this.storage.getItem(this.chatNotificationsKey) === 'true';
-    } catch {
-      return false;
-    }
+  getSidebarVisible() {
+    return readStorage(this.storage, this.sidebarVisibleKey, null);
   }
 
-  setChatNotificationsEnabled(enabled) {
-    try {
-      this.storage.setItem(this.chatNotificationsKey, String(enabled));
-    } catch {
-      // Ignore storage errors.
-    }
+  setSidebarVisible(showSidebar) {
+    writeStorage(this.storage, this.sidebarVisibleKey, showSidebar ? 'true' : 'false');
   }
+
 }

package/src/client/infrastructure/editor-view-adapter.js

@@ -20,7 +20,14 @@ import {
   syntaxHighlighting,
 } from '@codemirror/language';
 import { languages } from '@codemirror/language-data';
-import { highlightSelectionMatches, openSearchPanel, searchKeymap } from '@codemirror/search';
+import {
+  findNext,
+  getSearchQuery,
+  highlightSelectionMatches,
+  openSearchPanel,
+  searchKeymap,
+  searchPanelOpen,
+} from '@codemirror/search';
 import { Compartment, EditorSelection, EditorState, Prec, StateEffect, StateField } from '@codemirror/state';
 import { oneDark } from '@codemirror/theme-one-dark';
 import {
@@ -54,10 +61,82 @@ const REMOTE_UPDATE_FLASH_DURATION_MS = 1350;
 const REMOTE_UPDATE_CARET_MAX_LENGTH = 160;
 const RECENT_LOCAL_INPUT_WINDOW_MS = 900;
 const TASK_LIST_MARKER_PATTERN = /^(\s*(?:>\s*)*(?:[-+*]|\d+[.)])\s+\[)( |x|X)(\])(\s.*)?$/;
+
+function openSearchPanelPreservingViewport(view) {
+  const scrollTop = view.scrollDOM.scrollTop;
+  const selection = view.state.selection;
+  const applied = openSearchPanel(view);
+
+  if (applied) {
+    requestAnimationFrame(() => {
+      if (view.dom.isConnected && view.state.selection.eq(selection)) {
+        view.scrollDOM.scrollTop = scrollTop;
+      }
+    });
+  }
+
+  return applied;
+}
+
+function getSearchQueryKey(query) {
+  return JSON.stringify([query.search, query.caseSensitive, query.regexp, query.wholeWord]);
+}
+
+function createSearchNavigationListener() {
+  let lastQueryKey = '';
+  let panelWasOpen = false;
+  let pendingFrame = 0;
+
+  return EditorView.updateListener.of((update) => {
+    const panelOpen = searchPanelOpen(update.state);
+    const query = getSearchQuery(update.state);
+    const queryKey = getSearchQueryKey(query);
+    const shouldReveal = panelOpen
+      && query.valid
+      && (!panelWasOpen || queryKey !== lastQueryKey);
+
+    panelWasOpen = panelOpen;
+    lastQueryKey = queryKey;
+
+    if (!shouldReveal) {
+      return;
+    }
+
+    if (pendingFrame) {
+      cancelAnimationFrame(pendingFrame);
+    }
+
+    pendingFrame = requestAnimationFrame(() => {
+      pendingFrame = 0;
+      if (!update.view.dom.isConnected) {
+        return;
+      }
+
+      const currentQuery = getSearchQuery(update.view.state);
+      if (
+        !searchPanelOpen(update.view.state)
+        || !currentQuery.valid
+        || getSearchQueryKey(currentQuery) !== queryKey
+      ) {
+        return;
+      }
+
+      const searchInput = update.view.dom.querySelector('.cm-search input[name="search"]');
+      const inputSelection = searchInput === update.view.root.activeElement && searchInput
+        ? { end: searchInput.selectionEnd, start: searchInput.selectionStart }
+        : null;
+      findNext(update.view);
+      if (inputSelection && searchInput?.setSelectionRange) {
+        searchInput.setSelectionRange(inputSelection.start, inputSelection.end);
+      }
+    });
+  });
+}
+
 const EDITOR_COMMANDS = Object.freeze({
   indentLess,
   indentMore,
-  openSearch: openSearchPanel,
+  openSearch: openSearchPanelPreservingViewport,
   redo,
   undo,
 });
@@ -398,11 +477,16 @@ export class EditorViewAdapter {
       crosshairCursor(),
       highlightActiveLine(),
       highlightSelectionMatches(),
+      createSearchNavigationListener(),
       keymap.of([
         ...closeBracketsKeymap,
         ...defaultKeymap,
         ...historyKeymap,
-        ...searchKeymap,
+        ...searchKeymap.map((binding) => (
+          binding.run === openSearchPanel
+            ? { ...binding, run: openSearchPanelPreservingViewport }
+            : binding
+        )),
         ...foldKeymap,
         indentWithTab,
       ]),

package/src/client/infrastructure/excalidraw-room-client.js

@@ -30,6 +30,15 @@ const DEFAULT_EMPTY_SCENE_GUARD_MS = 250;
 const DEFAULT_SAVE_THROTTLE_MS = 48;
 const DEFAULT_SYNC_TIMEOUT_MS = 4000;
 
+export const EXCALIDRAW_ROOM_CONNECTION_STATE = Object.freeze({
+  AUTHORITATIVE: 'authoritative',
+  CLOSED: 'closed',
+  CONNECTING: 'connecting',
+  DISCONNECTING: 'disconnecting',
+  FALLBACK_READONLY: 'fallback-readonly',
+  RECONNECTING_READONLY: 'reconnecting-readonly',
+});
+
 function stableJson(value) {
   if (Array.isArray(value)) {
     return `[${value.map((entry) => stableJson(entry)).join(',')}]`;
@@ -80,6 +89,7 @@ export class ExcalidrawRoomClient {
     filePath = '',
     now = () => Date.now(),
     onCollaboratorsChange = () => {},
+    onConnectionStateChange = () => {},
     onRemoteSceneJson = () => {},
     requestAnimationFrameFn = (callback) => requestAnimationFrame(callback),
     resolveWsBaseUrlFn = resolveWsBaseUrl,
@@ -96,6 +106,7 @@ export class ExcalidrawRoomClient {
     this.filePath = filePath;
     this.now = now;
     this.onCollaboratorsChange = onCollaboratorsChange;
+    this.onConnectionStateChange = onConnectionStateChange;
     this.onRemoteSceneJson = onRemoteSceneJson;
     this.requestAnimationFrameFn = requestAnimationFrameFn;
     this.resolveWsBaseUrlFn = resolveWsBaseUrlFn;
@@ -114,6 +125,7 @@ export class ExcalidrawRoomClient {
     this.awareness = null;
     this.localUser = null;
     this.handleProviderSync = null;
+    this.handleProviderStatus = null;
     this.lastSceneJson = '';
     this.sceneSyncTimer = null;
     this.sceneSyncDueAt = 0;
@@ -128,6 +140,8 @@ export class ExcalidrawRoomClient {
     this.pendingEmptySceneCandidate = null;
     this.canWriteToRoom = false;
     this.waitingForAuthoritativeSync = false;
+    this.connectionState = EXCALIDRAW_ROOM_CONNECTION_STATE.CLOSED;
+    this.hasAuthoritativeSync = false;
     this.applyingSharedSnapshotDepth = 0;
     this.suppressStructuredSceneUpdateDepth = 0;
 
@@ -149,7 +163,6 @@ export class ExcalidrawRoomClient {
         return;
       }
 
-      this.unlockRoomWrites();
       this.pendingEmptySceneCandidate = null;
       this.lastSceneJson = JSON.stringify(parseSceneJson(remoteJson));
       this.onRemoteSceneJson(this.lastSceneJson);
@@ -164,6 +177,46 @@ export class ExcalidrawRoomClient {
     return this.localUser;
   }
 
+  getConnectionState() {
+    return this.connectionState;
+  }
+
+  hasPendingWrites() {
+    return Boolean(this.pendingSceneSyncPayload);
+  }
+
+  setConnectionState(nextState) {
+    if (!Object.values(EXCALIDRAW_ROOM_CONNECTION_STATE).includes(nextState)) {
+      throw new Error(`Unsupported Excalidraw room connection state: ${nextState}`);
+    }
+
+    const previousState = this.connectionState;
+    this.connectionState = nextState;
+    this.canWriteToRoom = nextState === EXCALIDRAW_ROOM_CONNECTION_STATE.AUTHORITATIVE;
+    this.waitingForAuthoritativeSync = (
+      nextState === EXCALIDRAW_ROOM_CONNECTION_STATE.CONNECTING
+      || nextState === EXCALIDRAW_ROOM_CONNECTION_STATE.FALLBACK_READONLY
+      || nextState === EXCALIDRAW_ROOM_CONNECTION_STATE.RECONNECTING_READONLY
+    );
+
+    if (!this.canWriteToRoom && this.sceneSyncTimer !== null) {
+      this.clearTimeoutFn(this.sceneSyncTimer);
+      this.sceneSyncTimer = null;
+      this.sceneSyncDueAt = 0;
+    }
+
+    if (previousState === nextState) {
+      return;
+    }
+
+    this.onConnectionStateChange({
+      canWrite: this.canWriteToRoom,
+      hasPendingWrites: this.hasPendingWrites(),
+      previousState,
+      state: nextState,
+    });
+  }
+
   getHistoryState() {
     return {
       canRedo: false,
@@ -217,10 +270,13 @@ export class ExcalidrawRoomClient {
 
   async connect({ initialUser = null } = {}) {
     this.localUser = initialUser;
+    this.setConnectionState(EXCALIDRAW_ROOM_CONNECTION_STATE.CONNECTING);
 
     if (!this.filePath) {
       const scene = createEmptyScene();
       this.lastSceneJson = JSON.stringify(scene);
+      this.hasAuthoritativeSync = true;
+      this.setConnectionState(EXCALIDRAW_ROOM_CONNECTION_STATE.AUTHORITATIVE);
       return scene;
     }
 
@@ -245,13 +301,37 @@ export class ExcalidrawRoomClient {
 
     this.handleProviderSync = (isSynced) => {
       if (!isSynced) {
+        this.setConnectionState(
+          this.hasAuthoritativeSync
+            ? EXCALIDRAW_ROOM_CONNECTION_STATE.RECONNECTING_READONLY
+            : EXCALIDRAW_ROOM_CONNECTION_STATE.CONNECTING,
+        );
         return;
       }
 
-      this.unlockRoomWrites();
+      this.markAuthoritative();
       this.handleStructuredSceneUpdate();
     };
     this.provider.on('sync', this.handleProviderSync);
+    this.handleProviderStatus = ({ status } = {}) => {
+      if (status === 'connected') {
+        if (this.hasAuthoritativeSync && !this.provider?.synced) {
+          this.setConnectionState(EXCALIDRAW_ROOM_CONNECTION_STATE.RECONNECTING_READONLY);
+        }
+        return;
+      }
+
+      if (status === 'connecting' || status === 'disconnected') {
+        this.setConnectionState(
+          this.hasAuthoritativeSync
+            ? EXCALIDRAW_ROOM_CONNECTION_STATE.RECONNECTING_READONLY
+            : this.connectionState === EXCALIDRAW_ROOM_CONNECTION_STATE.FALLBACK_READONLY
+              ? EXCALIDRAW_ROOM_CONNECTION_STATE.FALLBACK_READONLY
+              : EXCALIDRAW_ROOM_CONNECTION_STATE.CONNECTING,
+        );
+      }
+    };
+    this.provider.on('status', this.handleProviderStatus);
 
     const didInitialSyncFinish = await this.waitForSync(this.provider, this.syncTimeoutMs);
 
@@ -272,9 +352,12 @@ export class ExcalidrawRoomClient {
       initialJson = JSON.stringify(createEmptyScene());
     }
 
-    this.waitingForAuthoritativeSync = usedApiFallback && !didInitialSyncFinish;
-    this.canWriteToRoom = !this.waitingForAuthoritativeSync;
     this.lastSceneJson = JSON.stringify(parseSceneJson(initialJson));
+    if (didInitialSyncFinish || this.provider?.synced) {
+      this.markAuthoritative();
+    } else {
+      this.setConnectionState(EXCALIDRAW_ROOM_CONNECTION_STATE.FALLBACK_READONLY);
+    }
     if (!usedApiFallback && this.canWriteToRoom && !isExcalidrawRoomDocStructured(this.ydoc)) {
       this.ydoc.transact(() => {
         this.replaceStructuredSceneWithinTransaction(this.lastSceneJson);
@@ -375,9 +458,9 @@ export class ExcalidrawRoomClient {
     });
   }
 
-  unlockRoomWrites() {
-    this.waitingForAuthoritativeSync = false;
-    this.canWriteToRoom = true;
+  markAuthoritative() {
+    this.hasAuthoritativeSync = true;
+    this.setConnectionState(EXCALIDRAW_ROOM_CONNECTION_STATE.AUTHORITATIVE);
     if (!this.getStructuredSceneJson() && this.lastSceneJson) {
       this.commitSceneJson(this.lastSceneJson, {
         origin: 'excalidraw-authoritative-seed',
@@ -469,20 +552,25 @@ export class ExcalidrawRoomClient {
   }
 
   scheduleSceneSync(elements, appState, files) {
+    if (!this.canWriteToRoom) {
+      return false;
+    }
+
     this.pendingSceneSyncPayload = {
       appState,
       baseSceneJson: this.lastSceneJson,
       elements,
       files,
     };
-    if (!this.canWriteToRoom) {
-      return;
-    }
-
     this.scheduleSceneSyncFlush();
+    return true;
   }
 
   scheduleSceneSyncFlush() {
+    if (!this.canWriteToRoom) {
+      return false;
+    }
+
     const elapsed = this.now() - this.lastSceneSyncAt;
     const delay = Math.max(0, this.saveThrottleMs - elapsed);
     const dueAt = this.now() + delay;
@@ -499,11 +587,12 @@ export class ExcalidrawRoomClient {
       this.sceneSyncDueAt = 0;
       this.flushSceneSync();
     }, delay);
+    return true;
   }
 
   flushSceneSync() {
-    if (!this.ydoc || !this.pendingSceneSyncPayload) {
-      return;
+    if (!this.canWriteToRoom || !this.ydoc || !this.pendingSceneSyncPayload) {
+      return false;
     }
 
     const {
@@ -544,7 +633,7 @@ export class ExcalidrawRoomClient {
 
     if (!hasChanges) {
       this.pendingEmptySceneCandidate = null;
-      return;
+      return false;
     }
 
     const json = JSON.stringify(sceneData);
@@ -558,6 +647,7 @@ export class ExcalidrawRoomClient {
     if (this.pendingSceneSyncPayload) {
       this.scheduleSceneSyncFlush();
     }
+    return true;
   }
 
   hasRemoteCollaborators() {
@@ -727,6 +817,10 @@ export class ExcalidrawRoomClient {
   commitSceneJson(nextJson, {
     origin = 'excalidraw-room-write',
   } = {}) {
+    if (!this.canWriteToRoom) {
+      return false;
+    }
+
     const normalizedJson = JSON.stringify(parseSceneJson(nextJson));
     if (!this.ydoc) {
       const didChange = normalizedJson !== this.lastSceneJson;
@@ -755,6 +849,7 @@ export class ExcalidrawRoomClient {
 
   disconnect() {
     this.flushSceneSync();
+    this.setConnectionState(EXCALIDRAW_ROOM_CONNECTION_STATE.DISCONNECTING);
     this.clearTimeoutFn(this.sceneSyncTimer);
     this.sceneSyncTimer = null;
     this.sceneSyncDueAt = 0;
@@ -788,7 +883,11 @@ export class ExcalidrawRoomClient {
     if (this.provider && this.handleProviderSync) {
       this.provider.off('sync', this.handleProviderSync);
     }
+    if (this.provider && this.handleProviderStatus) {
+      this.provider.off('status', this.handleProviderStatus);
+    }
     this.handleProviderSync = null;
+    this.handleProviderStatus = null;
     this.provider?.disconnect();
     this.provider?.destroy();
     this.provider = null;
@@ -800,8 +899,8 @@ export class ExcalidrawRoomClient {
     this.roomFiles = null;
     this.roomAppState = null;
     this.localUser = null;
-    this.canWriteToRoom = false;
-    this.waitingForAuthoritativeSync = false;
+    this.hasAuthoritativeSync = false;
+    this.setConnectionState(EXCALIDRAW_ROOM_CONNECTION_STATE.CLOSED);
     this.applyingSharedSnapshotDepth = 0;
     this.suppressStructuredSceneUpdateDepth = 0;
   }

package/src/client/infrastructure/git-api-client.js

@@ -1,28 +1,5 @@
 import { resolveApiUrl } from '../domain/runtime-paths.js';
-
-function createRequestHeaders(requestId, headers = {}) {
-  const nextHeaders = { ...headers };
-  if (requestId) {
-    nextHeaders['X-CollabMD-Request-Id'] = String(requestId);
-  }
-
-  return nextHeaders;
-}
-
-async function parseJsonResponse(response, fallbackError) {
-  const data = await response.json().catch(() => ({}));
-  if (!response.ok || data.ok === false) {
-    const error = new Error(data.error || fallbackError);
-    error.status = response.status;
-    error.body = data;
-    if (typeof data?.code === 'string') {
-      error.code = data.code;
-    }
-    throw error;
-  }
-
-  return data;
-}
+import { createRequestHeaders, parseApiResponse } from './api-client-utils.js';
 
 function createSearchParams(values = {}) {
   const params = new URLSearchParams();
@@ -39,24 +16,24 @@ function createSearchParams(values = {}) {
 export class GitApiClient {
   async readStatus({ force = false } = {}) {
     const response = await fetch(resolveApiUrl(`/git/status${force ? '?force=true' : ''}`));
-    return parseJsonResponse(response, 'Failed to load git status');
+    return parseApiResponse(response, 'Failed to load git status');
   }
 
   async readPullBackups() {
     const response = await fetch(resolveApiUrl('/git/pull-backups'));
-    return parseJsonResponse(response, 'Failed to load pull backups');
+    return parseApiResponse(response, 'Failed to load pull backups');
   }
 
   async readHistory({ limit, offset } = {}) {
     const params = createSearchParams({ limit, offset });
     const response = await fetch(resolveApiUrl(`/git/history?${params.toString()}`));
-    return parseJsonResponse(response, 'Failed to load git history');
+    return parseApiResponse(response, 'Failed to load git history');
   }
 
   async readFileHistory({ path, limit, offset } = {}) {
     const params = createSearchParams({ limit, offset, path });
     const response = await fetch(resolveApiUrl(`/git/file-history?${params.toString()}`));
-    return parseJsonResponse(response, 'Failed to load file history');
+    return parseApiResponse(response, 'Failed to load file history');
   }
 
   async readDiff({
@@ -72,7 +49,7 @@ export class GitApiClient {
       scope,
     });
     const response = await fetch(resolveApiUrl(`/git/diff?${params.toString()}`));
-    return parseJsonResponse(response, 'Failed to load git diff');
+    return parseApiResponse(response, 'Failed to load git diff');
   }
 
   async readCommit({
@@ -88,13 +65,13 @@ export class GitApiClient {
       path,
     });
     const response = await fetch(resolveApiUrl(`/git/commit?${params.toString()}`));
-    return parseJsonResponse(response, 'Failed to load git commit');
+    return parseApiResponse(response, 'Failed to load git commit');
   }
 
   async readFileSnapshot({ hash, path } = {}) {
     const params = createSearchParams({ hash, path });
     const response = await fetch(resolveApiUrl(`/git/file-snapshot?${params.toString()}`));
-    return parseJsonResponse(response, 'Failed to load historical file preview');
+    return parseApiResponse(response, 'Failed to load historical file preview');
   }
 
   async stageFile({ path, requestId = null } = {}) {
@@ -127,7 +104,7 @@ export class GitApiClient {
       headers: createRequestHeaders(requestId, { 'Content-Type': 'application/json' }),
       method: 'POST',
     });
-    return parseJsonResponse(response, fallbackError);
+    return parseApiResponse(response, fallbackError);
   }
 }