@aspruyt/xfg 6.1.0 → 6.3.0

package/dist/settings/variables/formatter.js

@@ -0,0 +1,70 @@
+import chalk from "chalk";
+import { countActions } from "../base-processor.js";
+export function formatVariablesPlan(changes) {
+    const lines = [];
+    const entries = [];
+    const { create: creates, update: updates, delete: deletes, unchanged, } = countActions(changes);
+    const grouped = {
+        create: [],
+        update: [],
+        delete: [],
+        unchanged: [],
+    };
+    for (const c of changes) {
+        grouped[c.action].push(c);
+    }
+    if (grouped.create.length > 0) {
+        lines.push(chalk.bold("  Create:"));
+        for (const change of grouped.create) {
+            lines.push(chalk.green(`    + variable "${change.name}"`));
+            if (change.newValue !== undefined) {
+                lines.push(chalk.green(`        value: "${change.newValue}"`));
+            }
+            entries.push({
+                name: change.name,
+                action: "create",
+                newValue: change.newValue,
+            });
+            lines.push("");
+        }
+    }
+    if (grouped.update.length > 0) {
+        lines.push(chalk.bold("  Update:"));
+        for (const change of grouped.update) {
+            lines.push(chalk.yellow(`    ~ variable "${change.name}"`));
+            if (change.oldValue !== undefined && change.newValue !== undefined) {
+                lines.push(chalk.yellow(`        value: "${change.oldValue}" → "${change.newValue}"`));
+            }
+            entries.push({
+                name: change.name,
+                action: "update",
+                oldValue: change.oldValue,
+                newValue: change.newValue,
+            });
+            lines.push("");
+        }
+    }
+    if (grouped.delete.length > 0) {
+        lines.push(chalk.bold("  Delete:"));
+        for (const change of grouped.delete) {
+            lines.push(chalk.red(`    - variable "${change.name}"`));
+            entries.push({ name: change.name, action: "delete" });
+        }
+        lines.push("");
+    }
+    for (const change of grouped.unchanged) {
+        entries.push({ name: change.name, action: "unchanged" });
+    }
+    const total = creates + updates + deletes;
+    if (total > 0) {
+        const parts = [];
+        if (creates > 0)
+            parts.push(`${creates} to create`);
+        if (updates > 0)
+            parts.push(`${updates} to update`);
+        if (deletes > 0)
+            parts.push(`${deletes} to delete`);
+        lines.push(`  Plan: ${total} variables (${parts.join(", ")})`);
+    }
+    return { lines, creates, updates, deletes, unchanged, entries };
+}

package/dist/settings/variables/github-variables-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 { IVariablesStrategy, GitHubVariable } from "./types.js";
+interface GitHubVariablesStrategyOptions {
+    retries?: number;
+    cwd: string;
+}
+export declare class GitHubVariablesStrategy implements IVariablesStrategy {
+    private api;
+    constructor(executor: ICommandExecutor, options: GitHubVariablesStrategyOptions);
+    list(repoInfo: RepoInfo, options?: GhApiOptions): Promise<GitHubVariable[]>;
+    create(repoInfo: RepoInfo, name: string, value: string, options?: GhApiOptions): Promise<void>;
+    update(repoInfo: RepoInfo, name: string, value: string, options?: GhApiOptions): Promise<void>;
+    delete(repoInfo: RepoInfo, name: string, options?: GhApiOptions): Promise<void>;
+}
+export {};

package/dist/settings/variables/github-variables-strategy.js

@@ -0,0 +1,40 @@
+import { assertGitHubRepo } from "../../repo/index.js";
+import { GhApiClient } from "../../shared/gh-api-utils.js";
+import { parseApiJson } from "../../shared/json-utils.js";
+export class GitHubVariablesStrategy {
+    api;
+    constructor(executor, options) {
+        this.api = new GhApiClient(executor, options.retries ?? 3, options.cwd);
+    }
+    async list(repoInfo, options) {
+        assertGitHubRepo(repoInfo, "GitHub Variables strategy");
+        const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}/actions/variables`;
+        const result = await this.api.call("GET", endpoint, {
+            options,
+            paginate: true,
+        });
+        const response = parseApiJson(result, "variables response");
+        return response.variables ?? [];
+    }
+    async create(repoInfo, name, value, options) {
+        assertGitHubRepo(repoInfo, "GitHub Variables strategy");
+        const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}/actions/variables`;
+        await this.api.call("POST", endpoint, {
+            payload: { name, value },
+            options,
+        });
+    }
+    async update(repoInfo, name, value, options) {
+        assertGitHubRepo(repoInfo, "GitHub Variables strategy");
+        const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}/actions/variables/${encodeURIComponent(name)}`;
+        await this.api.call("PATCH", endpoint, {
+            payload: { value },
+            options,
+        });
+    }
+    async delete(repoInfo, name, options) {
+        assertGitHubRepo(repoInfo, "GitHub Variables strategy");
+        const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}/actions/variables/${encodeURIComponent(name)}`;
+        await this.api.call("DELETE", endpoint, { options });
+    }
+}

package/dist/settings/variables/index.d.ts

@@ -0,0 +1,4 @@
+export { type VariableChange, type VariableAction } from "./diff.js";
+export { type VariablesPlanEntry } from "./formatter.js";
+export { VariablesProcessor, type IVariablesProcessor } from "./processor.js";
+export { GitHubVariablesStrategy } from "./github-variables-strategy.js";

package/dist/settings/variables/index.js

@@ -0,0 +1,2 @@
+export { VariablesProcessor } from "./processor.js";
+export { GitHubVariablesStrategy } from "./github-variables-strategy.js";

package/dist/settings/variables/processor.d.ts

@@ -0,0 +1,19 @@
+import type { RepoConfig } from "../../config/index.js";
+import type { RepoInfo } from "../../repo/index.js";
+import { type VariablesPlanResult } from "./formatter.js";
+import type { IVariablesStrategy } from "./types.js";
+import { type BaseProcessorOptions, type BaseProcessorResult, type ISettingsProcessor, type ChangeCounts } from "../base-processor.js";
+export type IVariablesProcessor = ISettingsProcessor<VariablesProcessorOptions, VariablesProcessorResult>;
+export interface VariablesProcessorOptions extends BaseProcessorOptions {
+    noDelete?: boolean;
+}
+export interface VariablesProcessorResult extends BaseProcessorResult {
+    changes?: ChangeCounts;
+    planOutput?: VariablesPlanResult;
+}
+export declare class VariablesProcessor implements IVariablesProcessor {
+    private readonly strategy;
+    constructor(strategy: IVariablesStrategy);
+    process(repoConfig: RepoConfig, repoInfo: RepoInfo, options: VariablesProcessorOptions): Promise<VariablesProcessorResult>;
+    private applySettings;
+}

package/dist/settings/variables/processor.js

@@ -0,0 +1,60 @@
+import { diffVariables } from "./diff.js";
+import { formatVariablesPlan } from "./formatter.js";
+import { withGitHubGuards, countActions, buildDryRunResult, buildApplyResult, } from "../base-processor.js";
+export class VariablesProcessor {
+    strategy;
+    constructor(strategy) {
+        this.strategy = strategy;
+    }
+    async process(repoConfig, repoInfo, options) {
+        return withGitHubGuards(repoConfig, repoInfo, options, {
+            hasDesiredSettings: (rc) => {
+                const vars = rc.settings?.variables ?? {};
+                const { deleteOrphaned, ...entries } = vars;
+                return Object.keys(entries).length > 0 || deleteOrphaned === true;
+            },
+            emptySettingsMessage: "No variables configured",
+            applySettings: (githubRepo, rc, opts, token, repoName) => this.applySettings(githubRepo, rc, opts, token, repoName),
+        });
+    }
+    async applySettings(githubRepo, repoConfig, options, effectiveToken, repoName) {
+        const { dryRun, noDelete } = options;
+        const settings = repoConfig.settings;
+        const { deleteOrphaned: varDeleteOrphaned = false, ...desiredVariables } = (settings?.variables ?? {});
+        const deleteOrphaned = varDeleteOrphaned && !(noDelete ?? false);
+        const strategyOptions = { token: effectiveToken, host: githubRepo.host };
+        const currentVariables = await this.strategy.list(githubRepo, strategyOptions);
+        const changes = diffVariables(currentVariables, desiredVariables, deleteOrphaned);
+        const changeCounts = countActions(changes);
+        const planOutput = formatVariablesPlan(changes);
+        if (dryRun) {
+            return buildDryRunResult(repoName, changeCounts, { planOutput });
+        }
+        let appliedCount = 0;
+        for (const change of changes) {
+            switch (change.action) {
+                case "create":
+                    if (change.newValue !== undefined) {
+                        await this.strategy.create(githubRepo, change.name, change.newValue, strategyOptions);
+                        appliedCount++;
+                    }
+                    break;
+                case "update":
+                    if (change.newValue !== undefined) {
+                        await this.strategy.update(githubRepo, change.name, change.newValue, strategyOptions);
+                        appliedCount++;
+                    }
+                    break;
+                case "delete":
+                    await this.strategy.delete(githubRepo, change.name, strategyOptions);
+                    appliedCount++;
+                    break;
+                case "unchanged":
+                    break;
+            }
+        }
+        return buildApplyResult(repoName, changeCounts, appliedCount, {
+            planOutput,
+        });
+    }
+}

package/dist/settings/variables/types.d.ts

@@ -0,0 +1,18 @@
+import type { RepoInfo } from "../../repo/index.js";
+import type { GhApiOptions } from "../../shared/gh-api-utils.js";
+export interface GitHubVariable {
+    name: string;
+    value: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface GitHubVariablesListResponse {
+    total_count: number;
+    variables: GitHubVariable[];
+}
+export interface IVariablesStrategy {
+    list(repoInfo: RepoInfo, options?: GhApiOptions): Promise<GitHubVariable[]>;
+    create(repoInfo: RepoInfo, name: string, value: string, options?: GhApiOptions): Promise<void>;
+    update(repoInfo: RepoInfo, name: string, value: string, options?: GhApiOptions): Promise<void>;
+    delete(repoInfo: RepoInfo, name: string, options?: GhApiOptions): Promise<void>;
+}

package/dist/settings/variables/types.js

@@ -0,0 +1 @@
+export {};

package/dist/shared/command-executor.d.ts

@@ -1,14 +1,14 @@
 export interface ExecOptions {
-    /** Additional environment variables to set for the command */
     env?: Record<string, string>;
+    input?: string;
 }
 export interface ICommandExecutor {
-    exec(command: string, cwd: string, options?: ExecOptions): Promise<string>;
+    exec(executable: string, args: string[], cwd: string, options?: ExecOptions): Promise<string>;
 }
-export declare class ShellCommandExecutor implements ICommandExecutor {
+export declare class ProcessExecutor implements ICommandExecutor {
     private readonly baseEnv;
     constructor(baseEnv: Record<string, string | undefined>);
-    exec(command: string, cwd: string, options?: ExecOptions): Promise<string>;
+    exec(executable: string, args: string[], cwd: string, options?: ExecOptions): Promise<string>;
 }
 /** Extract stderr string from an exec error (child_process errors attach stderr). */
 export declare function getStderr(error: unknown): string;

package/dist/shared/command-executor.js

@@ -1,24 +1,23 @@
 import { execFileSync } from "node:child_process";
-import { sanitizeCredentials } from "../vcs/sanitize-utils.js";
-export class ShellCommandExecutor {
+import { sanitizeCredentials } from "./sanitize-utils.js";
+export class ProcessExecutor {
     baseEnv;
     constructor(baseEnv) {
         this.baseEnv = baseEnv;
     }
-    async exec(command, cwd, options) {
+    async exec(executable, args, cwd, options) {
         try {
-            return execFileSync("sh", ["-c", command], {
+            return execFileSync(executable, args, {
                 cwd,
                 encoding: "utf-8",
                 stdio: ["pipe", "pipe", "pipe"],
+                input: options?.input,
                 env: options?.env
                     ? { ...this.baseEnv, ...options.env }
                     : this.baseEnv,
             }).trim();
         }
         catch (error) {
-            // Normalise and sanitise the exec error so downstream retry logic
-            // sees a string stderr with no raw credentials.
             const execError = error;
             if (execError.stderr && typeof execError.stderr !== "string") {
                 execError.stderr = execError.stderr.toString();
@@ -41,7 +40,10 @@ export class ShellCommandExecutor {
 export function getStderr(error) {
     if (error != null && typeof error === "object" && "stderr" in error) {
         const { stderr } = error;
-        return typeof stderr === "string" ? stderr : "";
+        if (typeof stderr === "string")
+            return stderr;
+        if (Buffer.isBuffer(stderr))
+            return stderr.toString();
     }
     return "";
 }

package/dist/shared/diff-format.d.ts

@@ -0,0 +1 @@
+export declare function formatDiffLine(line: string): string;

package/dist/shared/diff-format.js

@@ -0,0 +1,10 @@
+import chalk from "chalk";
+export function formatDiffLine(line) {
+    if (line.startsWith("+"))
+        return chalk.green(line);
+    if (line.startsWith("-"))
+        return chalk.red(line);
+    if (line.startsWith("@@"))
+        return chalk.cyan(line);
+    return line;
+}

package/dist/shared/env-resolver.d.ts

@@ -0,0 +1,16 @@
+export interface IEnvResolver {
+    resolve(envName: string): string;
+    resolveAll(entries: {
+        name: string;
+        envVar: string;
+    }[]): Map<string, string>;
+}
+export declare class EnvResolver implements IEnvResolver {
+    private readonly env;
+    constructor(env: Record<string, string | undefined>);
+    resolve(envName: string): string;
+    resolveAll(entries: {
+        name: string;
+        envVar: string;
+    }[]): Map<string, string>;
+}

package/dist/shared/env-resolver.js

@@ -0,0 +1,33 @@
+export class EnvResolver {
+    env;
+    constructor(env) {
+        this.env = env;
+    }
+    resolve(envName) {
+        const value = this.env[envName];
+        if (value === undefined) {
+            throw new Error(`Environment variable '${envName}' is not set.`);
+        }
+        if (value === "") {
+            throw new Error(`Environment variable '${envName}' is empty.`);
+        }
+        return value;
+    }
+    resolveAll(entries) {
+        const missing = new Set();
+        const result = new Map();
+        for (const { name, envVar } of entries) {
+            const value = this.env[envVar];
+            if (value === undefined || value === "") {
+                missing.add(envVar);
+            }
+            else {
+                result.set(name, value);
+            }
+        }
+        if (missing.size > 0) {
+            throw new Error(`Missing environment variables: ${[...missing].join(", ")}`);
+        }
+        return result;
+    }
+}

package/dist/shared/errors.d.ts

@@ -5,7 +5,7 @@
  */
 export declare class ValidationError extends Error {
     readonly name = "ValidationError";
-    constructor(message: string);
+    constructor(message: string, options?: ErrorOptions);
 }
 /**
  * Thrown when a GitHub GraphQL API call fails.
@@ -14,13 +14,16 @@ export declare class ValidationError extends Error {
  */
 export declare class GraphQLApiError extends Error {
     readonly name = "GraphQLApiError";
-    constructor(message: string);
+    constructor(message: string, options?: ErrorOptions);
 }
 export declare class SyncError extends Error {
     readonly name = "SyncError";
-    constructor(message: string);
+    constructor(message: string, options?: ErrorOptions);
+}
+export interface RateLimitedError {
+    retryAfter?: number;
 }
 export declare class LifecycleError extends Error {
     readonly name = "LifecycleError";
-    constructor(message: string);
+    constructor(message: string, options?: ErrorOptions);
 }

package/dist/shared/errors.js

@@ -5,8 +5,8 @@
  */
 export class ValidationError extends Error {
     name = "ValidationError";
-    constructor(message) {
-        super(message);
+    constructor(message, options) {
+        super(message, options);
     }
 }
 /**
@@ -16,19 +16,19 @@ export class ValidationError extends Error {
  */
 export class GraphQLApiError extends Error {
     name = "GraphQLApiError";
-    constructor(message) {
-        super(message);
+    constructor(message, options) {
+        super(message, options);
     }
 }
 export class SyncError extends Error {
     name = "SyncError";
-    constructor(message) {
-        super(message);
+    constructor(message, options) {
+        super(message, options);
     }
 }
 export class LifecycleError extends Error {
     name = "LifecycleError";
-    constructor(message) {
-        super(message);
+    constructor(message, options) {
+        super(message, options);
     }
 }

package/dist/shared/gh-api-utils.d.ts

@@ -1,12 +1,8 @@
 import type { ICommandExecutor } from "./command-executor.js";
-import type { DebugWarnLog } from "./logger.js";
 export interface GitHubApiTarget {
     host: string;
     owner: string;
 }
-interface ITokenManager {
-    getTokenForRepo(repoInfo: GitHubApiTarget): Promise<string | null>;
-}
 type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
 export interface GhApiOptions {
     token?: string;
@@ -20,10 +16,10 @@ interface GhApiCallParams {
     _retryDelay?: (ms: number) => Promise<void>;
 }
 /**
- * Get the hostname flag for gh commands.
- * Returns "--hostname HOST" for GHE, empty string for github.com.
+ * Build the hostname args for gh commands.
+ * Returns ["--hostname", HOST] for GHE, empty array for github.com.
  */
-export declare function getHostnameFlag(repoInfo: Pick<GitHubApiTarget, "host">): string;
+export declare function buildHostnameArgs(repoInfo: Pick<GitHubApiTarget, "host">): string[];
 export declare function buildTokenEnv(token?: string): Record<string, string> | undefined;
 /**
  * Strips HTTP response headers from `gh api --include` output.
@@ -31,13 +27,6 @@ export declare function buildTokenEnv(token?: string): Record<string, string> |
  * If no blank line is found, returns the full string (no headers present).
  */
 export declare function parseResponseBody(raw: string): string;
-/**
- * Parses Retry-After header from an exec error's stdout and attaches it
- * as error.retryAfter (number of seconds). Only extracts the numeric value
- * to avoid leaking tokens from other headers.
- *
- * No-op if stdout is absent or does not contain a numeric Retry-After header.
- */
 export declare function attachRetryAfter(error: unknown): void;
 /**
  * Extracts GitHub API validation error details from `gh api --include` stdout
@@ -59,24 +48,4 @@ export declare class GhApiClient {
     constructor(executor: ICommandExecutor, retries: number, cwd: string);
     call(method: HttpMethod, endpoint: string, params?: GhApiCallParams): Promise<string>;
 }
-interface ResolveGitHubTokenOptions {
-    repoInfo: GitHubApiTarget;
-    tokenManager: ITokenManager | null;
-    context: string;
-    log?: DebugWarnLog;
-    envToken?: string;
-}
-/**
- * Resolve a GitHub token for a repo: GitHub App token → envToken fallback.
- * Returns { token, skipped } where skipped=true means no App installation found
- * for this owner (token will be undefined). Both sync and settings paths use this.
- */
-export declare function resolveGitHubToken(options: ResolveGitHubTokenOptions): Promise<{
-    token: string | undefined;
-    skipped: boolean;
-}>;
-/**
- * Check if an error message indicates an HTTP 404 response from the GitHub API.
- */
-export declare function isHttp404Error(error: unknown): boolean;
 export {};

package/dist/shared/gh-api-utils.js

@@ -1,15 +1,13 @@
-import { escapeShellArg } from "./shell-utils.js";
 import { withRetry } from "./retry-utils.js";
-import { toErrorMessage } from "./type-guards.js";
 /**
- * Get the hostname flag for gh commands.
- * Returns "--hostname HOST" for GHE, empty string for github.com.
+ * Build the hostname args for gh commands.
+ * Returns ["--hostname", HOST] for GHE, empty array for github.com.
  */
-export function getHostnameFlag(repoInfo) {
+export function buildHostnameArgs(repoInfo) {
     if (repoInfo.host !== "github.com") {
-        return `--hostname ${escapeShellArg(repoInfo.host)}`;
+        return ["--hostname", repoInfo.host];
     }
-    return "";
+    return [];
 }
 export function buildTokenEnv(token) {
     return token ? { GH_TOKEN: token } : undefined;
@@ -38,10 +36,17 @@ export function parseResponseBody(raw) {
  *
  * No-op if stdout is absent or does not contain a numeric Retry-After header.
  */
+function hasStdout(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "stdout" in error &&
+        (typeof error.stdout === "string" ||
+            Buffer.isBuffer(error.stdout)));
+}
 export function attachRetryAfter(error) {
-    const stdout = error.stdout;
-    if (!stdout)
+    if (!hasStdout(error))
         return;
+    const stdout = error.stdout;
     const stdoutStr = typeof stdout === "string" ? stdout : stdout.toString();
     const match = stdoutStr.match(/^retry-after:\s*(\d+)\s*$/im);
     if (match) {
@@ -57,9 +62,9 @@ export function attachRetryAfter(error) {
  * No-op if stdout is absent or does not contain parseable error JSON.
  */
 export function attachValidationDetails(error) {
-    const stdout = error.stdout;
-    if (!stdout)
+    if (!hasStdout(error))
         return;
+    const stdout = error.stdout;
     const stdoutStr = typeof stdout === "string" ? stdout : stdout.toString();
     const body = parseResponseBody(stdoutStr);
     try {
@@ -93,7 +98,7 @@ export function attachValidationDetails(error) {
  */
 async function ghApiCall(method, endpoint, opts) {
     const { executor, retries, cwd, apiOpts, payload, paginate } = opts;
-    const args = ["gh", "api"];
+    const args = ["api"];
     if (method !== "GET") {
         args.push("-X", method);
     }
@@ -104,14 +109,13 @@ async function ghApiCall(method, endpoint, opts) {
         args.push("--include");
     }
     if (apiOpts?.host && apiOpts.host !== "github.com") {
-        args.push("--hostname", escapeShellArg(apiOpts.host));
+        args.push("--hostname", apiOpts.host);
     }
-    args.push(escapeShellArg(endpoint));
-    const baseCommand = args.join(" ");
+    args.push(endpoint);
     const env = buildTokenEnv(apiOpts?.token);
-    const execAndParse = async (command) => {
+    const execAndParse = async (execArgs, execOptions) => {
         try {
-            const raw = await executor.exec(command, cwd, { env });
+            const raw = await executor.exec("gh", execArgs, cwd, execOptions);
             return paginate ? raw : parseResponseBody(raw);
         }
         catch (error) {
@@ -129,10 +133,9 @@ async function ghApiCall(method, endpoint, opts) {
     if (payload &&
         (method === "POST" || method === "PUT" || method === "PATCH")) {
         const payloadJson = JSON.stringify(payload);
-        const command = `echo ${escapeShellArg(payloadJson)} | ${baseCommand} --input -`;
-        return withRetry(() => execAndParse(command), retryOpts);
+        return withRetry(() => execAndParse([...args, "--input", "-"], { env, input: payloadJson }), retryOpts);
     }
-    return withRetry(() => execAndParse(baseCommand), retryOpts);
+    return withRetry(() => execAndParse(args, { env }), retryOpts);
 }
 /**
  * Encapsulates executor + retries for GitHub API calls.
@@ -159,36 +162,3 @@ export class GhApiClient {
         });
     }
 }
-/**
- * Resolve a GitHub token for a repo: GitHub App token → envToken fallback.
- * Returns { token, skipped } where skipped=true means no App installation found
- * for this owner (token will be undefined). Both sync and settings paths use this.
- */
-export async function resolveGitHubToken(options) {
-    const { repoInfo, tokenManager, context, log, envToken } = options;
-    try {
-        const appToken = await tokenManager?.getTokenForRepo(repoInfo);
-        if (appToken === null) {
-            // null = no installation found for this owner
-            return { token: undefined, skipped: true };
-        }
-        // string = app token; undefined = no manager configured
-        return { token: appToken ?? envToken, skipped: false };
-    }
-    catch (error) {
-        const errorMsg = `GitHub App token resolution failed for ${context}: ${toErrorMessage(error)}`;
-        if (envToken) {
-            log?.debug(`${errorMsg}; falling back to GH_TOKEN`);
-        }
-        else {
-            log?.warn(`${errorMsg}; no fallback token available`);
-        }
-        return { token: envToken, skipped: false };
-    }
-}
-/**
- * Check if an error message indicates an HTTP 404 response from the GitHub API.
- */
-export function isHttp404Error(error) {
-    return toErrorMessage(error).includes("HTTP 404");
-}

package/dist/shared/gh-token-utils.d.ts

@@ -0,0 +1,26 @@
+import type { DebugWarnLog } from "./logger.js";
+import type { GitHubApiTarget } from "./gh-api-utils.js";
+interface ITokenManager {
+    getTokenForRepo(repoInfo: GitHubApiTarget): Promise<string | null>;
+}
+export interface ResolveGitHubTokenOptions {
+    repoInfo: GitHubApiTarget;
+    tokenManager: ITokenManager | null;
+    context: string;
+    log?: DebugWarnLog;
+    envToken?: string;
+}
+/**
+ * Resolve a GitHub token for a repo: GitHub App token → envToken fallback.
+ * Returns { token, skipped } where skipped=true means no App installation found
+ * for this owner (token will be undefined). Both sync and settings paths use this.
+ */
+export declare function resolveGitHubToken(options: ResolveGitHubTokenOptions): Promise<{
+    token: string | undefined;
+    skipped: boolean;
+}>;
+/**
+ * Check if an error message indicates an HTTP 404 response from the GitHub API.
+ */
+export declare function isHttp404Error(error: unknown): boolean;
+export {};