@aspruyt/xfg 6.1.0 → 6.3.0

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

@@ -17,6 +17,11 @@ export interface SettingsReport {
             update: number;
             delete: number;
         };
+        variables?: {
+            create: number;
+            update: number;
+            delete: number;
+        };
     };
 }
 export interface RepoChanges {
@@ -24,6 +29,12 @@ export interface RepoChanges {
     settings: SettingChange[];
     rulesets: RulesetChange[];
     labels: LabelChange[];
+    variables?: {
+        name: string;
+        action: ActiveAction;
+        oldValue?: string;
+        newValue?: string;
+    }[];
     error?: string;
 }
 export interface SettingChange {

package/dist/output/settings-report.js

@@ -90,6 +90,13 @@ function formatSettingsSummary(totals) {
     ]);
     if (labelsEntry)
         parts.push(labelsEntry);
+    const variablesEntry = formatCountEntry("variable", "variables", [
+        { label: "to create", value: totals.variables?.create ?? 0 },
+        { label: "to update", value: totals.variables?.update ?? 0 },
+        { label: "to delete", value: totals.variables?.delete ?? 0 },
+    ]);
+    if (variablesEntry)
+        parts.push(variablesEntry);
     if (parts.length === 0) {
         return "No changes";
     }
@@ -112,6 +119,7 @@ export function formatSettingsReportCLI(report) {
         if (repo.settings.length === 0 &&
             repo.rulesets.length === 0 &&
             repo.labels.length === 0 &&
+            (repo.variables ?? []).length === 0 &&
             !repo.error) {
             continue;
         }
@@ -231,6 +239,21 @@ export function renderRepoSettingsDiffLines(repo, diffLines) {
             diffLines.push(`- label "${label.name}"`);
         }
     }
+    // Blank line before variables if there was content above
+    if ((repo.variables ?? []).length > 0 && diffLines.length > startLength) {
+        diffLines.push("");
+    }
+    for (const variable of repo.variables ?? []) {
+        if (variable.action === "create") {
+            diffLines.push(`+ variable "${variable.name}": ${formatValuePlain(variable.newValue)}`);
+        }
+        else if (variable.action === "update") {
+            diffLines.push(`! variable "${variable.name}": ${formatValuePlain(variable.oldValue)} → ${formatValuePlain(variable.newValue)}`);
+        }
+        else if (variable.action === "delete") {
+            diffLines.push(`- variable "${variable.name}"`);
+        }
+    }
     if (repo.error) {
         diffLines.push(`- Error: ${repo.error}`);
     }
@@ -252,6 +275,7 @@ export function formatSettingsReportMarkdown(report, dryRun) {
         if (repo.settings.length === 0 &&
             repo.rulesets.length === 0 &&
             repo.labels.length === 0 &&
+            (repo.variables ?? []).length === 0 &&
             !repo.error) {
             continue;
         }

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

@@ -1,6 +1,28 @@
-import type { SyncReport, RepoFileChanges, ReportFileChange } from "./types.js";
-export type { SyncReport, RepoFileChanges, ReportFileChange };
+import type { MergeMode } from "../config/index.js";
+import type { ActiveAction } from "../settings/index.js";
+export interface ReportFileChange {
+    path: string;
+    action: ActiveAction;
+    diffLines?: string[];
+}
+export interface SyncReport {
+    repos: RepoFileChanges[];
+    totals: {
+        files: {
+            create: number;
+            update: number;
+            delete: number;
+        };
+    };
+}
+export interface RepoFileChanges {
+    repoName: string;
+    files: ReportFileChange[];
+    prUrl?: string;
+    mergeOutcome?: MergeMode;
+    error?: string;
+}
 export declare function formatSyncReportCLI(report: SyncReport): string[];
 export declare function formatSyncReportMarkdown(report: SyncReport, dryRun: boolean): string;
-export declare function renderSyncLines(syncRepo: RepoFileChanges, diffLines: string[]): void;
+export declare function renderSyncLines(syncRepo: RepoFileChanges): string[];
 export declare function writeSyncReportSummary(report: SyncReport, dryRun: boolean, summaryPath: string | undefined): void;

package/dist/output/sync-report.js

@@ -1,7 +1,7 @@
 import chalk from "chalk";
 import { writeGitHubStepSummary } from "./github-summary.js";
 import { formatCountEntry } from "./settings-report.js";
-import { formatDiffLine } from "../sync/index.js";
+import { formatDiffLine } from "../shared/diff-format.js";
 function formatSyncSummary(totals) {
     const entry = formatCountEntry("file", "files", [
         { label: "to create", value: totals.files.create },
@@ -65,8 +65,7 @@ export function formatSyncReportMarkdown(report, dryRun) {
         }
         lines.push(`### ${repo.repoName}`);
         lines.push("");
-        const diffLines = [];
-        renderSyncLines(repo, diffLines);
+        const diffLines = renderSyncLines(repo);
         if (diffLines.length > 0) {
             lines.push("```diff");
             lines.push(...diffLines);
@@ -78,28 +77,29 @@ export function formatSyncReportMarkdown(report, dryRun) {
     lines.push(`**${formatSyncSummary(report.totals)}**`);
     return lines.join("\n");
 }
-export function renderSyncLines(syncRepo, diffLines) {
+export function renderSyncLines(syncRepo) {
+    const lines = [];
     for (let i = 0; i < syncRepo.files.length; i++) {
         const file = syncRepo.files[i];
-        // Blank line between files for readability
         if (i > 0)
-            diffLines.push("");
+            lines.push("");
         if (file.action === "create") {
-            diffLines.push(`+ ${file.path}`);
+            lines.push(`+ ${file.path}`);
         }
         else if (file.action === "update") {
-            diffLines.push(`! ${file.path}`);
+            lines.push(`! ${file.path}`);
         }
         else if (file.action === "delete") {
-            diffLines.push(`- ${file.path}`);
+            lines.push(`- ${file.path}`);
         }
         if (file.diffLines) {
-            diffLines.push(...file.diffLines);
+            lines.push(...file.diffLines);
         }
     }
     if (syncRepo.error) {
-        diffLines.push(`- Error: ${syncRepo.error}`);
+        lines.push(`- Error: ${syncRepo.error}`);
     }
+    return lines;
 }
 export function writeSyncReportSummary(report, dryRun, summaryPath) {
     const markdown = formatSyncReportMarkdown(report, dryRun);

package/dist/secrets/encryption.d.ts

@@ -0,0 +1,9 @@
+export interface ISecretEncryptor {
+    encrypt(value: string, publicKeyBase64: string): Promise<string>;
+}
+export declare class SodiumEncryptor implements ISecretEncryptor {
+    private sodium;
+    private initPromise;
+    private ensureInitialized;
+    encrypt(value: string, publicKeyBase64: string): Promise<string>;
+}

package/dist/secrets/encryption.js

@@ -0,0 +1,29 @@
+export class SodiumEncryptor {
+    sodium;
+    initPromise = null;
+    ensureInitialized() {
+        if (!this.initPromise) {
+            this.initPromise = (async () => {
+                try {
+                    const sodium = await import("libsodium-wrappers");
+                    await sodium.default.ready;
+                    this.sodium = sodium.default;
+                }
+                catch {
+                    throw new Error("Failed to load libsodium-wrappers. Install it: npm install libsodium-wrappers");
+                }
+            })().catch((err) => {
+                this.initPromise = null;
+                throw err;
+            });
+        }
+        return this.initPromise.then(() => this.sodium);
+    }
+    async encrypt(value, publicKeyBase64) {
+        const sodium = await this.ensureInitialized();
+        const messageBytes = sodium.from_string(value);
+        const publicKey = sodium.from_base64(publicKeyBase64, sodium.base64_variants.ORIGINAL);
+        const encrypted = sodium.crypto_box_seal(messageBytes, publicKey);
+        return sodium.to_base64(encrypted, sodium.base64_variants.ORIGINAL);
+    }
+}

package/dist/secrets/github-secrets-strategy.d.ts

@@ -0,0 +1,17 @@
+import type { ICommandExecutor } from "../shared/command-executor.js";
+import { type RepoInfo } from "../repo/index.js";
+import { type GhApiOptions } from "../shared/gh-api-utils.js";
+import type { ISecretsStrategy, GitHubSecret, GitHubPublicKey } from "./types.js";
+interface GitHubSecretsStrategyOptions {
+    retries?: number;
+    cwd: string;
+}
+export declare class GitHubSecretsStrategy implements ISecretsStrategy {
+    private api;
+    constructor(executor: ICommandExecutor, options: GitHubSecretsStrategyOptions);
+    list(repoInfo: RepoInfo, options?: GhApiOptions): Promise<GitHubSecret[]>;
+    getPublicKey(repoInfo: RepoInfo, options?: GhApiOptions): Promise<GitHubPublicKey>;
+    upsert(repoInfo: RepoInfo, name: string, encryptedValue: string, keyId: string, options?: GhApiOptions): Promise<void>;
+    delete(repoInfo: RepoInfo, name: string, options?: GhApiOptions): Promise<void>;
+}
+export {};

package/dist/secrets/github-secrets-strategy.js

@@ -0,0 +1,38 @@
+import { assertGitHubRepo } from "../repo/index.js";
+import { GhApiClient } from "../shared/gh-api-utils.js";
+import { parseApiJson } from "../shared/json-utils.js";
+export class GitHubSecretsStrategy {
+    api;
+    constructor(executor, options) {
+        this.api = new GhApiClient(executor, options.retries ?? 3, options.cwd);
+    }
+    async list(repoInfo, options) {
+        assertGitHubRepo(repoInfo, "GitHub Secrets strategy");
+        const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}/actions/secrets`;
+        const result = await this.api.call("GET", endpoint, {
+            options,
+            paginate: true,
+        });
+        const response = parseApiJson(result, "secrets response");
+        return response.secrets ?? [];
+    }
+    async getPublicKey(repoInfo, options) {
+        assertGitHubRepo(repoInfo, "GitHub Secrets strategy");
+        const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}/actions/secrets/public-key`;
+        const result = await this.api.call("GET", endpoint, { options });
+        return parseApiJson(result, "public key response");
+    }
+    async upsert(repoInfo, name, encryptedValue, keyId, options) {
+        assertGitHubRepo(repoInfo, "GitHub Secrets strategy");
+        const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}/actions/secrets/${encodeURIComponent(name)}`;
+        await this.api.call("PUT", endpoint, {
+            payload: { encrypted_value: encryptedValue, key_id: keyId },
+            options,
+        });
+    }
+    async delete(repoInfo, name, options) {
+        assertGitHubRepo(repoInfo, "GitHub Secrets strategy");
+        const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}/actions/secrets/${encodeURIComponent(name)}`;
+        await this.api.call("DELETE", endpoint, { options });
+    }
+}

package/dist/secrets/index.d.ts

@@ -0,0 +1,5 @@
+export { SecretsProcessor } from "./processor.js";
+export type { SecretsProcessorOptions, SecretsProcessorResult, } from "./processor.js";
+export { GitHubSecretsStrategy } from "./github-secrets-strategy.js";
+export { SodiumEncryptor, type ISecretEncryptor } from "./encryption.js";
+export type { ISecretsStrategy, GitHubSecret, GitHubPublicKey, } from "./types.js";

package/dist/secrets/index.js

@@ -0,0 +1,3 @@
+export { SecretsProcessor } from "./processor.js";
+export { GitHubSecretsStrategy } from "./github-secrets-strategy.js";
+export { SodiumEncryptor } from "./encryption.js";

package/dist/secrets/processor.d.ts

@@ -0,0 +1,31 @@
+import { type RepoInfo } from "../repo/index.js";
+import type { ISecretsStrategy } from "./types.js";
+import type { ISecretEncryptor } from "./encryption.js";
+import type { IEnvResolver } from "../shared/env-resolver.js";
+import type { SecretConfig } from "../config/index.js";
+type SecretsConfig = Record<string, SecretConfig | boolean> & {
+    deleteOrphaned?: boolean;
+};
+export interface SecretsProcessorOptions {
+    dryRun?: boolean;
+    token?: string;
+    noDelete?: boolean;
+}
+export interface SecretsProcessorResult {
+    success: boolean;
+    repoName: string;
+    message: string;
+    skipped?: boolean;
+    dryRun?: boolean;
+    created: number;
+    updated: number;
+    deleted: number;
+}
+export declare class SecretsProcessor {
+    private readonly strategy;
+    private readonly encryptor;
+    private readonly envResolver;
+    constructor(strategy: ISecretsStrategy, encryptor: ISecretEncryptor, envResolver: IEnvResolver);
+    process(secretsConfig: SecretsConfig, repoInfo: RepoInfo, options: SecretsProcessorOptions): Promise<SecretsProcessorResult>;
+}
+export {};

package/dist/secrets/processor.js

@@ -0,0 +1,115 @@
+import { isGitHubRepo, getRepoDisplayName, } from "../repo/index.js";
+export class SecretsProcessor {
+    strategy;
+    encryptor;
+    envResolver;
+    constructor(strategy, encryptor, envResolver) {
+        this.strategy = strategy;
+        this.encryptor = encryptor;
+        this.envResolver = envResolver;
+    }
+    async process(secretsConfig, repoInfo, options) {
+        const repoName = getRepoDisplayName(repoInfo);
+        if (!isGitHubRepo(repoInfo)) {
+            return {
+                success: true,
+                repoName,
+                message: "Skipped: not a GitHub repository",
+                skipped: true,
+                created: 0,
+                updated: 0,
+                deleted: 0,
+            };
+        }
+        const githubRepo = repoInfo;
+        const { deleteOrphaned: configDeleteOrphaned = false, ...rawEntries } = secretsConfig;
+        const { dryRun, token, noDelete } = options;
+        const deleteOrphaned = configDeleteOrphaned && !(noDelete ?? false);
+        const strategyOptions = { token, host: githubRepo.host };
+        const secretEntries = Object.entries(rawEntries).filter((entry) => typeof entry[1] !== "boolean");
+        let resolvedValues;
+        if (!dryRun && secretEntries.length > 0) {
+            resolvedValues = this.envResolver.resolveAll(secretEntries.map(([name, config]) => ({
+                name,
+                envVar: config.env,
+            })));
+        }
+        else {
+            resolvedValues = new Map();
+        }
+        const currentSecrets = await this.strategy.list(githubRepo, strategyOptions);
+        const currentByName = new Set(currentSecrets.map((s) => s.name.toUpperCase()));
+        const desiredNames = new Set(secretEntries.map(([name]) => name.toUpperCase()));
+        let created = 0;
+        let updated = 0;
+        let deleted = 0;
+        if (!dryRun) {
+            if (secretEntries.length > 0) {
+                const publicKey = await this.strategy.getPublicKey(githubRepo, strategyOptions);
+                for (const [name] of secretEntries) {
+                    const value = resolvedValues.get(name);
+                    const encrypted = await this.encryptor.encrypt(value, publicKey.key);
+                    await this.strategy.upsert(githubRepo, name, encrypted, publicKey.key_id, strategyOptions);
+                    if (currentByName.has(name.toUpperCase())) {
+                        updated++;
+                    }
+                    else {
+                        created++;
+                    }
+                }
+            }
+            if (deleteOrphaned) {
+                for (const current of currentSecrets) {
+                    if (!desiredNames.has(current.name.toUpperCase())) {
+                        await this.strategy.delete(githubRepo, current.name, strategyOptions);
+                        deleted++;
+                    }
+                }
+            }
+        }
+        else {
+            for (const [name] of secretEntries) {
+                if (currentByName.has(name.toUpperCase())) {
+                    updated++;
+                }
+                else {
+                    created++;
+                }
+            }
+            if (deleteOrphaned) {
+                for (const current of currentSecrets) {
+                    if (!desiredNames.has(current.name.toUpperCase())) {
+                        deleted++;
+                    }
+                }
+            }
+        }
+        const parts = [];
+        if (created > 0)
+            parts.push(`${created} created`);
+        if (updated > 0)
+            parts.push(`${updated} updated`);
+        if (deleted > 0)
+            parts.push(`${deleted} deleted`);
+        const summary = parts.length > 0 ? parts.join(", ") : "no changes";
+        if (dryRun) {
+            return {
+                success: true,
+                repoName,
+                message: `[DRY RUN] ${summary}`,
+                dryRun: true,
+                created,
+                updated,
+                deleted,
+            };
+        }
+        return {
+            success: true,
+            repoName,
+            message: summary,
+            created,
+            updated,
+            deleted,
+        };
+    }
+}

package/dist/secrets/types.d.ts

@@ -0,0 +1,21 @@
+import type { RepoInfo } from "../repo/index.js";
+import type { GhApiOptions } from "../shared/gh-api-utils.js";
+export interface GitHubSecret {
+    name: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface GitHubSecretsListResponse {
+    total_count: number;
+    secrets: GitHubSecret[];
+}
+export interface GitHubPublicKey {
+    key_id: string;
+    key: string;
+}
+export interface ISecretsStrategy {
+    list(repoInfo: RepoInfo, options?: GhApiOptions): Promise<GitHubSecret[]>;
+    getPublicKey(repoInfo: RepoInfo, options?: GhApiOptions): Promise<GitHubPublicKey>;
+    upsert(repoInfo: RepoInfo, name: string, encryptedValue: string, keyId: string, options?: GhApiOptions): Promise<void>;
+    delete(repoInfo: RepoInfo, name: string, options?: GhApiOptions): Promise<void>;
+}

package/dist/settings/base-processor.d.ts

@@ -33,11 +33,8 @@ interface SettingsGuards<TOptions extends BaseProcessorOptions, TResult extends
  * empty settings check, token resolution, and error wrapping.
  */
 export declare function withGitHubGuards<TOptions extends BaseProcessorOptions, TResult extends BaseProcessorResult>(repoConfig: RepoConfig, repoInfo: RepoInfo, options: TOptions, guards: SettingsGuards<TOptions, TResult>): Promise<TResult>;
-/** Common action literals shared by all settings processors. */
 export type SettingsAction = "create" | "update" | "delete" | "unchanged";
-/** Actions that represent an actual change (excludes "unchanged"). */
 export type ActiveAction = Exclude<SettingsAction, "unchanged">;
-/** Type predicate that narrows entries with an active (non-"unchanged") action. */
 export declare function isActiveAction<T extends {
     action: SettingsAction;
 }>(entry: T): entry is T & {
@@ -49,14 +46,28 @@ export interface ChangeCounts {
     delete: number;
     unchanged: number;
 }
-/**
- * Count actions from a diff result array.
- * Works with any change type that has an `action` field.
- */
 export declare function countActions(changes: ReadonlyArray<{
     action: SettingsAction;
 }>): ChangeCounts;
 export declare function formatChangeSummary(counts: ChangeCounts): string;
+export interface PlanEntry {
+    property: string;
+    action: "create" | "update";
+    oldValue?: unknown;
+    newValue?: unknown;
+}
+export interface FormatChangeResult {
+    lines: string[];
+    entries: PlanEntry[];
+    creates: number;
+    updates: number;
+}
+export declare function formatChangeLines(changes: ReadonlyArray<{
+    property: string;
+    action: SettingsAction;
+    oldValue?: unknown;
+    newValue?: unknown;
+}>, formatValue: (val: unknown) => string): FormatChangeResult;
 /**
  * Build a standardized dry-run result for settings processors.
  * Returns an intersection of BaseProcessorResult with the extra fields,

package/dist/settings/base-processor.js

@@ -1,3 +1,4 @@
+import chalk from "chalk";
 import { isGitHubRepo, getRepoDisplayName } from "../repo/index.js";
 import { toErrorMessage } from "../shared/type-guards.js";
 /**
@@ -43,14 +44,9 @@ export async function withGitHubGuards(repoConfig, repoInfo, options, guards) {
         });
     }
 }
-/** Type predicate that narrows entries with an active (non-"unchanged") action. */
 export function isActiveAction(entry) {
     return entry.action !== "unchanged";
 }
-/**
- * Count actions from a diff result array.
- * Works with any change type that has an `action` field.
- */
 export function countActions(changes) {
     const counts = {
         create: 0,
@@ -75,6 +71,31 @@ export function formatChangeSummary(counts) {
         parts.push(`${counts.unchanged} unchanged`);
     return parts.length > 0 ? parts.join(", ") : "no changes";
 }
+export function formatChangeLines(changes, formatValue) {
+    const lines = [];
+    const entries = [];
+    const { create: creates, update: updates } = countActions(changes);
+    for (const change of changes) {
+        if (change.action === "create") {
+            lines.push(chalk.green(`    + ${change.property}: ${formatValue(change.newValue)}`));
+            entries.push({
+                property: change.property,
+                action: "create",
+                newValue: change.newValue,
+            });
+        }
+        else if (change.action === "update") {
+            lines.push(chalk.yellow(`    ~ ${change.property}: ${formatValue(change.oldValue)} → ${formatValue(change.newValue)}`));
+            entries.push({
+                property: change.property,
+                action: "update",
+                oldValue: change.oldValue,
+                newValue: change.newValue,
+            });
+        }
+    }
+    return { lines, entries, creates, updates };
+}
 /**
  * Build a standardized dry-run result for settings processors.
  * Returns an intersection of BaseProcessorResult with the extra fields,

package/dist/settings/code-scanning/diff.js

@@ -44,8 +44,8 @@ export function diffCodeScanning(current, desired) {
     }
     // languages: only diff if specified in desired (sorted comparison)
     if (desired.languages !== undefined) {
-        const currentLangs = [...(current.languages ?? [])].sort();
-        const desiredLangs = [...desired.languages].sort();
+        const currentLangs = [...(current.languages ?? [])].sort((a, b) => a.localeCompare(b));
+        const desiredLangs = [...desired.languages].sort((a, b) => a.localeCompare(b));
         const langsMatch = currentLangs.length === desiredLangs.length &&
             currentLangs.every((lang, i) => lang === desiredLangs[i]);
         if (!langsMatch) {

package/dist/settings/code-scanning/formatter.d.ts

@@ -1,10 +1,6 @@
 import type { CodeScanningChange } from "./diff.js";
-export interface CodeScanningPlanEntry {
-    property: string;
-    action: "create" | "update";
-    oldValue?: unknown;
-    newValue?: unknown;
-}
+import { type PlanEntry } from "../base-processor.js";
+export type CodeScanningPlanEntry = PlanEntry;
 export interface CodeScanningPlanResult {
     lines: string[];
     creates: number;

package/dist/settings/code-scanning/formatter.js

@@ -1,6 +1,5 @@
-import chalk from "chalk";
 import { formatScalarValue } from "../../shared/string-utils.js";
-import { countActions } from "../base-processor.js";
+import { formatChangeLines } from "../base-processor.js";
 function formatValue(val) {
     if (Array.isArray(val)) {
         return `[${val.join(", ")}]`;
@@ -11,27 +10,5 @@ function formatValue(val) {
  * Formats code scanning changes as Terraform-style plan output.
  */
 export function formatCodeScanningPlan(changes) {
-    const lines = [];
-    const entries = [];
-    const { create: creates, update: updates } = countActions(changes);
-    for (const change of changes) {
-        if (change.action === "create") {
-            lines.push(chalk.green(`    + ${change.property}: ${formatValue(change.newValue)}`));
-            entries.push({
-                property: change.property,
-                action: "create",
-                newValue: change.newValue,
-            });
-        }
-        else if (change.action === "update") {
-            lines.push(chalk.yellow(`    ~ ${change.property}: ${formatValue(change.oldValue)} → ${formatValue(change.newValue)}`));
-            entries.push({
-                property: change.property,
-                action: "update",
-                oldValue: change.oldValue,
-                newValue: change.newValue,
-            });
-        }
-    }
-    return { lines, creates, updates, entries };
+    return formatChangeLines(changes, formatValue);
 }

package/dist/settings/code-scanning/github-code-scanning-strategy.d.ts

@@ -1,7 +1,7 @@
 import type { ICommandExecutor } from "../../shared/command-executor.js";
 import { type RepoInfo } from "../../repo/index.js";
 import { type GhApiOptions } from "../../shared/gh-api-utils.js";
-import type { ICodeScanningStrategy, CurrentCodeScanningSettings } from "./types.js";
+import type { ICodeScanningStrategy, CurrentCodeScanningSettings, CodeScanningUpdateParams } from "./types.js";
 interface GitHubCodeScanningStrategyOptions {
     retries?: number;
     cwd: string;
@@ -9,11 +9,7 @@ interface GitHubCodeScanningStrategyOptions {
 export declare class GitHubCodeScanningStrategy implements ICodeScanningStrategy {
     private api;
     constructor(executor: ICommandExecutor, options: GitHubCodeScanningStrategyOptions);
-    getDefaultSetup(repoInfo: RepoInfo, options?: GhApiOptions): Promise<CurrentCodeScanningSettings>;
-    updateDefaultSetup(repoInfo: RepoInfo, settings: {
-        state: string;
-        query_suite?: string;
-        languages?: string[];
-    }, options?: GhApiOptions): Promise<void>;
+    get(repoInfo: RepoInfo, options?: GhApiOptions): Promise<CurrentCodeScanningSettings>;
+    update(repoInfo: RepoInfo, settings: CodeScanningUpdateParams, options?: GhApiOptions): Promise<void>;
 }
 export {};

package/dist/settings/code-scanning/github-code-scanning-strategy.js

@@ -6,13 +6,13 @@ export class GitHubCodeScanningStrategy {
     constructor(executor, options) {
         this.api = new GhApiClient(executor, options.retries ?? 3, options.cwd);
     }
-    async getDefaultSetup(repoInfo, options) {
+    async get(repoInfo, options) {
         assertGitHubRepo(repoInfo, "GitHub Code Scanning strategy");
         const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}/code-scanning/default-setup`;
         const result = await this.api.call("GET", endpoint, { options });
         return parseApiJson(result, "code scanning default setup response");
     }
-    async updateDefaultSetup(repoInfo, settings, options) {
+    async update(repoInfo, settings, options) {
         assertGitHubRepo(repoInfo, "GitHub Code Scanning strategy");
         const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}/code-scanning/default-setup`;
         await this.api.call("PATCH", endpoint, { payload: settings, options });