@aspruyt/xfg 4.0.0 → 4.0.2

package/dist/cli/sync-command.js

@@ -1,20 +1,22 @@
 import { resolve, join } from "node:path";
 import { existsSync } from "node:fs";
-import { loadRawConfig, normalizeConfig, } from "../config/index.js";
+import { loadRawConfig, normalizeConfig } from "../config/index.js";
 import { validateForSync } from "../config/validator.js";
 import { parseGitUrl, getRepoDisplayName, isGitHubRepo, } from "../shared/repo-detector.js";
-import { sanitizeBranchName, validateBranchName } from "../vcs/git-ops.js";
-import { hasGitHubAppCredentials, GitHubAppTokenManager, } from "../vcs/index.js";
+import { sanitizeBranchName, validateBranchName } from "../vcs/branch-utils.js";
+import { createTokenManager } from "../vcs/index.js";
 import { logger } from "../shared/logger.js";
 import { generateWorkspaceName } from "../shared/workspace-utils.js";
 import { defaultProcessorFactory, defaultRulesetProcessorFactory, defaultRepoSettingsProcessorFactory, defaultLabelsProcessorFactory, } from "./types.js";
-import { ResultsCollector } from "./settings/results-collector.js";
+import { ResultsCollector } from "./results-collector.js";
 import { buildSettingsReport } from "./settings-report-builder.js";
 import { formatSettingsReportCLI } from "../output/settings-report.js";
 import { buildSyncReport } from "./sync-report-builder.js";
 import { formatSyncReportCLI } from "../output/sync-report.js";
 import { buildLifecycleReport, formatLifecycleReportCLI, hasLifecycleChanges, } from "../output/lifecycle-report.js";
 import { writeUnifiedSummary } from "../output/unified-summary.js";
+import { toErrorMessage } from "../shared/type-guards.js";
+import { resolveGitHubToken } from "../shared/gh-api-utils.js";
 import { RepoLifecycleManager, runLifecycleCheck, toCreateRepoSettings, } from "../lifecycle/index.js";
 /**
  * Get unique file names from all repos in the config
@@ -49,9 +51,6 @@ function formatFileNames(fileNames) {
     }
     return `${fileNames.length} files`;
 }
-/**
- * Determine merge outcome from processor result
- */
 function determineMergeOutcome(result) {
     if (!result.success)
         return undefined;
@@ -63,311 +62,100 @@ function determineMergeOutcome(result) {
         return "auto";
     return "manual";
 }
-/**
- * Run the sync command - synchronizes files across repositories.
- */
-export async function runSync(options, deps = {}) {
-    const { processorFactory = defaultProcessorFactory, lifecycleManager, rulesetProcessorFactory = defaultRulesetProcessorFactory, repoSettingsProcessorFactory = defaultRepoSettingsProcessorFactory, labelsProcessorFactory = defaultLabelsProcessorFactory, } = deps;
-    const configPath = resolve(options.config);
-    if (!existsSync(configPath)) {
-        console.error(`Config file not found: ${configPath}`);
-        process.exit(1);
-    }
-    console.log(`Loading config from: ${configPath}`);
-    if (options.dryRun) {
-        console.log("Running in DRY RUN mode - no changes will be made\n");
-    }
-    const rawConfig = loadRawConfig(configPath);
-    try {
-        validateForSync(rawConfig);
-    }
-    catch (error) {
-        console.error(error instanceof Error ? error.message : String(error));
-        process.exit(1);
-    }
-    const config = normalizeConfig(rawConfig);
-    const fileNames = getUniqueFileNames(config);
-    let branchName;
-    if (options.branch) {
-        validateBranchName(options.branch);
-        branchName = options.branch;
-    }
-    else {
-        branchName = generateBranchName(fileNames);
-    }
-    logger.setTotal(config.repos.length);
-    console.log(`Found ${config.repos.length} repositories to process`);
-    console.log(`Target files: ${formatFileNames(fileNames)}`);
-    console.log(`Branch: ${branchName}\n`);
-    const processor = processorFactory();
-    const lm = lifecycleManager ?? new RepoLifecycleManager(undefined, options.retries);
-    const tokenManager = hasGitHubAppCredentials()
-        ? new GitHubAppTokenManager(process.env.XFG_GITHUB_APP_ID, process.env.XFG_GITHUB_APP_PRIVATE_KEY)
-        : null;
-    const reportResults = [];
-    const lifecycleReportInputs = [];
-    const settingsCollector = new ResultsCollector();
-    for (let i = 0; i < config.repos.length; i++) {
-        const repoConfig = config.repos[i];
-        if (options.merge || options.mergeStrategy || options.deleteBranch) {
-            repoConfig.prOptions = {
-                ...repoConfig.prOptions,
-                merge: options.merge ?? repoConfig.prOptions?.merge,
-                mergeStrategy: options.mergeStrategy ?? repoConfig.prOptions?.mergeStrategy,
-                deleteBranch: options.deleteBranch ?? repoConfig.prOptions?.deleteBranch,
-            };
-        }
-        const current = i + 1;
-        let repoInfo;
-        try {
-            repoInfo = parseGitUrl(repoConfig.git, {
-                githubHosts: config.githubHosts,
-            });
+function logSettingsResult(result, label, current, repoName, settingsCollector) {
+    if (result.planOutput?.lines?.length) {
+        logger.info("");
+        logger.info(`${repoName} - ${label}:`);
+        for (const line of result.planOutput.lines) {
+            logger.info(line);
         }
-        catch (error) {
-            logger.error(current, repoConfig.git, String(error));
-            reportResults.push({
-                repoName: repoConfig.git,
-                success: false,
-                fileChanges: [],
-                error: error instanceof Error ? error.message : String(error),
-            });
-            continue;
-        }
-        const repoName = getRepoDisplayName(repoInfo);
-        const workDir = resolve(join(options.workDir ?? "./tmp", generateWorkspaceName(i)));
-        // Resolve auth token for lifecycle gh commands
-        let lifecycleToken;
-        if (isGitHubRepo(repoInfo)) {
-            try {
-                lifecycleToken =
-                    (await tokenManager?.getTokenForRepo(repoInfo)) ??
-                        process.env.GH_TOKEN;
-            }
-            catch {
-                lifecycleToken = process.env.GH_TOKEN;
+        if (result.warnings?.length) {
+            for (const warning of result.warnings) {
+                logger.warn(warning);
             }
         }
-        // Check if repo exists, create/fork/migrate if needed
-        try {
-            const { outputLines, lifecycleResult } = await runLifecycleCheck(repoConfig, repoInfo, i, {
-                dryRun: options.dryRun ?? false,
-                resolvedWorkDir: workDir,
-                githubHosts: config.githubHosts,
-                token: lifecycleToken,
-            }, lm, config.settings?.repo);
-            for (const line of outputLines) {
-                logger.info(line);
-            }
-            // Collect lifecycle result for report
-            const createSettings = toCreateRepoSettings(config.settings?.repo);
-            lifecycleReportInputs.push({
-                repoName,
-                action: lifecycleResult.action,
-                upstream: repoConfig.upstream,
-                source: repoConfig.source,
-                settings: createSettings
-                    ? {
-                        visibility: createSettings.visibility,
-                        description: createSettings.description,
-                    }
-                    : undefined,
-            });
-            // In dry-run, skip processing repos that don't exist yet
-            if (options.dryRun && lifecycleResult.action !== "existed") {
-                reportResults.push({
-                    repoName,
-                    success: true,
-                    fileChanges: [],
+    }
+    else if (!result.skipped && result.success) {
+        logger.success(current, repoName, `${label}: ${result.message}`);
+    }
+    if (!result.success && !result.skipped) {
+        logger.error(current, repoName, `${label}: ${result.message}`);
+        settingsCollector.appendError(repoName, result.message);
+    }
+}
+async function applyRepoSettings(ctx) {
+    const { repoConfig, repoInfo, repoName, current, options, token, settingsCollector, rulesetProcessorFactory, repoSettingsProcessorFactory, labelsProcessorFactory, } = ctx;
+    if (!repoConfig.settings || !isGitHubRepo(repoInfo))
+        return;
+    const settingsDescriptors = [
+        {
+            key: "rulesets",
+            label: "Rulesets",
+            run: async () => {
+                const result = await rulesetProcessorFactory().process(repoConfig, repoInfo, {
+                    dryRun: options.dryRun,
+                    noDelete: options.noDelete,
+                    token,
                 });
-                continue;
-            }
-        }
-        catch (error) {
-            logger.error(current, repoName, `Lifecycle error: ${error instanceof Error ? error.message : String(error)}`);
-            reportResults.push({
-                repoName,
-                success: false,
-                fileChanges: [],
-                error: error instanceof Error ? error.message : String(error),
-            });
+                if (!result.skipped) {
+                    settingsCollector.getOrCreate(repoName).rulesetResult = result;
+                }
+                return result;
+            },
+        },
+        {
+            key: "labels",
+            label: "Labels",
+            run: async () => {
+                const result = await labelsProcessorFactory().process(repoConfig, repoInfo, {
+                    dryRun: options.dryRun,
+                    noDelete: options.noDelete,
+                    token,
+                });
+                if (!result.skipped) {
+                    settingsCollector.getOrCreate(repoName).labelsResult = result;
+                }
+                return result;
+            },
+        },
+        {
+            key: "repo",
+            label: "Repo Settings",
+            run: async () => {
+                const result = await repoSettingsProcessorFactory().process(repoConfig, repoInfo, { dryRun: options.dryRun, token });
+                if (!result.skipped) {
+                    settingsCollector.getOrCreate(repoName).settingsResult = result;
+                }
+                return result;
+            },
+        },
+    ];
+    for (const desc of settingsDescriptors) {
+        const settingsValue = repoConfig.settings[desc.key];
+        if (!settingsValue || Object.keys(settingsValue).length === 0)
             continue;
-        }
         try {
-            logger.progress(current, repoName, "Processing...");
-            const result = await processor.process(repoConfig, repoInfo, {
-                branchName,
-                workDir,
-                configId: config.id,
-                dryRun: options.dryRun,
-                retries: options.retries,
-                prTemplate: config.prTemplate,
-                noDelete: options.noDelete,
-            });
-            const mergeOutcome = determineMergeOutcome(result);
-            reportResults.push({
-                repoName,
-                success: result.success,
-                fileChanges: (result.fileChanges ?? []).map((f) => ({
-                    path: f.path,
-                    action: f.action,
-                })),
-                prUrl: result.prUrl,
-                mergeOutcome,
-                error: result.success ? undefined : result.message,
-            });
-            if (result.skipped) {
-                logger.skip(current, repoName, result.message);
-            }
-            else if (result.success) {
-                logger.success(current, repoName, result.message);
-            }
-            else {
-                logger.error(current, repoName, result.message);
-            }
+            const result = await desc.run();
+            logSettingsResult(result, desc.label, current, repoName, settingsCollector);
         }
         catch (error) {
-            logger.error(current, repoName, String(error));
-            reportResults.push({
-                repoName,
-                success: false,
-                fileChanges: [],
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-        // After file sync, apply settings via API (GitHub-only — ADO and GitLab repos are skipped)
-        if (repoConfig.settings && isGitHubRepo(repoInfo)) {
-            const githubRepo = repoInfo;
-            let settingsToken;
-            try {
-                settingsToken =
-                    (await tokenManager?.getTokenForRepo(githubRepo)) ??
-                        process.env.GH_TOKEN;
-            }
-            catch {
-                settingsToken = process.env.GH_TOKEN;
-            }
-            // Apply rulesets
-            if (repoConfig.settings.rulesets &&
-                Object.keys(repoConfig.settings.rulesets).length > 0) {
-                try {
-                    const rulesetProcessor = rulesetProcessorFactory();
-                    const rulesetResult = await rulesetProcessor.process(repoConfig, repoInfo, {
-                        dryRun: options.dryRun,
-                        noDelete: options.noDelete,
-                        token: settingsToken,
-                    });
-                    if (rulesetResult.planOutput?.lines?.length) {
-                        logger.info("");
-                        logger.info(`${repoName} - Rulesets:`);
-                        for (const line of rulesetResult.planOutput.lines) {
-                            logger.info(line);
-                        }
-                    }
-                    else if (!rulesetResult.skipped && rulesetResult.success) {
-                        logger.success(current, repoName, `Rulesets: ${rulesetResult.message}`);
-                    }
-                    if (!rulesetResult.skipped) {
-                        settingsCollector.getOrCreate(repoName).rulesetResult =
-                            rulesetResult;
-                    }
-                    if (!rulesetResult.success && !rulesetResult.skipped) {
-                        logger.error(current, repoName, `Rulesets: ${rulesetResult.message}`);
-                        settingsCollector.appendError(repoName, rulesetResult.message);
-                    }
-                }
-                catch (error) {
-                    logger.error(current, repoName, `Rulesets: ${String(error)}`);
-                    settingsCollector.appendError(repoName, error);
-                }
-            }
-            // Apply labels
-            if (repoConfig.settings.labels &&
-                Object.keys(repoConfig.settings.labels).length > 0) {
-                try {
-                    const labelsProcessor = labelsProcessorFactory();
-                    const labelsResult = await labelsProcessor.process(repoConfig, repoInfo, {
-                        dryRun: options.dryRun,
-                        noDelete: options.noDelete,
-                        token: settingsToken,
-                    });
-                    if (labelsResult.planOutput?.lines?.length) {
-                        logger.info("");
-                        logger.info(`${repoName} - Labels:`);
-                        for (const line of labelsResult.planOutput.lines) {
-                            logger.info(line);
-                        }
-                    }
-                    else if (!labelsResult.skipped && labelsResult.success) {
-                        logger.success(current, repoName, `Labels: ${labelsResult.message}`);
-                    }
-                    if (!labelsResult.skipped) {
-                        settingsCollector.getOrCreate(repoName).labelsResult = labelsResult;
-                    }
-                    if (!labelsResult.success && !labelsResult.skipped) {
-                        logger.error(current, repoName, `Labels: ${labelsResult.message}`);
-                        settingsCollector.appendError(repoName, labelsResult.message);
-                    }
-                }
-                catch (error) {
-                    logger.error(current, repoName, `Labels: ${String(error)}`);
-                    settingsCollector.appendError(repoName, error);
-                }
-            }
-            // Apply repo settings
-            if (repoConfig.settings.repo &&
-                Object.keys(repoConfig.settings.repo).length > 0) {
-                try {
-                    const repoSettingsProcessor = repoSettingsProcessorFactory();
-                    const repoSettingsResult = await repoSettingsProcessor.process(repoConfig, repoInfo, {
-                        dryRun: options.dryRun,
-                        token: settingsToken,
-                    });
-                    if (repoSettingsResult.planOutput?.lines?.length) {
-                        logger.info("");
-                        logger.info(`${repoName} - Repo Settings:`);
-                        for (const line of repoSettingsResult.planOutput.lines) {
-                            logger.info(line);
-                        }
-                        if (repoSettingsResult.warnings?.length) {
-                            for (const warning of repoSettingsResult.warnings) {
-                                logger.info(`Warning: ${warning}`);
-                            }
-                        }
-                    }
-                    else if (!repoSettingsResult.skipped &&
-                        repoSettingsResult.success) {
-                        logger.success(current, repoName, `Repo settings: ${repoSettingsResult.message}`);
-                    }
-                    if (!repoSettingsResult.skipped) {
-                        settingsCollector.getOrCreate(repoName).settingsResult =
-                            repoSettingsResult;
-                    }
-                    if (!repoSettingsResult.success && !repoSettingsResult.skipped) {
-                        logger.error(current, repoName, `Repo settings: ${repoSettingsResult.message}`);
-                        settingsCollector.appendError(repoName, repoSettingsResult.message);
-                    }
-                }
-                catch (error) {
-                    logger.error(current, repoName, `Repo settings: ${String(error)}`);
-                    settingsCollector.appendError(repoName, error);
-                }
-            }
+            logger.error(current, repoName, `${desc.label}: ${toErrorMessage(error)}`);
+            settingsCollector.appendError(repoName, error);
         }
     }
-    // Build and display lifecycle report (before sync report)
+}
+function displayReports(reportResults, lifecycleReportInputs, settingsCollector, dryRun) {
     const lifecycleReport = buildLifecycleReport(lifecycleReportInputs);
     if (hasLifecycleChanges(lifecycleReport)) {
-        console.log("");
+        logger.log("");
         for (const line of formatLifecycleReportCLI(lifecycleReport)) {
-            console.log(line);
+            logger.log(line);
         }
     }
-    // Build and display sync report
     const report = buildSyncReport(reportResults);
-    console.log("");
+    logger.log("");
     for (const line of formatSyncReportCLI(report)) {
-        console.log(line);
+        logger.log(line);
     }
     // Build and display settings report (if any settings were processed)
     const settingsResults = settingsCollector.getAll();
@@ -376,9 +164,9 @@ export async function runSync(options, deps = {}) {
         settingsReport = buildSettingsReport(settingsResults);
         const settingsLines = formatSettingsReportCLI(settingsReport);
         if (settingsLines.length > 0) {
-            console.log("");
+            logger.log("");
             for (const line of settingsLines) {
-                console.log(line);
+                logger.log(line);
             }
         }
     }
@@ -387,12 +175,218 @@ export async function runSync(options, deps = {}) {
         lifecycle: lifecycleReport,
         sync: report,
         settings: settingsReport,
-        dryRun: options.dryRun ?? false,
+        dryRun,
     });
-    // Exit with error if any failures (file sync or settings)
-    const hasErrors = reportResults.some((r) => r.error);
+}
+/**
+ * Process a single repository: resolve URL, run lifecycle check, sync files, apply settings.
+ * Pushes results into ctx.reportResults, ctx.lifecycleReportInputs, and ctx.settingsCollector.
+ */
+async function processSingleRepo(repoConfig, index, ctx) {
+    const { config, options } = ctx;
+    const current = index + 1;
+    // Apply CLI-level PR option overrides
+    if (options.merge || options.mergeStrategy || options.deleteBranch) {
+        repoConfig.prOptions = {
+            ...repoConfig.prOptions,
+            merge: options.merge ?? repoConfig.prOptions?.merge,
+            mergeStrategy: options.mergeStrategy ?? repoConfig.prOptions?.mergeStrategy,
+            deleteBranch: options.deleteBranch ?? repoConfig.prOptions?.deleteBranch,
+        };
+    }
+    const mergeMode = repoConfig.prOptions?.merge ?? "auto";
+    if (mergeMode === "direct" && repoConfig.prOptions?.mergeStrategy) {
+        logger.warn(`mergeStrategy '${repoConfig.prOptions.mergeStrategy}' is ignored in direct mode for ${repoConfig.git}`);
+    }
+    let repoInfo;
+    try {
+        repoInfo = parseGitUrl(repoConfig.git, {
+            githubHosts: config.githubHosts,
+        });
+    }
+    catch (error) {
+        logger.error(current, repoConfig.git, toErrorMessage(error));
+        ctx.reportResults.push({
+            repoName: repoConfig.git,
+            success: false,
+            fileChanges: [],
+            error: toErrorMessage(error),
+        });
+        return;
+    }
+    const repoName = getRepoDisplayName(repoInfo);
+    const workDir = resolve(join(options.workDir ?? "./tmp", generateWorkspaceName(index)));
+    const repoToken = isGitHubRepo(repoInfo)
+        ? (await resolveGitHubToken(repoInfo, ctx.tokenManager, repoName, logger, process.env.GH_TOKEN)).token
+        : undefined;
+    const skipFileSync = await runLifecyclePhase(repoConfig, repoInfo, repoName, index, workDir, repoToken, ctx);
+    if (skipFileSync)
+        return;
+    // Sync files via processor
+    await runFileSyncPhase(repoConfig, repoInfo, repoName, current, workDir, repoToken, ctx);
+    // Apply settings via API (GitHub-only — ADO and GitLab repos are skipped)
+    await applyRepoSettings({
+        repoConfig,
+        repoInfo,
+        repoName,
+        current,
+        options,
+        token: repoToken,
+        settingsCollector: ctx.settingsCollector,
+        rulesetProcessorFactory: ctx.rulesetProcessorFactory,
+        repoSettingsProcessorFactory: ctx.repoSettingsProcessorFactory,
+        labelsProcessorFactory: ctx.labelsProcessorFactory,
+    });
+}
+/**
+ * Run lifecycle check (repo existence, creation, forking).
+ * Returns true if the main loop should skip file sync for this repo.
+ */
+async function runLifecyclePhase(repoConfig, repoInfo, repoName, index, workDir, lifecycleToken, ctx) {
+    const current = index + 1;
+    try {
+        const { outputLines, lifecycleResult } = await runLifecycleCheck(repoConfig, repoInfo, index, {
+            dryRun: ctx.options.dryRun ?? false,
+            resolvedWorkDir: workDir,
+            githubHosts: ctx.config.githubHosts,
+            token: lifecycleToken,
+        }, ctx.lifecycleManager, ctx.config.settings?.repo);
+        for (const line of outputLines) {
+            logger.info(line);
+        }
+        const createSettings = toCreateRepoSettings(ctx.config.settings?.repo);
+        ctx.lifecycleReportInputs.push({
+            repoName,
+            action: lifecycleResult.action,
+            upstream: repoConfig.upstream,
+            source: repoConfig.source,
+            settings: createSettings
+                ? {
+                    visibility: createSettings.visibility,
+                    description: createSettings.description,
+                }
+                : undefined,
+        });
+        // In dry-run, skip processing repos that don't exist yet
+        if (ctx.options.dryRun && lifecycleResult.action !== "existed") {
+            ctx.reportResults.push({
+                repoName,
+                success: true,
+                fileChanges: [],
+            });
+            return true;
+        }
+        return false;
+    }
+    catch (error) {
+        logger.error(current, repoName, `Lifecycle error: ${toErrorMessage(error)}`);
+        ctx.reportResults.push({
+            repoName,
+            success: false,
+            fileChanges: [],
+            error: toErrorMessage(error),
+        });
+        return true;
+    }
+}
+/**
+ * Run the file sync processor for a single repo and collect results.
+ */
+async function runFileSyncPhase(repoConfig, repoInfo, repoName, current, workDir, token, ctx) {
+    try {
+        logger.progress(current, repoName, "Processing...");
+        const result = await ctx.processor.process(repoConfig, repoInfo, {
+            branchName: ctx.branchName,
+            workDir,
+            configId: ctx.config.id,
+            dryRun: ctx.options.dryRun,
+            retries: ctx.options.retries,
+            prTemplate: ctx.config.prTemplate,
+            noDelete: ctx.options.noDelete,
+            token,
+            isGraphQLCommitMode: isGitHubRepo(repoInfo) && ctx.tokenManager !== null,
+        });
+        const mergeOutcome = determineMergeOutcome(result);
+        ctx.reportResults.push({
+            repoName,
+            success: result.success,
+            fileChanges: (result.fileChanges ?? []).map((f) => ({
+                path: f.path,
+                action: f.action,
+            })),
+            prUrl: result.prUrl,
+            mergeOutcome,
+            error: result.success ? undefined : result.message,
+        });
+        if (result.skipped) {
+            logger.skip(current, repoName, result.message);
+        }
+        else if (result.success) {
+            logger.success(current, repoName, result.message);
+        }
+        else {
+            logger.error(current, repoName, result.message);
+        }
+    }
+    catch (error) {
+        logger.error(current, repoName, toErrorMessage(error));
+        ctx.reportResults.push({
+            repoName,
+            success: false,
+            fileChanges: [],
+            error: toErrorMessage(error),
+        });
+    }
+}
+export async function runSync(options, deps = {}) {
+    const { processorFactory = defaultProcessorFactory, lifecycleManager, rulesetProcessorFactory = defaultRulesetProcessorFactory, repoSettingsProcessorFactory = defaultRepoSettingsProcessorFactory, labelsProcessorFactory = defaultLabelsProcessorFactory, } = deps;
+    const configPath = resolve(options.config);
+    if (!existsSync(configPath)) {
+        throw new Error(`Config file not found: ${configPath}`);
+    }
+    logger.log(`Loading config from: ${configPath}`);
+    if (options.dryRun) {
+        logger.log("Running in DRY RUN mode - no changes will be made\n");
+    }
+    const rawConfig = loadRawConfig(configPath);
+    validateForSync(rawConfig);
+    const config = normalizeConfig(rawConfig);
+    const fileNames = getUniqueFileNames(config);
+    let branchName;
+    if (options.branch) {
+        validateBranchName(options.branch);
+        branchName = options.branch;
+    }
+    else {
+        branchName = generateBranchName(fileNames);
+    }
+    logger.setTotal(config.repos.length);
+    logger.log(`Found ${config.repos.length} repositories to process`);
+    logger.log(`Target files: ${formatFileNames(fileNames)}`);
+    logger.log(`Branch: ${branchName}\n`);
+    const ctx = {
+        config,
+        options,
+        branchName,
+        processor: processorFactory(),
+        lifecycleManager: lifecycleManager ?? new RepoLifecycleManager(undefined, options.retries),
+        tokenManager: createTokenManager(),
+        reportResults: [],
+        lifecycleReportInputs: [],
+        settingsCollector: new ResultsCollector(),
+        rulesetProcessorFactory,
+        repoSettingsProcessorFactory,
+        labelsProcessorFactory,
+    };
+    for (let i = 0; i < config.repos.length; i++) {
+        await processSingleRepo(config.repos[i], i, ctx);
+    }
+    displayReports(ctx.reportResults, ctx.lifecycleReportInputs, ctx.settingsCollector, options.dryRun ?? false);
+    // Propagate failures to caller (CLI entry handles process.exit)
+    const settingsResults = ctx.settingsCollector.getAll();
+    const hasErrors = ctx.reportResults.some((r) => r.error);
     const hasSettingsErrors = settingsResults.some((r) => r.error);
     if (hasErrors || hasSettingsErrors) {
-        process.exit(1);
+        throw new Error("One or more repositories had errors during sync");
     }
 }