Merge remote-tracking branch 'origin/main' into 12-12-refactor_sessions

Author: jonathanlab

apps/array/package.json

@@ -52,7 +52,6 @@
     "autoprefixer": "^10.4.17",
     "electron": "^30.0.0",
     "husky": "^9.1.7",
-    "immer": "^11.0.1",
     "jsdom": "^26.0.0",
     "lint-staged": "^15.5.2",
     "postcss": "^8.4.33",
@@ -126,6 +125,7 @@
     "electron-store": "^11.0.0",
     "file-icon": "^6.0.0",
     "idb-keyval": "^6.2.2",
+    "immer": "^11.0.1",
     "is-glob": "^4.0.3",
     "micromatch": "^4.0.5",
     "node-addon-api": "^8.5.0",
@@ -143,6 +143,7 @@
     "remark-gfm": "^4.0.1",
     "sonner": "^2.0.7",
     "uuid": "^9.0.1",
+    "vscode-icons-js": "^11.6.1",
     "zod": "^4.1.12",
     "zustand": "^4.5.0"
   }

apps/array/src/api/fetcher.test.ts

@@ -0,0 +1,105 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { buildApiFetcher } from "./fetcher";
+
+describe("buildApiFetcher", () => {
+  const mockFetch = vi.fn();
+  const mockInput = {
+    method: "get" as const,
+    url: new URL("https://api.example.com/test"),
+    path: "/test",
+  };
+  const ok = (data = {}) => ({
+    ok: true,
+    status: 200,
+    json: () => Promise.resolve(data),
+  });
+  const err = (status: number) => ({
+    ok: false,
+    status,
+    json: () => Promise.resolve({ error: status }),
+  });
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    vi.stubGlobal("fetch", mockFetch);
+  });
+
+  it("makes request with bearer token", async () => {
+    mockFetch.mockResolvedValueOnce(ok());
+    const fetcher = buildApiFetcher({ apiToken: "my-token" });
+
+    await fetcher.fetch(mockInput);
+
+    expect(mockFetch.mock.calls[0][1].headers.get("Authorization")).toBe(
+      "Bearer my-token",
+    );
+  });
+
+  it("retries with new token on 401", async () => {
+    const onTokenRefresh = vi.fn().mockResolvedValue("new-token");
+    mockFetch.mockResolvedValueOnce(err(401)).mockResolvedValueOnce(ok());
+
+    const fetcher = buildApiFetcher({ apiToken: "old-token", onTokenRefresh });
+    const response = await fetcher.fetch(mockInput);
+
+    expect(response.ok).toBe(true);
+    expect(onTokenRefresh).toHaveBeenCalledTimes(1);
+    expect(mockFetch.mock.calls[1][1].headers.get("Authorization")).toBe(
+      "Bearer new-token",
+    );
+  });
+
+  it("uses refreshed token for subsequent requests", async () => {
+    const onTokenRefresh = vi.fn().mockResolvedValue("refreshed-token");
+    mockFetch
+      .mockResolvedValueOnce(err(401))
+      .mockResolvedValueOnce(ok())
+      .mockResolvedValueOnce(ok());
+
+    const fetcher = buildApiFetcher({
+      apiToken: "initial-token",
+      onTokenRefresh,
+    });
+    await fetcher.fetch(mockInput);
+    await fetcher.fetch(mockInput);
+
+    expect(mockFetch.mock.calls[2][1].headers.get("Authorization")).toBe(
+      "Bearer refreshed-token",
+    );
+  });
+
+  it("does not refresh on non-401 errors", async () => {
+    const onTokenRefresh = vi.fn();
+    mockFetch.mockResolvedValueOnce(err(403));
+
+    const fetcher = buildApiFetcher({ apiToken: "token", onTokenRefresh });
+
+    await expect(fetcher.fetch(mockInput)).rejects.toThrow("[403]");
+    expect(onTokenRefresh).not.toHaveBeenCalled();
+  });
+
+  it("throws on 401 without refresh callback", async () => {
+    mockFetch.mockResolvedValueOnce(err(401));
+    const fetcher = buildApiFetcher({ apiToken: "token" });
+
+    await expect(fetcher.fetch(mockInput)).rejects.toThrow("[401]");
+  });
+
+  it("throws when refresh fails", async () => {
+    const onTokenRefresh = vi.fn().mockRejectedValue(new Error("failed"));
+    mockFetch.mockResolvedValueOnce(err(401));
+
+    const fetcher = buildApiFetcher({ apiToken: "token", onTokenRefresh });
+
+    await expect(fetcher.fetch(mockInput)).rejects.toThrow("[401]");
+  });
+
+  it("handles network errors", async () => {
+    mockFetch.mockRejectedValueOnce(new Error("Network failure"));
+    const fetcher = buildApiFetcher({ apiToken: "token" });
+
+    await expect(fetcher.fetch(mockInput)).rejects.toThrow(
+      "Network request failed",
+    );
+  });
+});

apps/array/src/api/fetcher.ts

@@ -4,6 +4,8 @@ export const buildApiFetcher: (config: {
   apiToken: string;
   onTokenRefresh?: () => Promise<string>;
 }) => Parameters<typeof createApiClient>[0] = (config) => {
+  let currentToken = config.apiToken;
+
   const makeRequest = async (
     input: Parameters<Parameters<typeof createApiClient>[0]["fetch"]>[0],
     token: string,
@@ -51,13 +53,14 @@ export const buildApiFetcher: (config: {
 
   return {
     fetch: async (input) => {
-      let response = await makeRequest(input, config.apiToken);
+      let response = await makeRequest(input, currentToken);
 
       // Handle 401 with automatic token refresh
       if (!response.ok && response.status === 401 && config.onTokenRefresh) {
         try {
           const newToken = await config.onTokenRefresh();
-          response = await makeRequest(input, newToken);
+          currentToken = newToken;
+          response = await makeRequest(input, currentToken);
         } catch {
           // Token refresh failed - throw the original 401 error
           const errorResponse = await response.json();

apps/array/src/main/preload.ts

@@ -297,6 +297,33 @@ contextBridge.exposeInMainWorld("electronAPI", {
     fileStatus: string,
   ): Promise<void> =>
     ipcRenderer.invoke("discard-file-changes", repoPath, filePath, fileStatus),
+  getGitSyncStatus: (
+    repoPath: string,
+  ): Promise<{
+    ahead: number;
+    behind: number;
+    hasRemote: boolean;
+    currentBranch: string | null;
+    isFeatureBranch: boolean;
+  }> => ipcRenderer.invoke("get-git-sync-status", repoPath),
+  getLatestCommit: (
+    repoPath: string,
+  ): Promise<{
+    sha: string;
+    shortSha: string;
+    message: string;
+    author: string;
+    date: string;
+  } | null> => ipcRenderer.invoke("get-latest-commit", repoPath),
+  getGitRepoInfo: (
+    repoPath: string,
+  ): Promise<{
+    organization: string;
+    repository: string;
+    currentBranch: string | null;
+    defaultBranch: string;
+    compareUrl: string | null;
+  } | null> => ipcRenderer.invoke("get-git-repo-info", repoPath),
   listDirectory: (
     dirPath: string,
   ): Promise<

apps/array/src/main/services/git.ts

@@ -383,6 +383,158 @@ export interface DiffStats {
   linesRemoved: number;
 }
 
+export interface GitSyncStatus {
+  ahead: number;
+  behind: number;
+  hasRemote: boolean;
+  currentBranch: string | null;
+  isFeatureBranch: boolean;
+}
+
+export interface GitCommitInfo {
+  sha: string;
+  shortSha: string;
+  message: string;
+  author: string;
+  date: string;
+}
+
+export interface GitRepoInfo {
+  organization: string;
+  repository: string;
+  currentBranch: string | null;
+  defaultBranch: string;
+  compareUrl: string | null;
+}
+
+const getLatestCommit = async (
+  directoryPath: string,
+): Promise<GitCommitInfo | null> => {
+  try {
+    const { stdout } = await execAsync(
+      'git log -1 --format="%H|%h|%s|%an|%aI"',
+      { cwd: directoryPath },
+    );
+
+    const [sha, shortSha, message, author, date] = stdout.trim().split("|");
+    if (!sha) return null;
+
+    return { sha, shortSha, message, author, date };
+  } catch {
+    return null;
+  }
+};
+
+const getGitRepoInfo = async (
+  directoryPath: string,
+): Promise<GitRepoInfo | null> => {
+  try {
+    const remoteUrl = await getRemoteUrl(directoryPath);
+    if (!remoteUrl) return null;
+
+    const parsed = parseGitHubUrl(remoteUrl);
+    if (!parsed) return null;
+
+    const currentBranch = await getCurrentBranch(directoryPath);
+    const defaultBranch = await getDefaultBranch(directoryPath);
+
+    let compareUrl: string | null = null;
+    if (currentBranch && currentBranch !== defaultBranch) {
+      compareUrl = `https://github.com/${parsed.organization}/${parsed.repository}/compare/${defaultBranch}...${currentBranch}?expand=1`;
+    }
+
+    return {
+      organization: parsed.organization,
+      repository: parsed.repository,
+      currentBranch: currentBranch ?? null,
+      defaultBranch,
+      compareUrl,
+    };
+  } catch {
+    return null;
+  }
+};
+
+const getGitSyncStatus = async (
+  directoryPath: string,
+): Promise<GitSyncStatus> => {
+  try {
+    const currentBranch = await getCurrentBranch(directoryPath);
+    if (!currentBranch) {
+      return {
+        ahead: 0,
+        behind: 0,
+        hasRemote: false,
+        currentBranch: null,
+        isFeatureBranch: false,
+      };
+    }
+
+    const defaultBranch = await getDefaultBranch(directoryPath);
+    const isFeatureBranch = currentBranch !== defaultBranch;
+
+    try {
+      const { stdout: upstream } = await execAsync(
+        `git rev-parse --abbrev-ref ${currentBranch}@{upstream}`,
+        { cwd: directoryPath },
+      );
+
+      const upstreamBranch = upstream.trim();
+      if (!upstreamBranch) {
+        return {
+          ahead: 0,
+          behind: 0,
+          hasRemote: false,
+          currentBranch,
+          isFeatureBranch,
+        };
+      }
+
+      // Use --quiet to suppress output, ignore errors (network may be unavailable)
+      try {
+        await execAsync("git fetch --quiet", {
+          cwd: directoryPath,
+          timeout: 10000,
+        });
+      } catch {
+        // Fetch failed (likely offline), continue with stale data
+      }
+
+      const { stdout: revList } = await execAsync(
+        `git rev-list --left-right --count ${currentBranch}...${upstreamBranch}`,
+        { cwd: directoryPath },
+      );
+
+      const [ahead, behind] = revList.trim().split("\t").map(Number);
+
+      return {
+        ahead: ahead || 0,
+        behind: behind || 0,
+        hasRemote: true,
+        currentBranch,
+        isFeatureBranch,
+      };
+    } catch {
+      return {
+        ahead: 0,
+        behind: 0,
+        hasRemote: false,
+        currentBranch,
+        isFeatureBranch,
+      };
+    }
+  } catch (error) {
+    log.error("Error getting git sync status:", error);
+    return {
+      ahead: 0,
+      behind: 0,
+      hasRemote: false,
+      currentBranch: null,
+      isFeatureBranch: false,
+    };
+  }
+};
+
 const discardFileChanges = async (
   directoryPath: string,
   filePath: string,
@@ -857,4 +1009,34 @@ export function registerGitIpc(
       return discardFileChanges(directoryPath, filePath, fileStatus);
     },
   );
+
+  ipcMain.handle(
+    "get-git-sync-status",
+    async (
+      _event: IpcMainInvokeEvent,
+      directoryPath: string,
+    ): Promise<GitSyncStatus> => {
+      return getGitSyncStatus(directoryPath);
+    },
+  );
+
+  ipcMain.handle(
+    "get-latest-commit",
+    async (
+      _event: IpcMainInvokeEvent,
+      directoryPath: string,
+    ): Promise<GitCommitInfo | null> => {
+      return getLatestCommit(directoryPath);
+    },
+  );
+
+  ipcMain.handle(
+    "get-git-repo-info",
+    async (
+      _event: IpcMainInvokeEvent,
+      directoryPath: string,
+    ): Promise<GitRepoInfo | null> => {
+      return getGitRepoInfo(directoryPath);
+    },
+  );
 }