Changed git repositories to support multiple repositories at once

Author: kevinwang5658

package-lock.json

@@ -70,7 +70,7 @@
     "ts-node": "^10.9.1",
     "tslib": "^2.6.2",
     "tsx": "^4.7.2",
-    "typescript": "^5",
+    "typescript": "5.9.3",
     "vitest": "^1.4.0"
   },
   "optionalDependencies": {

package.json

@@ -10,6 +10,13 @@
       "type": "string",
       "description": "Remote repository to clone repo from."
     },
+    "repositories": {
+      "type": "array",
+      "description": "Remote repositories to clone. This is a convenience property for cloning multiple repositories at once.",
+      "items": {
+        "type": "string"
+      }
+    },
     "parentDirectory": {
       "type": "string",
       "description": "Parent directory to clone into. The folder name will use default git semantics which extracts the last part of the clone url. Only one of parentDirectory or directory can be specified"
@@ -26,6 +33,6 @@
   "additionalProperties": false,
   "oneOf": [
     { "required": ["repository", "directory"] },
-    { "required": ["repository", "parentDirectory"] }
+    { "required": ["repositories", "parentDirectory"] }
   ]
 }

src/resources/git/repository/git-repository-schema.json

@@ -5,53 +5,74 @@ import path from 'node:path';
 import { FileUtils } from '../../../utils/file-utils.js';
 import Schema from './git-repository-schema.json';
 
-export interface GitCloneConfig extends ResourceConfig {
+export interface GitRepositoryConfig extends ResourceConfig {
   autoVerifySSH: boolean
   directory?: string,
   parentDirectory?: string,
+  repositories?: string[],
   repository: string,
 }
 
-export class GitCloneResource extends Resource<GitCloneConfig> {
-  getSettings(): ResourceSettings<GitCloneConfig> {
+export class GitRepositoryResource extends Resource<GitRepositoryConfig> {
+  getSettings(): ResourceSettings<GitRepositoryConfig> {
     return {
       id: 'git-repository',
       operatingSystems: [OS.Darwin, OS.Linux],
       schema: Schema,
       parameterSettings: {
+        repositories: { type: 'array' },
         parentDirectory: { type: 'directory' },
         directory: { type: 'directory' },
         autoVerifySSH: { type: 'boolean', default: true, setting: true },
       },
-      importAndDestroy:{
+      importAndDestroy: {
         requiredParameters: ['directory']
       },
       allowMultiple: {
         matcher: (desired, current) => {
           const desiredPath = desired.parentDirectory
-            ? path.resolve(desired.parentDirectory, this.extractBasename(desired.repository!)!)
+            ? desired.repositories?.map((r) => path.resolve(desired.parentDirectory!, this.extractBasename(r)!))
             : path.resolve(desired.directory!);
 
           const currentPath = current.parentDirectory
-            ? path.resolve(current.parentDirectory, this.extractBasename(current.repository!)!)
+            ? current.repositories?.map((r) => path.resolve(current.parentDirectory!, this.extractBasename(r)!))
             : path.resolve(current.directory!);
 
           const isNotCaseSensitive = process.platform === 'darwin';
           if (isNotCaseSensitive) {
-            return desiredPath.toLowerCase() === currentPath.toLowerCase()
+            if (!Array.isArray(desiredPath) && !Array.isArray(currentPath)) {
+              return desiredPath!.toLowerCase() === currentPath!.toLowerCase()
+            }
+
+            if (Array.isArray(desiredPath) && Array.isArray(currentPath)) {
+              const currentLowered = new Set(currentPath.map((c) => c.toLowerCase()))
+              return desiredPath.some((d) => currentLowered.has(d.toLowerCase()))
+            }
           }
- 
+
+          if (Array.isArray(desiredPath) && Array.isArray(currentPath)) {
+            return desiredPath.some((d) => currentPath.includes(d))
+          }
+
           return desiredPath === currentPath;
         },
-        findAllParameters: async () => {
+        async findAllParameters() {
           const $ = getPty();
           const { data } = await $.spawnSafe('find ~ -type d \\( -path $HOME/Library -o -path $HOME/Pictures -o -path $HOME/Utilities -o -path "$HOME/.*" \\) -prune -o -name .git -print')
 
-          return data
+          const directories = data
               ?.split(/\n/)?.filter(Boolean)
               ?.map((p) => path.dirname(p))
               ?.map((directory) => ({ directory }))
             ?? [];
+
+          const groupedDirectories = Object.groupBy(directories, (d) => path.dirname(d.directory));
+          const multipleRepositories = Object.entries(groupedDirectories).filter(([_, dirs]) => (dirs?.length ?? 0) > 1)
+            .map(([parent]) => ({ parentDirectory: parent }))
+          const singleRepositories = Object.entries(groupedDirectories).filter(([_, dirs]) => (dirs?.length ?? 0) === 1)
+            .map(([directory]) => ({ directory }))
+
+          return [...multipleRepositories, ...singleRepositories];
         }
       },
       dependencies: [
@@ -63,27 +84,47 @@ export class GitCloneResource extends Resource<GitCloneConfig> {
     }
   }
 
-  override async refresh(parameters: Partial<GitCloneConfig>): Promise<Partial<GitCloneConfig> | null> {
+  override async refresh(parameters: Partial<GitRepositoryConfig>): Promise<Partial<GitRepositoryConfig> | null> {
     const $ = getPty();
 
     if (parameters.parentDirectory) {
-      const folderName = this.extractBasename(parameters.repository!);
-      if (!folderName) {
-        throw new Error('Invalid git repository or remote name. Un-able to parse');
+      // Check if parent directory exists
+      const parentExists = await FileUtils.checkDirExistsOrThrowIfFile(parameters.parentDirectory);
+      if (!parentExists) {
+        return null;
       }
 
-      const fullPath = path.join(parameters.parentDirectory, folderName);
+      // Find all git repositories in the parent directory
+      const { data } = await $.spawnSafe(`find "${parameters.parentDirectory}" -maxdepth 2 -type d -name .git`, { cwd: parameters.parentDirectory });
 
-      const exists = await FileUtils.checkDirExistsOrThrowIfFile(fullPath);
-      if (!exists) {
+      const gitDirs = data?.split(/\n/)?.filter(Boolean) ?? [];
+      if (gitDirs.length === 0) {
+        return null;
+      }
+
+      // Get repository URLs for all found git directories
+      const repositories: string[] = [];
+      for (const gitDir of gitDirs) {
+        const repoPath = path.dirname(gitDir);
+        const { data: url } = await $.spawnSafe('git config --get remote.origin.url', { cwd: repoPath });
+        if (url && url.trim()) {
+          repositories.push(url.trim());
+        }
+      }
+
+      if (repositories.length === 0) {
         return null;
       }
 
-      const { data: url } = await $.spawn('git config --get remote.origin.url', { cwd: fullPath });
+      console.log('Refresh', {
+        parentDirectory: parameters.parentDirectory,
+        repositories,
+        autoVerifySSH: parameters.autoVerifySSH,
+      })
 
       return {
         parentDirectory: parameters.parentDirectory,
-        repository: url.trim(),
+        repositories,
         autoVerifySSH: parameters.autoVerifySSH,
       }
     }
@@ -107,29 +148,34 @@ export class GitCloneResource extends Resource<GitCloneConfig> {
   }
 
 
-  override async create(plan: CreatePlan<GitCloneConfig>): Promise<void> {
+  override async create(plan: CreatePlan<GitRepositoryConfig>): Promise<void> {
     const $ = getPty();
     const config = plan.desiredConfig;
 
-    if (plan.desiredConfig.autoVerifySSH) {
-      await this.autoVerifySSHForFirstAttempt(config.repository)
-    }
-
     if (config.parentDirectory) {
       const parentDirectory = path.resolve(config.parentDirectory);
       await FileUtils.createDirIfNotExists(parentDirectory);
-      await $.spawn(`git clone ${config.repository}`, { cwd: parentDirectory });
+
+      // Clone all repositories in the list
+      const repositories = (config as any).repositories || [config.repository];
+      for (const repository of repositories) {
+        if (plan.desiredConfig.autoVerifySSH) {
+          await this.autoVerifySSHForFirstAttempt(repository);
+        }
+
+        await $.spawn(`git clone ${repository}`, { cwd: parentDirectory });
+      }
     } else {
       const directory = path.resolve(config.directory!);
       await $.spawn(`git clone ${config.repository} ${directory}`);
     }
   }
 
-  override async destroy(plan: DestroyPlan<GitCloneConfig>): Promise<void> {
+  override async destroy(plan: DestroyPlan<GitRepositoryConfig>): Promise<void> {
     // Do nothing here. We don't want to destroy a user's repository.
     // TODO: change this to skip the destroy only if the user's repo has pending changes (check via git)
-    throw new Error(`The git-clone resource is not designed to delete folders. 
-Please delete ${plan.currentConfig.directory ?? (plan.currentConfig.parentDirectory! + this.extractBasename(plan.currentConfig.repository))} manually and re-apply`);
+    throw new Error(`The git-clone resource is not designed to delete folders.
+Please delete ${plan.currentConfig.directory ?? (plan.currentConfig.repositories?.map((r) => path.resolve(plan.currentConfig.parentDirectory!, this.extractBasename(r)!)).join(', '))} manually and re-apply`);
   }
 
   // Converts https://github.com/kevinwang5658/codify-homebrew-plugin.git => codify-homebrew-plugin

src/resources/git/repository/git-repository.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from 'vitest';
+import { afterAll, describe, expect, it } from 'vitest';
 import { PluginTester, testSpawn } from 'codify-plugin-test';
 import * as path from 'node:path';
 import * as fs from 'node:fs/promises';
@@ -12,7 +12,7 @@ describe('Git repository integration tests', async () => {
       {
         type: 'git-repository',
         parentDirectory: '~/projects/test',
-        repository: 'https://github.com/kevinwang5658/untitled.git'
+        repositories: ['https://github.com/kevinwang5658/untitled.git', 'https://github.com/octocat/Hello-World.git']
       }
     ], {
       skipUninstall: true, // Can't directly delete repos via codify currently.
@@ -39,6 +39,9 @@ describe('Git repository integration tests', async () => {
       }
     ], {
       skipUninstall: true,
+      validatePlan: async (plans) => {
+        console.log('plans', plans);
+      },
       validateApply: async () => {
         const location = path.join(os.homedir(), 'projects', 'nested', 'codify-plugin');
         const lstat = await fs.lstat(location);
@@ -50,4 +53,9 @@ describe('Git repository integration tests', async () => {
       }
     });
   })
+
+  afterAll(async () => {
+    await fs.rm(path.join(os.homedir(), 'projects', 'test'), { recursive: true, force: true });
+    await fs.rm(path.join(os.homedir(), 'projects', 'nested'), { recursive: true, force: true });
+  })
 })

test/git/git-repository.test.ts

@@ -13,7 +13,7 @@
     "outDir": "dist",
     "rootDir": "src",
     "strict": true,
-    "target": "es2022"
+    "target": "es2024"
   },
   "include": [
     "src/**/*.ts"