refactor repo api to trpc

charlesvien · charlesvien · commit 16e41dc93d5d · 2025-12-17T09:40:39.000-08:00
diff --git a/apps/array/src/main/preload.ts b/apps/array/src/main/preload.ts
@@ -51,22 +51,6 @@ interface AgentStartParams {
 }
 
 contextBridge.exposeInMainWorld("electronAPI", {
-  // Repo API
-  validateRepo: (directoryPath: string): Promise<boolean> =>
-    ipcRenderer.invoke("validate-repo", directoryPath),
-  cloneRepository: (
-    repoUrl: string,
-    targetPath: string,
-    cloneId: string,
-  ): Promise<{ cloneId: string }> =>
-    ipcRenderer.invoke("clone-repository", repoUrl, targetPath, cloneId),
-  onCloneProgress: (
-    cloneId: string,
-    listener: (event: {
-      status: "cloning" | "complete" | "error";
-      message: string;
-    }) => void,
-  ): (() => void) => createIpcListener(`clone-progress:${cloneId}`, listener),
   // Agent API
   agentStart: async (
     params: AgentStartParams,
diff --git a/apps/array/src/main/services/git.ts b/apps/array/src/main/services/git.ts
@@ -662,17 +662,6 @@ export const detectSSHError = (output: string): string | undefined => {
 };
 
 export function registerGitIpc(): void {
-  ipcMain.handle(
-    "validate-repo",
-    async (
-      _event: IpcMainInvokeEvent,
-      directoryPath: string,
-    ): Promise<boolean> => {
-      if (!directoryPath) return false;
-      return isGitRepository(directoryPath);
-    },
-  );
-
   ipcMain.handle(
     "get-changed-files-head",
     async (
diff --git a/apps/array/src/main/services/git/schemas.ts b/apps/array/src/main/services/git/schemas.ts
@@ -15,3 +15,31 @@ export const detectRepoOutput = z
 
 export type DetectRepoInput = z.infer<typeof detectRepoInput>;
 export type DetectRepoResult = z.infer<typeof detectRepoOutput>;
+
+// validateRepo schemas
+export const validateRepoInput = z.object({
+  directoryPath: z.string(),
+});
+
+export const validateRepoOutput = z.boolean();
+
+// cloneRepository schemas
+export const cloneRepositoryInput = z.object({
+  repoUrl: z.string(),
+  targetPath: z.string(),
+  cloneId: z.string(),
+});
+
+export const cloneRepositoryOutput = z.object({
+  cloneId: z.string(),
+});
+
+export const cloneProgressStatus = z.enum(["cloning", "complete", "error"]);
+
+export const cloneProgressPayload = z.object({
+  cloneId: z.string(),
+  status: cloneProgressStatus,
+  message: z.string(),
+});
+
+export type CloneProgressPayload = z.infer<typeof cloneProgressPayload>;
diff --git a/apps/array/src/main/services/git/service.ts b/apps/array/src/main/services/git/service.ts
@@ -1,13 +1,27 @@
-import { execFile } from "node:child_process";
+import { exec, execFile, spawn } from "node:child_process";
 import { promisify } from "node:util";
 import { injectable } from "inversify";
-import type { DetectRepoResult } from "./schemas.js";
+import { TypedEventEmitter } from "../../lib/typed-event-emitter.js";
+import type { CloneProgressPayload, DetectRepoResult } from "./schemas.js";
 import { parseGitHubUrl } from "./utils.js";
 
+const execAsync = promisify(exec);
 const execFileAsync = promisify(execFile);
 
+export const GitServiceEvent = {
+  CloneProgress: "cloneProgress",
+} as const;
+
+export interface GitServiceEvents {
+  [GitServiceEvent.CloneProgress]: CloneProgressPayload;
+}
+
 @injectable()
-export class GitService {
+export class GitService extends TypedEventEmitter<GitServiceEvents> {
+  constructor() {
+    super();
+  }
+
   public async detectRepo(
     directoryPath: string,
   ): Promise<DetectRepoResult | null> {
@@ -30,9 +44,70 @@ export class GitService {
     };
   }
 
+  public async validateRepo(directoryPath: string): Promise<boolean> {
+    if (!directoryPath) return false;
+
+    try {
+      await execAsync("git rev-parse --is-inside-work-tree", {
+        cwd: directoryPath,
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  public async cloneRepository(
+    repoUrl: string,
+    targetPath: string,
+    cloneId: string,
+  ): Promise<{ cloneId: string }> {
+    const emitProgress = (
+      status: CloneProgressPayload["status"],
+      message: string,
+    ) => {
+      this.emit(GitServiceEvent.CloneProgress, { cloneId, status, message });
+    };
+
+    emitProgress("cloning", `Starting clone of ${repoUrl}...`);
+
+    const gitProcess = spawn("git", ["clone", "--progress", repoUrl, targetPath], {
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+
+    gitProcess.stderr.on("data", (data: Buffer) => {
+      const output = data.toString();
+      emitProgress("cloning", output.trim());
+    });
+
+    gitProcess.stdout.on("data", (data: Buffer) => {
+      const output = data.toString();
+      emitProgress("cloning", output.trim());
+    });
+
+    return new Promise((resolve, reject) => {
+      gitProcess.on("close", (code) => {
+        if (code === 0) {
+          emitProgress("complete", "Clone completed successfully");
+          resolve({ cloneId });
+        } else {
+          const errorMsg = `Clone failed with exit code ${code}`;
+          emitProgress("error", errorMsg);
+          reject(new Error(errorMsg));
+        }
+      });
+
+      gitProcess.on("error", (err) => {
+        const errorMsg = `Clone failed: ${err.message}`;
+        emitProgress("error", errorMsg);
+        reject(err);
+      });
+    });
+  }
+
   public async getRemoteUrl(directoryPath: string): Promise<string | null> {
     try {
-      const { stdout } = await execFileAsync("git remote get-url origin", {
+      const { stdout } = await execFileAsync("git", ["remote", "get-url", "origin"], {
         cwd: directoryPath,
       });
       return stdout.trim();
@@ -43,7 +118,7 @@ export class GitService {
 
   public async getCurrentBranch(directoryPath: string): Promise<string | null> {
     try {
-      const { stdout } = await execFileAsync("git branch --show-current", {
+      const { stdout } = await execFileAsync("git", ["branch", "--show-current"], {
         cwd: directoryPath,
       });
       return stdout.trim();
diff --git a/apps/array/src/main/trpc/routers/git.ts b/apps/array/src/main/trpc/routers/git.ts
@@ -1,10 +1,19 @@
+import { on } from "node:events";
 import { container } from "../../di/container.js";
 import { MAIN_TOKENS } from "../../di/tokens.js";
 import {
+  type CloneProgressPayload,
+  cloneRepositoryInput,
+  cloneRepositoryOutput,
   detectRepoInput,
   detectRepoOutput,
+  validateRepoInput,
+  validateRepoOutput,
 } from "../../services/git/schemas.js";
-import type { GitService } from "../../services/git/service.js";
+import {
+  GitServiceEvent,
+  type GitService,
+} from "../../services/git/service.js";
 import { publicProcedure, router } from "../trpc.js";
 
 const getService = () => container.get<GitService>(MAIN_TOKENS.GitService);
@@ -14,4 +23,28 @@ export const gitRouter = router({
     .input(detectRepoInput)
     .output(detectRepoOutput)
     .query(({ input }) => getService().detectRepo(input.directoryPath)),
+
+  validateRepo: publicProcedure
+    .input(validateRepoInput)
+    .output(validateRepoOutput)
+    .query(({ input }) => getService().validateRepo(input.directoryPath)),
+
+  cloneRepository: publicProcedure
+    .input(cloneRepositoryInput)
+    .output(cloneRepositoryOutput)
+    .mutation(({ input }) =>
+      getService().cloneRepository(input.repoUrl, input.targetPath, input.cloneId),
+    ),
+
+  onCloneProgress: publicProcedure.subscription(async function* (opts) {
+    const service = getService();
+    const options = opts.signal ? { signal: opts.signal } : undefined;
+    for await (const [payload] of on(
+      service,
+      GitServiceEvent.CloneProgress,
+      options,
+    )) {
+      yield payload as CloneProgressPayload;
+    }
+  }),
 });
diff --git a/apps/array/src/renderer/features/task-detail/stores/taskExecutionStore.ts b/apps/array/src/renderer/features/task-detail/stores/taskExecutionStore.ts
@@ -2,6 +2,7 @@ import { useSettingsStore } from "@features/settings/stores/settingsStore";
 import type { Task, WorkspaceMode } from "@shared/types";
 import { repositoryWorkspaceStore } from "@stores/repositoryWorkspaceStore";
 import { useTaskDirectoryStore } from "@stores/taskDirectoryStore";
+import { trpcVanilla } from "@renderer/trpc/client";
 import { getTaskRepository } from "@utils/repository";
 import { create } from "zustand";
 import { persist } from "zustand/middleware";
@@ -114,8 +115,8 @@ export const useTaskExecutionStore = create<TaskExecutionStore>()(
             repositoryWorkspaceStore.getState().selectRepository(repository);
           }
 
-          window.electronAPI
-            ?.validateRepo(storedDirectory)
+          trpcVanilla.git.validateRepo
+            .query({ directoryPath: storedDirectory })
             .then((exists) => {
               store.updateTaskState(taskId, { repoExists: exists });
             })
@@ -132,9 +133,9 @@ export const useTaskExecutionStore = create<TaskExecutionStore>()(
         if (!taskState.repoPath) return;
 
         try {
-          const exists = await window.electronAPI?.validateRepo(
-            taskState.repoPath,
-          );
+          const exists = await trpcVanilla.git.validateRepo.query({
+            directoryPath: taskState.repoPath,
+          });
           store.updateTaskState(taskId, { repoExists: exists });
         } catch {
           store.updateTaskState(taskId, { repoExists: false });
diff --git a/apps/array/src/renderer/stores/cloneStore.ts b/apps/array/src/renderer/stores/cloneStore.ts
@@ -1,4 +1,5 @@
 import { useTaskExecutionStore } from "@features/task-detail/stores/taskExecutionStore";
+import { trpcVanilla } from "@renderer/trpc/client";
 import { useTaskDirectoryStore } from "@stores/taskDirectoryStore";
 import { create } from "zustand";
 
@@ -26,6 +27,33 @@ interface CloneStore {
 const REMOVE_DELAY_SUCCESS_MS = 3000;
 const REMOVE_DELAY_ERROR_MS = 5000;
 
+// Global subscription to clone progress events
+let globalSubscription: { unsubscribe: () => void } | null = null;
+let subscriptionRefCount = 0;
+
+const ensureGlobalSubscription = (store: CloneStore) => {
+  if (globalSubscription) {
+    subscriptionRefCount++;
+    return;
+  }
+
+  subscriptionRefCount = 1;
+  globalSubscription = trpcVanilla.git.onCloneProgress.subscribe(undefined, {
+    onData: (event) => {
+      store.updateClone(event.cloneId, event.status, event.message);
+    },
+  });
+};
+
+const releaseGlobalSubscription = () => {
+  subscriptionRefCount--;
+  if (subscriptionRefCount <= 0 && globalSubscription) {
+    globalSubscription.unsubscribe();
+    globalSubscription = null;
+    subscriptionRefCount = 0;
+  }
+};
+
 export const cloneStore = create<CloneStore>((set, get) => {
   const updateTaskRepoExists = (targetPath: string, exists: boolean) => {
     const taskStore = useTaskExecutionStore.getState();
@@ -66,26 +94,14 @@ export const cloneStore = create<CloneStore>((set, get) => {
     window.setTimeout(() => get().removeClone(cloneId), REMOVE_DELAY_ERROR_MS);
   };
 
-  return {
+  const store: CloneStore = {
     operations: {},
 
     startClone: (cloneId, repository, targetPath) => {
-      const unsubscribe = window.electronAPI.onCloneProgress(
-        cloneId,
-        (event) => {
-          get().updateClone(cloneId, event.status, event.message);
-
-          const operation = get().operations[cloneId];
-          if (!operation) return;
-
-          if (event.status === "complete") {
-            handleComplete(cloneId, repository);
-          } else if (event.status === "error") {
-            handleError(cloneId, repository, event.message);
-          }
-        },
-      );
+      // Ensure global subscription is active
+      ensureGlobalSubscription(store);
 
+      // Set up clone operation with progress handler
       set((state) => ({
         operations: {
           ...state.operations,
@@ -95,10 +111,22 @@ export const cloneStore = create<CloneStore>((set, get) => {
             targetPath,
             status: "cloning",
             latestMessage: `Cloning ${repository}...`,
-            unsubscribe,
+            unsubscribe: releaseGlobalSubscription,
           },
         },
       }));
+
+      // Start the clone operation via tRPC mutation
+      trpcVanilla.git.cloneRepository
+        .mutate({ repoUrl: repository, targetPath, cloneId })
+        .then(() => {
+          handleComplete(cloneId, repository);
+        })
+        .catch((err) => {
+          const message = err instanceof Error ? err.message : "Clone failed";
+          get().updateClone(cloneId, "error", message);
+          handleError(cloneId, repository, message);
+        });
     },
 
     updateClone: (cloneId, status, message) => {
@@ -140,4 +168,6 @@ export const cloneStore = create<CloneStore>((set, get) => {
         (op) => op.repository === repository,
       ) ?? null,
   };
+
+  return store;
 });
diff --git a/apps/array/src/renderer/stores/taskDirectoryStore.ts b/apps/array/src/renderer/stores/taskDirectoryStore.ts
@@ -1,3 +1,4 @@
+import { trpcVanilla } from "@renderer/trpc/client";
 import { omitKey } from "@utils/object";
 import { expandTildePath } from "@utils/path";
 import { create } from "zustand";
@@ -60,8 +61,9 @@ export const useTaskDirectoryStore = create<TaskDirectoryState>()(
         const { lastUsedDirectory } = get();
         if (!lastUsedDirectory) return;
 
-        const exists =
-          await window.electronAPI?.validateRepo(lastUsedDirectory);
+        const exists = await trpcVanilla.git.validateRepo.query({
+          directoryPath: lastUsedDirectory,
+        });
         if (!exists) {
           set({ lastUsedDirectory: null });
         }
diff --git a/apps/array/src/renderer/types/electron.d.ts b/apps/array/src/renderer/types/electron.d.ts
