@aspruyt/xfg 3.7.7 → 3.8.1

package/dist/cli/settings-command.js

@@ -8,52 +8,43 @@ import { logger } from "../shared/logger.js";
 import { generateWorkspaceName } from "../shared/workspace-utils.js";
 import { buildErrorResult } from "../output/summary-utils.js";
 import { getManagedRulesets } from "../sync/manifest.js";
-import { printPlan } from "../output/plan-formatter.js";
-import { writePlanSummary } from "../output/plan-summary.js";
-import { rulesetResultToResources, repoSettingsResultToResources, } from "../settings/resource-converters.js";
+import { formatSettingsReportCLI, writeSettingsReportSummary, } from "../output/settings-report.js";
+import { buildSettingsReport, } from "./settings-report-builder.js";
 import { defaultProcessorFactory, defaultRulesetProcessorFactory, defaultRepoSettingsProcessorFactory, } from "./types.js";
 /**
- * Run the settings command - manages GitHub Rulesets and repo settings.
+ * Collects processing results for the SettingsReport.
+ * Provides a centralized way to track results across rulesets and repo settings.
  */
-export async function runSettings(options, processorFactory = defaultRulesetProcessorFactory, repoProcessorFactory = defaultProcessorFactory, repoSettingsProcessorFactory = defaultRepoSettingsProcessorFactory) {
-    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 {
-        validateForSettings(rawConfig);
-    }
-    catch (error) {
-        console.error(error instanceof Error ? error.message : String(error));
-        process.exit(1);
-    }
-    const config = normalizeConfig(rawConfig);
-    const reposWithRulesets = config.repos.filter((r) => r.settings?.rulesets && Object.keys(r.settings.rulesets).length > 0);
-    const reposWithRepoSettings = config.repos.filter((r) => r.settings?.repo && Object.keys(r.settings.repo).length > 0);
-    if (reposWithRulesets.length === 0 && reposWithRepoSettings.length === 0) {
-        console.log("No settings configured. Add settings.rulesets or settings.repo to your config.");
-        return;
+class ResultsCollector {
+    results = [];
+    getOrCreate(repoName) {
+        let result = this.results.find((r) => r.repoName === repoName);
+        if (!result) {
+            result = { repoName };
+            this.results.push(result);
+        }
+        return result;
     }
-    if (reposWithRulesets.length > 0) {
-        console.log(`Found ${reposWithRulesets.length} repositories with rulesets`);
+    appendError(repoName, error) {
+        const existing = this.getOrCreate(repoName);
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        if (existing.error) {
+            existing.error += `; ${errorMsg}`;
+        }
+        else {
+            existing.error = errorMsg;
+        }
     }
-    if (reposWithRepoSettings.length > 0) {
-        console.log(`Found ${reposWithRepoSettings.length} repositories with repo settings`);
+    getAll() {
+        return this.results;
     }
-    console.log("");
-    logger.setTotal(reposWithRulesets.length + reposWithRepoSettings.length);
-    const processor = processorFactory();
-    const repoProcessor = repoProcessorFactory();
-    const results = [];
-    const plan = { resources: [], errors: [] };
-    for (let i = 0; i < reposWithRulesets.length; i++) {
-        const repoConfig = reposWithRulesets[i];
+}
+/**
+ * Process rulesets for all configured repositories.
+ */
+async function processRulesets(repos, config, options, processor, repoProcessor, results, collector) {
+    for (let i = 0; i < repos.length; i++) {
+        const repoConfig = repos[i];
         let repoInfo;
         try {
             repoInfo = parseGitUrl(repoConfig.git, {
@@ -63,26 +54,12 @@ export async function runSettings(options, processorFactory = defaultRulesetProc
         catch (error) {
             logger.error(i + 1, repoConfig.git, String(error));
             results.push(buildErrorResult(repoConfig.git, error));
-            plan.errors.push({
-                repo: repoConfig.git,
-                message: error instanceof Error ? error.message : String(error),
-            });
+            collector.appendError(repoConfig.git, error);
             continue;
         }
         const repoName = getRepoDisplayName(repoInfo);
         if (!isGitHubRepo(repoInfo)) {
             logger.skip(i + 1, repoName, "GitHub Rulesets only supported for GitHub repos");
-            if (repoConfig.settings?.rulesets) {
-                for (const rulesetName of Object.keys(repoConfig.settings.rulesets)) {
-                    plan.resources.push({
-                        type: "ruleset",
-                        repo: repoName,
-                        name: rulesetName,
-                        action: "skipped",
-                        skipReason: "GitHub Rulesets only supported for GitHub repos",
-                    });
-                }
-            }
             continue;
         }
         const managedRulesets = getManagedRulesets(null, config.id);
@@ -135,94 +112,140 @@ export async function runSettings(options, processorFactory = defaultRulesetProc
                 message: result.message,
                 rulesetPlanDetails: result.planOutput?.entries,
             });
-            plan.resources.push(...rulesetResultToResources(repoName, result));
+            if (!result.skipped) {
+                collector.getOrCreate(repoName).rulesetResult = result;
+            }
         }
         catch (error) {
             logger.error(i + 1, repoName, String(error));
             results.push(buildErrorResult(repoName, error));
-            plan.errors.push({
-                repo: repoName,
-                message: error instanceof Error ? error.message : String(error),
-            });
+            collector.appendError(repoName, error);
         }
     }
-    if (reposWithRepoSettings.length > 0) {
-        const repoSettingsProcessor = repoSettingsProcessorFactory();
-        console.log(`\nProcessing repo settings for ${reposWithRepoSettings.length} repositories\n`);
-        for (let i = 0; i < reposWithRepoSettings.length; i++) {
-            const repoConfig = reposWithRepoSettings[i];
-            let repoInfo;
-            try {
-                repoInfo = parseGitUrl(repoConfig.git, {
-                    githubHosts: config.githubHosts,
-                });
-            }
-            catch (error) {
-                console.error(`Failed to parse ${repoConfig.git}: ${error}`);
-                plan.errors.push({
-                    repo: repoConfig.git,
-                    message: error instanceof Error ? error.message : String(error),
-                });
-                continue;
-            }
-            const repoName = getRepoDisplayName(repoInfo);
-            try {
-                const result = await repoSettingsProcessor.process(repoConfig, repoInfo, {
-                    dryRun: options.dryRun,
-                });
-                if (result.planOutput && result.planOutput.lines.length > 0) {
-                    console.log(`\n  ${chalk.bold(repoName)}:`);
-                    console.log("  Repo Settings:");
-                    for (const line of result.planOutput.lines) {
-                        console.log(line);
-                    }
-                    if (result.warnings && result.warnings.length > 0) {
-                        for (const warning of result.warnings) {
-                            console.log(chalk.yellow(`  ⚠️  Warning: ${warning}`));
-                        }
-                    }
+}
+/**
+ * Process repo settings for all configured repositories.
+ */
+async function processRepoSettings(repos, config, options, processorFactory, results, collector) {
+    if (repos.length === 0) {
+        return;
+    }
+    const processor = processorFactory();
+    console.log(`\nProcessing repo settings for ${repos.length} repositories\n`);
+    for (let i = 0; i < repos.length; i++) {
+        const repoConfig = repos[i];
+        let repoInfo;
+        try {
+            repoInfo = parseGitUrl(repoConfig.git, {
+                githubHosts: config.githubHosts,
+            });
+        }
+        catch (error) {
+            console.error(`Failed to parse ${repoConfig.git}: ${error}`);
+            collector.appendError(repoConfig.git, error);
+            continue;
+        }
+        const repoName = getRepoDisplayName(repoInfo);
+        try {
+            const result = await processor.process(repoConfig, repoInfo, {
+                dryRun: options.dryRun,
+            });
+            if (result.planOutput && result.planOutput.lines.length > 0) {
+                console.log(`\n  ${chalk.bold(repoName)}:`);
+                console.log("  Repo Settings:");
+                for (const line of result.planOutput.lines) {
+                    console.log(line);
                 }
-                if (result.skipped) {
-                    // Silent skip
+                if (result.warnings && result.warnings.length > 0) {
+                    for (const warning of result.warnings) {
+                        console.log(chalk.yellow(`  ⚠️  Warning: ${warning}`));
+                    }
                 }
-                else if (result.success) {
-                    console.log(chalk.green(`  ✓ ${repoName}: ${result.message}`));
+            }
+            if (result.skipped) {
+                // Silent skip
+            }
+            else if (result.success) {
+                console.log(chalk.green(`  ✓ ${repoName}: ${result.message}`));
+            }
+            else {
+                console.log(chalk.red(`  ✗ ${repoName}: ${result.message}`));
+            }
+            if (!result.skipped) {
+                const existing = results.find((r) => r.repoName === repoName);
+                if (existing) {
+                    existing.repoSettingsPlanDetails = result.planOutput?.entries;
                 }
                 else {
-                    console.log(chalk.red(`  ✗ ${repoName}: ${result.message}`));
-                }
-                if (!result.skipped) {
-                    const existing = results.find((r) => r.repoName === repoName);
-                    if (existing) {
-                        existing.repoSettingsPlanDetails = result.planOutput?.entries;
-                    }
-                    else {
-                        results.push({
-                            repoName,
-                            status: result.success ? "succeeded" : "failed",
-                            message: result.message,
-                            repoSettingsPlanDetails: result.planOutput?.entries,
-                        });
-                    }
+                    results.push({
+                        repoName,
+                        status: result.success ? "succeeded" : "failed",
+                        message: result.message,
+                        repoSettingsPlanDetails: result.planOutput?.entries,
+                    });
                 }
-                plan.resources.push(...repoSettingsResultToResources(repoName, result));
             }
-            catch (error) {
-                console.error(`  ✗ ${repoName}: ${error}`);
-                plan.errors.push({
-                    repo: repoName,
-                    message: error instanceof Error ? error.message : String(error),
-                });
+            if (!result.skipped) {
+                collector.getOrCreate(repoName).settingsResult = result;
             }
         }
+        catch (error) {
+            console.error(`  ✗ ${repoName}: ${error}`);
+            collector.appendError(repoName, error);
+        }
+    }
+}
+/**
+ * Run the settings command - manages GitHub Rulesets and repo settings.
+ */
+export async function runSettings(options, processorFactory = defaultRulesetProcessorFactory, repoProcessorFactory = defaultProcessorFactory, repoSettingsProcessorFactory = defaultRepoSettingsProcessorFactory) {
+    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 {
+        validateForSettings(rawConfig);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+    const config = normalizeConfig(rawConfig);
+    const reposWithRulesets = config.repos.filter((r) => r.settings?.rulesets && Object.keys(r.settings.rulesets).length > 0);
+    const reposWithRepoSettings = config.repos.filter((r) => r.settings?.repo && Object.keys(r.settings.repo).length > 0);
+    if (reposWithRulesets.length === 0 && reposWithRepoSettings.length === 0) {
+        console.log("No settings configured. Add settings.rulesets or settings.repo to your config.");
+        return;
+    }
+    if (reposWithRulesets.length > 0) {
+        console.log(`Found ${reposWithRulesets.length} repositories with rulesets`);
+    }
+    if (reposWithRepoSettings.length > 0) {
+        console.log(`Found ${reposWithRepoSettings.length} repositories with repo settings`);
     }
     console.log("");
-    printPlan(plan);
-    writePlanSummary(plan, {
-        title: "Repository Settings Summary",
-        dryRun: options.dryRun ?? false,
-    });
-    if (plan.errors && plan.errors.length > 0) {
+    logger.setTotal(reposWithRulesets.length + reposWithRepoSettings.length);
+    const processor = processorFactory();
+    const repoProcessor = repoProcessorFactory();
+    const results = [];
+    const collector = new ResultsCollector();
+    await processRulesets(reposWithRulesets, config, options, processor, repoProcessor, results, collector);
+    await processRepoSettings(reposWithRepoSettings, config, options, repoSettingsProcessorFactory, results, collector);
+    console.log("");
+    const report = buildSettingsReport(collector.getAll());
+    const lines = formatSettingsReportCLI(report);
+    for (const line of lines) {
+        console.log(line);
+    }
+    writeSettingsReportSummary(report, options.dryRun ?? false);
+    const hasErrors = report.repos.some((r) => r.error);
+    if (hasErrors) {
         process.exit(1);
     }
 }

package/dist/cli/settings-report-builder.d.ts

@@ -0,0 +1,22 @@
+import type { SettingsReport } from "../output/settings-report.js";
+import type { RepoSettingsPlanEntry } from "../settings/repo-settings/formatter.js";
+import type { RulesetPlanEntry } from "../settings/rulesets/formatter.js";
+/**
+ * Result from processing a repository's settings and rulesets.
+ * Used to collect results during settings command execution.
+ */
+export interface ProcessorResults {
+    repoName: string;
+    settingsResult?: {
+        planOutput?: {
+            entries?: RepoSettingsPlanEntry[];
+        };
+    };
+    rulesetResult?: {
+        planOutput?: {
+            entries?: RulesetPlanEntry[];
+        };
+    };
+    error?: string;
+}
+export declare function buildSettingsReport(results: ProcessorResults[]): SettingsReport;

package/dist/cli/settings-report-builder.js

@@ -0,0 +1,64 @@
+export function buildSettingsReport(results) {
+    const repos = [];
+    const totals = {
+        settings: { add: 0, change: 0 },
+        rulesets: { create: 0, update: 0, delete: 0 },
+    };
+    for (const result of results) {
+        const repoChanges = {
+            repoName: result.repoName,
+            settings: [],
+            rulesets: [],
+        };
+        // Convert settings processor output
+        if (result.settingsResult?.planOutput?.entries) {
+            for (const entry of result.settingsResult.planOutput.entries) {
+                // Skip settings where both values are undefined (no actual change)
+                if (entry.oldValue === undefined && entry.newValue === undefined) {
+                    continue;
+                }
+                const settingChange = {
+                    name: entry.property,
+                    action: entry.action,
+                    oldValue: entry.oldValue,
+                    newValue: entry.newValue,
+                };
+                repoChanges.settings.push(settingChange);
+                if (entry.action === "add") {
+                    totals.settings.add++;
+                }
+                else {
+                    totals.settings.change++;
+                }
+            }
+        }
+        // Convert ruleset processor output
+        if (result.rulesetResult?.planOutput?.entries) {
+            for (const entry of result.rulesetResult.planOutput.entries) {
+                if (entry.action === "unchanged")
+                    continue;
+                const rulesetChange = {
+                    name: entry.name,
+                    action: entry.action,
+                    propertyDiffs: entry.propertyDiffs,
+                    config: entry.config,
+                };
+                repoChanges.rulesets.push(rulesetChange);
+                if (entry.action === "create") {
+                    totals.rulesets.create++;
+                }
+                else if (entry.action === "update") {
+                    totals.rulesets.update++;
+                }
+                else if (entry.action === "delete") {
+                    totals.rulesets.delete++;
+                }
+            }
+        }
+        if (result.error) {
+            repoChanges.error = result.error;
+        }
+        repos.push(repoChanges);
+    }
+    return { repos, totals };
+}

package/dist/cli/sync-command.js

@@ -6,11 +6,9 @@ import { parseGitUrl, getRepoDisplayName } from "../shared/repo-detector.js";
 import { sanitizeBranchName, validateBranchName } from "../vcs/git-ops.js";
 import { logger } from "../shared/logger.js";
 import { generateWorkspaceName } from "../shared/workspace-utils.js";
-import { buildRepoResult, buildErrorResult } from "../output/summary-utils.js";
-import { printPlan } from "../output/plan-formatter.js";
-import { writePlanSummary } from "../output/plan-summary.js";
-import { syncResultToResources } from "../settings/resource-converters.js";
 import { defaultProcessorFactory } from "./types.js";
+import { buildSyncReport } from "./sync-report-builder.js";
+import { formatSyncReportCLI, writeSyncReportSummary, } from "../output/sync-report.js";
 /**
  * Get unique file names from all repos in the config
  */
@@ -44,6 +42,20 @@ function formatFileNames(fileNames) {
     }
     return `${fileNames.length} files`;
 }
+/**
+ * Determine merge outcome from processor result
+ */
+function determineMergeOutcome(result) {
+    if (!result.success)
+        return undefined;
+    if (!result.prUrl)
+        return "direct";
+    if (result.mergeResult?.merged)
+        return "force";
+    if (result.mergeResult?.autoMergeEnabled)
+        return "auto";
+    return "manual";
+}
 /**
  * Run the sync command - synchronizes files across repositories.
  */
@@ -80,8 +92,7 @@ export async function runSync(options, processorFactory = defaultProcessorFactor
     console.log(`Target files: ${formatFileNames(fileNames)}`);
     console.log(`Branch: ${branchName}\n`);
     const processor = processorFactory();
-    const results = [];
-    const plan = { resources: [], errors: [] };
+    const reportResults = [];
     for (let i = 0; i < config.repos.length; i++) {
         const repoConfig = config.repos[i];
         if (options.merge || options.mergeStrategy || options.deleteBranch) {
@@ -101,10 +112,11 @@ export async function runSync(options, processorFactory = defaultProcessorFactor
         }
         catch (error) {
             logger.error(current, repoConfig.git, String(error));
-            results.push(buildErrorResult(repoConfig.git, error));
-            plan.errors.push({
-                repo: repoConfig.git,
-                message: error instanceof Error ? error.message : String(error),
+            reportResults.push({
+                repoName: repoConfig.git,
+                success: false,
+                fileChanges: [],
+                error: error instanceof Error ? error.message : String(error),
             });
             continue;
         }
@@ -121,35 +133,48 @@ export async function runSync(options, processorFactory = defaultProcessorFactor
                 prTemplate: config.prTemplate,
                 noDelete: options.noDelete,
             });
-            const repoResult = buildRepoResult(repoName, repoConfig, result);
-            results.push(repoResult);
+            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, repoResult.message);
+                logger.success(current, repoName, result.message);
             }
             else {
                 logger.error(current, repoName, result.message);
             }
-            plan.resources.push(...syncResultToResources(repoName, repoConfig, result));
         }
         catch (error) {
             logger.error(current, repoName, String(error));
-            results.push(buildErrorResult(repoName, error));
-            plan.errors.push({
-                repo: repoName,
-                message: error instanceof Error ? error.message : String(error),
+            reportResults.push({
+                repoName,
+                success: false,
+                fileChanges: [],
+                error: error instanceof Error ? error.message : String(error),
             });
         }
     }
+    // Build and display report
+    const report = buildSyncReport(reportResults);
     console.log("");
-    printPlan(plan);
-    writePlanSummary(plan, {
-        title: "Config Sync Summary",
-        dryRun: options.dryRun ?? false,
-    });
-    if (plan.errors && plan.errors.length > 0) {
+    for (const line of formatSyncReportCLI(report)) {
+        console.log(line);
+    }
+    writeSyncReportSummary(report, options.dryRun ?? false);
+    // Exit with error if any failures
+    const hasErrors = reportResults.some((r) => r.error);
+    if (hasErrors) {
         process.exit(1);
     }
 }

package/dist/cli/sync-report-builder.d.ts

@@ -0,0 +1,15 @@
+import type { SyncReport } from "../output/sync-report.js";
+interface FileChangeInput {
+    path: string;
+    action: "create" | "update" | "delete";
+}
+interface SyncResultInput {
+    repoName: string;
+    success: boolean;
+    fileChanges: FileChangeInput[];
+    prUrl?: string;
+    mergeOutcome?: "manual" | "auto" | "force" | "direct";
+    error?: string;
+}
+export declare function buildSyncReport(results: SyncResultInput[]): SyncReport;
+export {};

package/dist/cli/sync-report-builder.js

@@ -0,0 +1,29 @@
+export function buildSyncReport(results) {
+    const repos = [];
+    const totals = {
+        files: { create: 0, update: 0, delete: 0 },
+    };
+    for (const result of results) {
+        const files = result.fileChanges.map((f) => ({
+            path: f.path,
+            action: f.action,
+        }));
+        // Count totals
+        for (const file of files) {
+            if (file.action === "create")
+                totals.files.create++;
+            else if (file.action === "update")
+                totals.files.update++;
+            else if (file.action === "delete")
+                totals.files.delete++;
+        }
+        repos.push({
+            repoName: result.repoName,
+            files,
+            prUrl: result.prUrl,
+            mergeOutcome: result.mergeOutcome,
+            error: result.error,
+        });
+    }
+    return { repos, totals };
+}

package/dist/output/index.d.ts

@@ -1,4 +1,4 @@
-export { formatResourceId, formatResourceLine, formatPlanSummary, formatPlan, printPlan, type ResourceType, type ResourceAction, type Resource, type ResourceDetails, type PropertyChange, type PlanCounts, type Plan, type RepoError, } from "./plan-formatter.js";
-export { formatPlanMarkdown, writePlanSummary, type PlanMarkdownOptions, } from "./plan-summary.js";
+export { formatSyncReportCLI, formatSyncReportMarkdown, writeSyncReportSummary, type SyncReport, type RepoFileChanges, type FileChange, } from "./sync-report.js";
+export { formatSettingsReportCLI, formatSettingsReportMarkdown, writeSettingsReportSummary, type SettingsReport, type RepoChanges, type RulesetChange, type SettingChange, } from "./settings-report.js";
 export { formatSummary, isGitHubActions, writeSummary, type MergeOutcome, type FileChanges, type RulesetPlanDetail, type RepoSettingsPlanDetail, type RepoResult, type SummaryData, } from "./github-summary.js";
 export { getMergeOutcome, toFileChanges, buildRepoResult, buildErrorResult, } from "./summary-utils.js";

package/dist/output/index.js

@@ -1,7 +1,7 @@
-// Plan formatting (console output with chalk)
-export { formatResourceId, formatResourceLine, formatPlanSummary, formatPlan, printPlan, } from "./plan-formatter.js";
-// Plan summary (markdown output for GitHub)
-export { formatPlanMarkdown, writePlanSummary, } from "./plan-summary.js";
+// Sync report (repo-grouped file changes)
+export { formatSyncReportCLI, formatSyncReportMarkdown, writeSyncReportSummary, } from "./sync-report.js";
+// Settings report (repo-grouped settings changes)
+export { formatSettingsReportCLI, formatSettingsReportMarkdown, writeSettingsReportSummary, } from "./settings-report.js";
 // GitHub Actions summary
 export { formatSummary, isGitHubActions, writeSummary, } from "./github-summary.js";
 // Summary utilities

package/dist/output/settings-report.d.ts

@@ -0,0 +1,37 @@
+import { type PropertyDiff } from "../settings/rulesets/formatter.js";
+import type { Ruleset } from "../config/index.js";
+export interface SettingsReport {
+    repos: RepoChanges[];
+    totals: {
+        settings: {
+            add: number;
+            change: number;
+        };
+        rulesets: {
+            create: number;
+            update: number;
+            delete: number;
+        };
+    };
+}
+export interface RepoChanges {
+    repoName: string;
+    settings: SettingChange[];
+    rulesets: RulesetChange[];
+    error?: string;
+}
+export interface SettingChange {
+    name: string;
+    action: "add" | "change";
+    oldValue?: unknown;
+    newValue: unknown;
+}
+export interface RulesetChange {
+    name: string;
+    action: "create" | "update" | "delete";
+    propertyDiffs?: PropertyDiff[];
+    config?: Ruleset;
+}
+export declare function formatSettingsReportCLI(report: SettingsReport): string[];
+export declare function formatSettingsReportMarkdown(report: SettingsReport, dryRun: boolean): string;
+export declare function writeSettingsReportSummary(report: SettingsReport, dryRun: boolean): void;