@companyhelm/cli 0.4.0 → 0.4.2

package/dist/commands/setup-github-app.js

@@ -1,233 +0,0 @@
-import * as clack from "@clack/prompts";
-import chalk from "chalk";
-import { spawn } from "node:child_process";
-import { createInterface } from "node:readline";
-import { Writable } from "node:stream";
-import { unwrapPromptResult, requireInteractiveTerminal, InteractiveCommandCancelledError, hasInteractiveTerminal } from "./interactive.js";
-import { GithubAppConfigStore } from "../core/config/GithubAppConfigStore.js";
-import { normalizeGithubAppConfig } from "../core/config/GithubAppConfig.js";
-const GITHUB_NEW_APP_URL = "https://github.com/settings/apps/new";
-function createHiddenTerminalOutput() {
-    return new Writable({
-        write(_chunk, _encoding, callback) {
-            callback();
-        },
-    });
-}
-function getBrowserOpenCommand(url) {
-    if (process.platform === "darwin") {
-        return { command: "open", args: [url] };
-    }
-    if (process.platform === "win32") {
-        return { command: "cmd", args: ["/c", "start", "", url] };
-    }
-    return { command: "xdg-open", args: [url] };
-}
-async function openUrlInBrowser(url) {
-    const { command, args } = getBrowserOpenCommand(url);
-    await new Promise((resolve, reject) => {
-        const child = spawn(command, args, {
-            detached: true,
-            stdio: "ignore",
-        });
-        child.once("error", reject);
-        child.once("spawn", () => {
-            child.unref();
-            resolve();
-        });
-    });
-}
-function writeGithubAppCreationGuide(output) {
-    const divider = chalk.dim("=".repeat(68));
-    const label = (text) => chalk.bold(chalk.cyan(text));
-    const value = (text) => chalk.white(text);
-    output.write([
-        divider,
-        chalk.bold("Create a GitHub App before continuing"),
-        chalk.dim("CompanyHelm needs a local GitHub App before startup can continue."),
-        chalk.dim("Agents use that app to access and work on your repositories from isolated container workspaces."),
-        chalk.dim("That lets each agent clone repos and operate safely without reusing your host checkout."),
-        "",
-        `${label("New app page")} ${chalk.underline(chalk.green(GITHUB_NEW_APP_URL))}`,
-        "",
-        chalk.bold("Required form values"),
-        `${label("GitHub App name:")} ${value("Any name you like, e.g. companyhelm <your deployment name>")}`,
-        `${label("Public link:")} ${value("Paste your public link here")}`,
-        `${label("Setup URL:")} ${value("http://localhost:4173/github/install")}`,
-        `${label("Redirect on update:")} ${value("Checked")}`,
-        `${label("Webhook:")} ${value("Leave it inactive and uncheck the webhook option")}`,
-        `${label("Permissions:")} ${value("Grant at least Contents so CompanyHelm can download repositories; add any additional permissions your agents need")}`,
-        `${label("Where can this GitHub App be installed?")} ${value("Select Any account")}`,
-        "",
-        chalk.bold("Bring back after creation"),
-        value("App URL, Client ID, and private key PEM"),
-        "",
-        divider,
-        "",
-    ].join("\n"));
-}
-async function promptTextValue(message, input, output, validate) {
-    const value = await clack.text({
-        message,
-        input,
-        output,
-        validate,
-    });
-    return String(unwrapPromptResult(value, "GitHub App setup cancelled.", output)).trim();
-}
-export async function readPemFromTerminal(input = process.stdin, output = process.stdout) {
-    requireInteractiveTerminal(input, output, "setup-github-app requires an interactive terminal.");
-    output.write([
-        "Generate a private key.",
-        "Once downloaded copy the contents (e.g. cat ~/Downloads/{your-app-name}{date}.pem | pbcopy) and paste it here.",
-        "",
-    ].join("\n"));
-    const readline = createInterface({
-        input,
-        output: createHiddenTerminalOutput(),
-        terminal: false,
-    });
-    return await new Promise((resolve, reject) => {
-        const lines = [];
-        let settled = false;
-        const finish = (callback) => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            readline.close();
-            callback();
-        };
-        readline.on("line", (line) => {
-            lines.push(line);
-            if (/^-----END [A-Z0-9 ]+-----$/.test(line.trim())) {
-                finish(() => {
-                    try {
-                        const normalized = normalizeGithubAppConfig({
-                            appUrl: "https://github.com/apps/placeholder",
-                            appClientId: "placeholder",
-                            appPrivateKeyPem: `${lines.join("\n")}\n`,
-                        });
-                        resolve(normalized.appPrivateKeyPem);
-                    }
-                    catch (error) {
-                        reject(error);
-                    }
-                });
-            }
-        });
-        readline.on("close", () => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            reject(new Error("GitHub App PEM input ended before a PEM end marker was received."));
-        });
-        readline.on("SIGINT", () => {
-            finish(() => {
-                reject(new InteractiveCommandCancelledError("GitHub App setup cancelled."));
-            });
-        });
-        readline.on("error", (error) => {
-            finish(() => {
-                reject(error);
-            });
-        });
-    });
-}
-export async function promptGithubAppConfig(input = process.stdin, output = process.stdout, openBrowser = openUrlInBrowser) {
-    requireInteractiveTerminal(input, output, "setup-github-app requires an interactive terminal.");
-    writeGithubAppCreationGuide(output);
-    const shouldOpenBrowser = unwrapPromptResult(await clack.confirm({
-        message: `Open ${GITHUB_NEW_APP_URL} in your browser now?`,
-        active: "Yes",
-        inactive: "No",
-        initialValue: true,
-        input,
-        output,
-    }), "GitHub App setup cancelled.", output);
-    if (shouldOpenBrowser) {
-        try {
-            await openBrowser(GITHUB_NEW_APP_URL);
-            output.write(`Opened ${GITHUB_NEW_APP_URL} in your browser.\n\n`);
-        }
-        catch {
-            output.write([
-                "Could not open a browser automatically.",
-                `Open this URL manually: ${GITHUB_NEW_APP_URL}`,
-                "",
-            ].join("\n"));
-        }
-    }
-    const appUrl = await promptTextValue("GitHub App URL", input, output, (value) => {
-        try {
-            new URL(String(value || "").trim());
-            return undefined;
-        }
-        catch {
-            return "Enter a valid GitHub App URL.";
-        }
-    });
-    const appClientId = await promptTextValue("GitHub App Client ID (not the App ID)", input, output, (value) => (String(value || "").trim() ? undefined : "Client ID is required."));
-    const appPrivateKeyPem = await readPemFromTerminal(input, output);
-    return normalizeGithubAppConfig({
-        appUrl,
-        appClientId,
-        appPrivateKeyPem,
-    });
-}
-export async function ensureGithubAppConfig(store = new GithubAppConfigStore(), input = process.stdin, output = process.stdout, options = {}) {
-    const existingConfig = store.load();
-    if (existingConfig) {
-        return existingConfig;
-    }
-    if (!hasInteractiveTerminal(input, output)) {
-        return null;
-    }
-    const workspaceMode = options.workspaceMode ?? "dedicated";
-    clack.intro("CompanyHelm GitHub auth", { output });
-    clack.note(workspaceMode === "dedicated"
-        ? [
-            "No machine GitHub App config was found.",
-            "Dedicated workspaces cannot access files from your host system.",
-            "GitHub auth is recommended so agents can clone and work in your repositories.",
-        ].join("\n")
-        : [
-            "No machine GitHub App config was found.",
-            "GitHub auth is optional in current working directory mode.",
-            "Set it up now if you want agents to access GitHub directly from this deployment.",
-        ].join("\n"), "Optional setup", { output });
-    const shouldSetup = unwrapPromptResult(await clack.confirm({
-        message: "Set up GitHub auth now?",
-        active: "Set it up",
-        inactive: "Skip for now",
-        initialValue: false,
-        input,
-        output,
-    }), "GitHub App setup cancelled.", output);
-    if (!shouldSetup) {
-        clack.outro("Skipping GitHub App setup. Continuing startup without GitHub access.", { output });
-        return null;
-    }
-    const config = await promptGithubAppConfig(input, output);
-    const spinner = clack.spinner({ output });
-    spinner.start("Saving machine GitHub App config");
-    const configPath = store.save(config);
-    spinner.stop(`Saved GitHub App config to ${configPath}`);
-    clack.outro("GitHub App setup complete. Continuing startup.", { output });
-    return config;
-}
-export function registerSetupGithubAppCommand(program, store = new GithubAppConfigStore()) {
-    program
-        .command("setup-github-app")
-        .description("Save machine-wide GitHub App config for local deploys.")
-        .action(async () => {
-        clack.intro("CompanyHelm GitHub App setup");
-        const config = await promptGithubAppConfig();
-        const spinner = clack.spinner();
-        spinner.start("Saving machine GitHub App config");
-        const configPath = store.save(config);
-        spinner.stop(`Saved GitHub App config to ${configPath}`);
-        clack.outro(`Saved GitHub App config to ${configPath}.`);
-    });
-}

package/dist/commands/startup-preferences.d.ts

@@ -1,3 +0,0 @@
-import type { Readable, Writable } from "node:stream";
-import { LocalConfigStore, type AgentWorkspaceMode } from "../core/runtime/LocalConfigStore.js";
-export declare function ensureAgentWorkspaceMode(store?: LocalConfigStore, input?: Readable, output?: Writable): Promise<AgentWorkspaceMode>;

package/dist/commands/startup-preferences.js

@@ -1,39 +0,0 @@
-import * as clack from "@clack/prompts";
-import { unwrapPromptResult, hasInteractiveTerminal } from "./interactive.js";
-import { LocalConfigStore } from "../core/runtime/LocalConfigStore.js";
-const DEFAULT_WORKSPACE_MODE = "current-working-directory";
-export async function ensureAgentWorkspaceMode(store = new LocalConfigStore(), input = process.stdin, output = process.stdout) {
-    const existingMode = store.load().agentWorkspaceMode;
-    if (existingMode) {
-        return existingMode;
-    }
-    if (!hasInteractiveTerminal(input, output)) {
-        return DEFAULT_WORKSPACE_MODE;
-    }
-    clack.note([
-        "Choose where agent threads should run.",
-        "Dedicated workspaces keep agents isolated from your host filesystem.",
-        "In dedicated mode agents will not have access to files on your system, so GitHub auth is recommended if you want them to clone your repositories.",
-        "Current working directory mode mounts this checkout directly into agent threads.",
-    ].join("\n"), "Agent workspace", { output });
-    const selectedMode = unwrapPromptResult(await clack.select({
-        message: "Where should agents operate?",
-        options: [
-            {
-                value: "current-working-directory",
-                label: "Current working directory",
-                hint: "recommended: agents work directly in this checkout"
-            },
-            {
-                value: "dedicated",
-                label: "Dedicated workspaces directory",
-                hint: "isolated thread workspaces"
-            }
-        ],
-        initialValue: DEFAULT_WORKSPACE_MODE,
-        input,
-        output
-    }), "Workspace selection cancelled.", output);
-    store.setAgentWorkspaceMode(selectedMode);
-    return selectedMode;
-}

package/dist/commands/status.d.ts

@@ -1,3 +0,0 @@
-import type { Command } from "commander";
-import type { CommandDependencies } from "./dependencies.js";
-export declare function registerStatusCommand(program: Command, dependencies: CommandDependencies): void;

package/dist/commands/status.js

@@ -1,7 +0,0 @@
-import { TerminalRenderer } from "../core/ui/TerminalRenderer.js";
-export function registerStatusCommand(program, dependencies) {
-    program.command("status").description("Show deployment status.").action(async () => {
-        const renderer = new TerminalRenderer(process.stdout.isTTY);
-        process.stdout.write(`${renderer.renderStatus(await dependencies.status())}\n`);
-    });
-}

package/dist/commands/up.d.ts

@@ -1,3 +0,0 @@
-import type { Command } from "commander";
-import type { CommandDependencies } from "./dependencies.js";
-export declare function registerUpCommand(program: Command, dependencies: CommandDependencies): void;

package/dist/commands/up.js

@@ -1,39 +0,0 @@
-const LOG_LEVELS = new Set(["debug", "info", "warn", "error"]);
-export function registerUpCommand(program, dependencies) {
-    program
-        .command("up")
-        .description("Start or reconcile the local deployment.")
-        .option("--log-level <level>", "Set log level for api, companyhelm-web, and runner.", "info")
-        .option("--use-host-docker-runtime", "Run thread containers against the host Docker runtime instead of DinD sidecars.")
-        .option("--api-repo-path [path]", "Start the API from a local repo path. Defaults to ../companyhelm-api when provided without a value.")
-        .option("--web-repo-path [path]", "Start companyhelm-web from a local repo path. Defaults to ../companyhelm-web when provided without a value.")
-        .action(async (options) => {
-        const logLevel = String(options.logLevel || "").trim().toLowerCase();
-        if (!LOG_LEVELS.has(logLevel)) {
-            throw new Error(`Unsupported log level "${options.logLevel}". Expected one of: debug, info, warn, error.`);
-        }
-        const upOptions = {
-            logLevel: logLevel,
-            useHostDockerRuntime: Boolean(options.useHostDockerRuntime)
-        };
-        const apiRepoPath = normalizeLocalRepoOption(options.apiRepoPath);
-        const webRepoPath = normalizeLocalRepoOption(options.webRepoPath);
-        if (apiRepoPath !== undefined) {
-            upOptions.apiRepoPath = apiRepoPath;
-        }
-        if (webRepoPath !== undefined) {
-            upOptions.webRepoPath = webRepoPath;
-        }
-        await dependencies.up(upOptions);
-    });
-}
-function normalizeLocalRepoOption(option) {
-    if (option === true) {
-        return true;
-    }
-    if (typeof option === "string") {
-        const trimmed = option.trim();
-        return trimmed.length > 0 ? trimmed : true;
-    }
-    return undefined;
-}

package/dist/core/bootstrap/DeploymentBootstrapper.d.ts

@@ -1,15 +0,0 @@
-import type { LogLevel } from "../../commands/dependencies.js";
-import type { GithubAppConfig } from "../config/GithubAppConfig.js";
-import type { RuntimeState } from "../runtime/RuntimeState.js";
-export declare class DeploymentBootstrapper {
-    private readonly renderer;
-    writeSeedSql(root: string, state: RuntimeState, passwordHash: string, passwordSalt: string): string;
-    writeApiConfig(root: string, state: RuntimeState, logLevel?: LogLevel, options?: {
-        databaseHost?: string;
-        appPort?: number;
-        runnerGrpcPort?: number;
-        githubAppConfig?: GithubAppConfig | null;
-    }): string;
-    writeFrontendConfig(root: string, state: RuntimeState): string;
-    private indentBlock;
-}

package/dist/core/bootstrap/DeploymentBootstrapper.js

@@ -1,118 +0,0 @@
-import fs from "node:fs";
-import { RuntimePaths } from "../runtime/RuntimePaths.js";
-import { SeedSqlRenderer } from "./SeedSqlRenderer.js";
-export class DeploymentBootstrapper {
-    renderer = new SeedSqlRenderer();
-    writeSeedSql(root, state, passwordHash, passwordSalt) {
-        const runtimePaths = new RuntimePaths(root);
-        const outputPath = runtimePaths.seedFilePath();
-        const sql = this.renderer.render({
-            companyId: state.company.id,
-            companyName: state.company.name,
-            username: state.auth.username,
-            passwordHash,
-            passwordSalt,
-            runnerName: state.runner.name,
-            runnerSecret: state.runner.secret
-        });
-        fs.writeFileSync(outputPath, sql, "utf8");
-        return outputPath;
-    }
-    writeApiConfig(root, state, logLevel = "info", options = {}) {
-        const runtimePaths = new RuntimePaths(root);
-        const outputPath = runtimePaths.apiConfigPath();
-        const appPort = options.appPort ?? state.ports.apiHttp;
-        const runnerGrpcPort = options.runnerGrpcPort ?? state.ports.runnerGrpc;
-        const databaseHost = options.databaseHost ?? "postgres";
-        const githubConfigLines = options.githubAppConfig
-            ? [
-                '  app_client_id: "${GITHUB_APP_CLIENT_ID}"',
-                '  app_private_key_pem: "${GITHUB_APP_PRIVATE_KEY_PEM}"',
-                '  app_link: "${GITHUB_APP_URL}"'
-            ]
-            : [
-                '  app_client_id: "companyhelm-local-github-disabled"',
-                '  app_private_key_pem: "companyhelm-local-github-disabled"',
-                '  app_link: "https://github.com/apps/companyhelm-local-disabled"'
-            ];
-        const yaml = [
-            "app:",
-            '  host: "0.0.0.0"',
-            `  port: ${appPort}`,
-            '  graphqlEndpoint: "/graphql"',
-            "  graphiql: true",
-            "  grpc:",
-            '    host: "0.0.0.0"',
-            `    port: ${runnerGrpcPort}`,
-            "    heartbeat:",
-            "      intervalMs: 20000",
-            "      jitterMs: 10000",
-            "  workers:",
-            "    agentHeartbeats:",
-            "      intervalSeconds: 60",
-            "      jitterSeconds: 60",
-            "      batchSize: 10",
-            "      leaseSeconds: 120",
-            "    taskWorker:",
-            "      intervalSeconds: 60",
-            "      jitterSeconds: 60",
-            "      batchSize: 10",
-            "      leaseSeconds: 120",
-            "database:",
-            '  name: "companyhelm"',
-            `  host: "${databaseHost}"`,
-            "  port: 5432",
-            "  roles:",
-            "    app_runtime:",
-            '      username: "app-runtime"',
-            '      password: "companyhelm-local-app-runtime-role-password"',
-            "    admin:",
-            '      username: "postgres"',
-            '      password: "postgres"',
-            "github:",
-            ...githubConfigLines,
-            'authProvider: "companyhelm"',
-            "auth:",
-            "  companyhelm:",
-            "    jwt_private_key_pem: |-",
-            this.indentBlock(state.auth.jwtPrivateKeyPem, 6),
-            "    jwt_public_key_pem: |-",
-            this.indentBlock(state.auth.jwtPublicKeyPem, 6),
-            '    jwt_issuer: "companyhelm.local"',
-            '    jwt_audience: "companyhelm-web"',
-            "    jwt_expiration_seconds: 86400",
-            "security:",
-            "  encryption:",
-            '    key: "companyhelm-local-encryption-key"',
-            `log_level: "${logLevel}"`,
-            "log_pretty: false",
-            ""
-        ].join("\n");
-        fs.writeFileSync(outputPath, yaml, "utf8");
-        return outputPath;
-    }
-    writeFrontendConfig(root, state) {
-        const runtimePaths = new RuntimePaths(root);
-        const outputPath = runtimePaths.frontendConfigPath();
-        const yaml = [
-            "api:",
-            `  graphqlApiUrl: "http://127.0.0.1:${state.ports.apiHttp}/graphql"`,
-            `  runnerGrpcTarget: "localhost:${state.ports.runnerGrpc}"`,
-            "auth:",
-            '  provider: "companyhelm"',
-            "  companyhelm:",
-            '    tokenStorageKey: "companyhelm.auth.token"',
-            ""
-        ].join("\n");
-        fs.writeFileSync(outputPath, yaml, "utf8");
-        return outputPath;
-    }
-    indentBlock(value, spaces) {
-        const prefix = " ".repeat(spaces);
-        return value
-            .trimEnd()
-            .split("\n")
-            .map((line) => `${prefix}${line}`)
-            .join("\n");
-    }
-}

package/dist/core/bootstrap/SeedSqlRenderer.d.ts

@@ -1,12 +0,0 @@
-export interface SeedSqlInput {
-    companyId: string;
-    companyName: string;
-    username: string;
-    passwordHash: string;
-    passwordSalt?: string;
-    runnerName: string;
-    runnerSecret: string;
-}
-export declare class SeedSqlRenderer {
-    render(input: SeedSqlInput): string;
-}

package/dist/core/bootstrap/SeedSqlRenderer.js

@@ -1,44 +0,0 @@
-import { createHash } from "node:crypto";
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-export class SeedSqlRenderer {
-    render(input) {
-        const templatePath = path.resolve(__dirname, "../../templates/seed.sql.tpl");
-        const template = fs.readFileSync(templatePath, "utf8");
-        const email = input.username.trim();
-        const firstName = email.split("@")[0] || email;
-        const runnerSecretHash = createHash("sha256").update(input.runnerSecret).digest("hex");
-        const userId = deriveUuid(input.companyId, "user");
-        const userAuthId = deriveUuid(input.companyId, "user-auth");
-        const runnerId = deriveUuid(input.companyId, "runner");
-        return template
-            .replaceAll("{{COMPANY_ID}}", input.companyId)
-            .replaceAll("{{COMPANY_NAME}}", input.companyName)
-            .replaceAll("{{USER_ID}}", userId)
-            .replaceAll("{{USER_AUTH_ID}}", userAuthId)
-            .replaceAll("{{USER_FIRST_NAME}}", firstName)
-            .replaceAll("{{USER_EMAIL}}", email)
-            .replaceAll("{{PASSWORD_SALT}}", input.passwordSalt ?? "password-salt")
-            .replaceAll("{{PASSWORD_HASH}}", input.passwordHash)
-            .replaceAll("{{RUNNER_ID}}", runnerId)
-            .replaceAll("{{RUNNER_NAME}}", input.runnerName)
-            .replaceAll("{{RUNNER_SECRET_HASH}}", runnerSecretHash);
-    }
-}
-function deriveUuid(companyId, scope) {
-    const hex = createHash("sha256").update(`${companyId}:${scope}`).digest("hex");
-    const chars = hex.slice(0, 32).split("");
-    chars[12] = "4";
-    chars[16] = ((Number.parseInt(chars[16] ?? "0", 16) & 0x3) | 0x8).toString(16);
-    const normalized = chars.join("");
-    return [
-        normalized.slice(0, 8),
-        normalized.slice(8, 12),
-        normalized.slice(12, 16),
-        normalized.slice(16, 20),
-        normalized.slice(20, 32)
-    ].join("-");
-}

package/dist/core/config/ApiEnvFileWriter.d.ts

@@ -1,8 +0,0 @@
-import type { GithubAppConfig } from "./GithubAppConfig.js";
-export declare class ApiEnvFileWriter {
-    private readonly runtimePaths;
-    private readonly templatePath;
-    constructor(root: string);
-    write(config: GithubAppConfig | null): string;
-    private render;
-}

package/dist/core/config/ApiEnvFileWriter.js

@@ -1,33 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { RuntimePaths } from "../runtime/RuntimePaths.js";
-function escapeEnvValue(value) {
-    return String(value || "")
-        .replace(/\\/g, "\\\\")
-        .replace(/\r\n/g, "\n")
-        .replace(/\r/g, "\n")
-        .replace(/\n/g, "\\n");
-}
-export class ApiEnvFileWriter {
-    runtimePaths;
-    templatePath;
-    constructor(root) {
-        this.runtimePaths = new RuntimePaths(root);
-        this.templatePath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../templates/api.env.tpl");
-    }
-    write(config) {
-        fs.mkdirSync(this.runtimePaths.apiDirectoryPath(), { recursive: true });
-        const contents = this.render(config);
-        fs.writeFileSync(this.runtimePaths.apiEnvPath(), contents, "utf8");
-        return this.runtimePaths.apiEnvPath();
-    }
-    render(config) {
-        const template = fs.readFileSync(this.templatePath, "utf8");
-        const rendered = template
-            .replace("{{GITHUB_APP_URL}}", escapeEnvValue(config?.appUrl ?? ""))
-            .replace("{{GITHUB_APP_CLIENT_ID}}", escapeEnvValue(config?.appClientId ?? ""))
-            .replace("{{GITHUB_APP_PRIVATE_KEY_PEM}}", escapeEnvValue(config?.appPrivateKeyPem ?? ""));
-        return rendered.endsWith("\n") ? rendered : `${rendered}\n`;
-    }
-}

package/dist/core/config/GithubAppConfig.d.ts

@@ -1,6 +0,0 @@
-export interface GithubAppConfig {
-    appUrl: string;
-    appClientId: string;
-    appPrivateKeyPem: string;
-}
-export declare function normalizeGithubAppConfig(config: GithubAppConfig): GithubAppConfig;

package/dist/core/config/GithubAppConfig.js

@@ -1,26 +0,0 @@
-function normalizeRequiredValue(value, fieldName) {
-    const normalized = String(value || "").trim();
-    if (!normalized) {
-        throw new Error(`GitHub App config field "${fieldName}" is required.`);
-    }
-    return normalized;
-}
-export function normalizeGithubAppConfig(config) {
-    const appUrl = normalizeRequiredValue(config.appUrl, "appUrl");
-    try {
-        new URL(appUrl);
-    }
-    catch {
-        throw new Error(`GitHub App config field "appUrl" must be a valid URL.`);
-    }
-    const appClientId = normalizeRequiredValue(config.appClientId, "appClientId");
-    const rawPem = String(config.appPrivateKeyPem || "").replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
-    if (!rawPem) {
-        throw new Error('GitHub App config field "appPrivateKeyPem" is required.');
-    }
-    return {
-        appUrl,
-        appClientId,
-        appPrivateKeyPem: `${rawPem}\n`,
-    };
-}

package/dist/core/config/GithubAppConfigStore.d.ts

@@ -1,11 +0,0 @@
-import { type GithubAppConfig } from "./GithubAppConfig.js";
-export declare class GithubAppConfigStore {
-    private readonly configRoot;
-    constructor(configRoot?: string);
-    configPath(): string;
-    hasConfig(): boolean;
-    save(config: GithubAppConfig): string;
-    load(): GithubAppConfig | null;
-    loadOrThrow(): GithubAppConfig;
-    delete(): void;
-}