@loucompanion/forge-bridge 0.1.1-dev.242bb53ef13f

package/dist/cli/cli.service.d.ts

@@ -0,0 +1,45 @@
+import type { BridgeService } from "../bridge/bridge.base.js";
+import type { BridgeServiceConfig } from "../bridge/bridge.types.js";
+import type { SessionService } from "../session/session.base.js";
+import type { CliIo, CliService } from "./cli.base.js";
+export declare class ForgeBridgeCliService implements CliService {
+    private readonly sessions;
+    private readonly bridgeFactory;
+    constructor(sessions?: SessionService, bridgeFactory?: (config: BridgeServiceConfig) => BridgeService);
+    run(argv: readonly string[], io?: CliIo): Promise<number>;
+}
+export declare function parseArgs(argv: readonly string[]): {
+    readonly ok: true;
+    readonly command: "run-once";
+    readonly dispatchPath: string;
+    readonly resultPath: string;
+} | {
+    readonly ok: true;
+    readonly command: "connect";
+    readonly config: BridgeServiceConfig;
+} | {
+    readonly ok: true;
+    readonly command: "add-repo";
+    readonly label: string;
+    readonly repoPath: string;
+} | {
+    readonly ok: true;
+    readonly command: "remove-repo";
+    readonly label: string;
+} | {
+    readonly ok: true;
+    readonly command: "status";
+    readonly config: BridgeServiceConfig;
+    readonly checkUpdates: boolean;
+} | {
+    readonly ok: true;
+    readonly command: "cleanup";
+    readonly config: BridgeServiceConfig;
+    readonly mode: CleanupMode;
+    readonly force: boolean;
+} | {
+    readonly ok: false;
+    readonly error: string;
+};
+type CleanupMode = "stale" | "merged" | "all";
+export {};

package/dist/cli/cli.service.js

@@ -0,0 +1,400 @@
+import fs from "node:fs/promises";
+import { execFile } from "node:child_process";
+import path from "node:path";
+import { promisify } from "node:util";
+import { redactSecrets, redactText } from "../shared/redaction/redaction.js";
+import { defaultBridgeServiceConfig, ForgeBridgeService } from "../bridge/bridge.service.js";
+import { addRepoMapping, applyLocalConfigDefaults, readLocalConfigSync, removeRepoMapping, resolveLocalConfigPath } from "./local-config.js";
+import { BridgeSessionService } from "../session/session.service.js";
+import { failureResult, parseRunOnceDispatchPacket } from "../session/session.types.js";
+const apiKeySecretGrantEnv = "FORGE_API_KEY_SECRET_GRANT";
+const execFileAsync = promisify(execFile);
+export class ForgeBridgeCliService {
+    sessions;
+    bridgeFactory;
+    constructor(sessions = new BridgeSessionService(), bridgeFactory = (config) => new ForgeBridgeService(config)) {
+        this.sessions = sessions;
+        this.bridgeFactory = bridgeFactory;
+    }
+    async run(argv, io = { stdout: process.stdout, stderr: process.stderr }) {
+        const args = parseArgs(argv);
+        if (!args.ok) {
+            io.stderr.write(`${args.error}\n`);
+            return 2;
+        }
+        if (args.command === "connect") {
+            const missing = [
+                ["server", args.config.serverUrl],
+                ["runner id", args.config.runnerId],
+                ["device token", args.config.deviceToken]
+            ].find(([, value]) => !value);
+            if (missing) {
+                io.stderr.write(`forge-bridge connect requires ${missing[0]}.\n`);
+                return 2;
+            }
+            const controller = new AbortController();
+            const stop = () => controller.abort("signal received");
+            process.once("SIGINT", stop);
+            process.once("SIGTERM", stop);
+            try {
+                await this.bridgeFactory(args.config).run(controller.signal);
+                return 0;
+            }
+            finally {
+                process.off("SIGINT", stop);
+                process.off("SIGTERM", stop);
+            }
+        }
+        if (args.command === "add-repo") {
+            try {
+                const config = await addRepoMapping(args.label, args.repoPath);
+                const normalizedLabel = args.label.trim();
+                const mapping = config.repoMappings?.find((entry) => entry.label.toLowerCase() === normalizedLabel.toLowerCase());
+                io.stdout.write(`Added repo ${mapping?.label ?? normalizedLabel}: ${mapping?.localPath ?? path.resolve(args.repoPath)}\n`);
+                return 0;
+            }
+            catch (error) {
+                io.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+                return 2;
+            }
+        }
+        if (args.command === "remove-repo") {
+            try {
+                const result = await removeRepoMapping(args.label);
+                io.stdout.write(result.removed ? `Removed repo ${args.label}.\n` : `Repo ${args.label} was not configured.\n`);
+                return result.removed ? 0 : 1;
+            }
+            catch (error) {
+                io.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+                return 2;
+            }
+        }
+        if (args.command === "status") {
+            await writeStatus(args.config, args.checkUpdates, io);
+            return 0;
+        }
+        if (args.command === "cleanup") {
+            return await cleanupRepos(args.config, args.mode, args.force, io);
+        }
+        let redactionSecrets = readEnvSecretValuesForRedaction();
+        try {
+            const dispatchJson = await fs.readFile(args.dispatchPath, "utf8");
+            const dispatch = attachEnvSecretGrant(parseRunOnceDispatchPacket(JSON.parse(dispatchJson)));
+            redactionSecrets = exactSecrets(dispatch);
+            const result = await this.sessions.runOnce(dispatch, {
+                emit: async (event) => {
+                    const line = {
+                        type: "runner_event",
+                        event: redactSecrets(event, redactionSecrets)
+                    };
+                    io.stdout.write(`${JSON.stringify(line)}\n`);
+                }
+            });
+            await writeJsonAtomic(args.resultPath, redactSecrets(result, redactionSecrets));
+            return result.exitCode;
+        }
+        catch (error) {
+            const summary = redactText(error instanceof Error ? error.message : String(error), redactionSecrets);
+            await writeJsonAtomic(args.resultPath, failureResult(summary)).catch(() => undefined);
+            io.stderr.write(`${summary}\n`);
+            return 1;
+        }
+        finally {
+            delete process.env[apiKeySecretGrantEnv];
+        }
+    }
+}
+function attachEnvSecretGrant(dispatch) {
+    if (!dispatch.execution.requiresApiKeySecretGrant) {
+        delete process.env[apiKeySecretGrantEnv];
+        return dispatch;
+    }
+    const raw = process.env[apiKeySecretGrantEnv];
+    delete process.env[apiKeySecretGrantEnv];
+    if (!raw) {
+        return dispatch;
+    }
+    const grant = parseEnvSecretGrant(raw);
+    return {
+        ...dispatch,
+        apiKeySecretGrant: grant
+    };
+}
+function parseEnvSecretGrant(raw) {
+    const value = JSON.parse(raw);
+    if (!value || typeof value !== "object") {
+        throw new Error("API-key secret grant environment value must be an object.");
+    }
+    if (typeof value.grantId !== "string" ||
+        typeof value.provider !== "string" ||
+        typeof value.secret !== "string" ||
+        typeof value.expiresAt !== "string") {
+        throw new Error("API-key secret grant environment value is invalid.");
+    }
+    return {
+        grantId: value.grantId,
+        provider: value.provider,
+        secret: value.secret,
+        expiresAt: value.expiresAt
+    };
+}
+function exactSecrets(dispatch) {
+    return dispatch.apiKeySecretGrant?.secret ? [dispatch.apiKeySecretGrant.secret] : [];
+}
+function readEnvSecretValuesForRedaction() {
+    const raw = process.env[apiKeySecretGrantEnv];
+    if (!raw) {
+        return [];
+    }
+    try {
+        return [parseEnvSecretGrant(raw).secret];
+    }
+    catch {
+        return [];
+    }
+}
+export function parseArgs(argv) {
+    if (argv[0] === "connect") {
+        return parseConnectArgs(argv);
+    }
+    if (argv[0] === "add-repo") {
+        if (!argv[1] || !argv[2] || argv.length > 3) {
+            return { ok: false, error: "Usage: forge-bridge add-repo <label> <path>" };
+        }
+        return { ok: true, command: "add-repo", label: argv[1], repoPath: argv[2] };
+    }
+    if (argv[0] === "remove-repo") {
+        if (!argv[1] || argv.length > 2) {
+            return { ok: false, error: "Usage: forge-bridge remove-repo <label>" };
+        }
+        return { ok: true, command: "remove-repo", label: argv[1] };
+    }
+    if (argv[0] === "status") {
+        let checkUpdates = false;
+        for (let index = 1; index < argv.length; index += 1) {
+            const arg = argv[index];
+            if (arg === "--check-updates") {
+                checkUpdates = true;
+            }
+            else {
+                return { ok: false, error: `Unknown argument: ${arg}` };
+            }
+        }
+        return { ok: true, command: "status", config: configuredBridgeServiceConfig(), checkUpdates };
+    }
+    if (argv[0] === "cleanup") {
+        return parseCleanupArgs(argv);
+    }
+    if (argv[0] !== "run-once") {
+        return {
+            ok: false,
+            error: "Usage: forge-bridge run-once --dispatch <dispatch-json-path> --result <result-json-path> | forge-bridge connect --server <url> --runner-id <id> --device-token <token> | forge-bridge add-repo <label> <path> | forge-bridge remove-repo <label> | forge-bridge status [--check-updates] | forge-bridge cleanup [--stale|--merged|--all|--force]"
+        };
+    }
+    let dispatchPath = null;
+    let resultPath = null;
+    for (let index = 1; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === "--dispatch") {
+            dispatchPath = argv[++index] ?? null;
+        }
+        else if (arg === "--result") {
+            resultPath = argv[++index] ?? null;
+        }
+        else {
+            return { ok: false, error: `Unknown argument: ${arg}` };
+        }
+    }
+    if (!dispatchPath || !resultPath) {
+        return { ok: false, error: "run-once requires --dispatch and --result." };
+    }
+    return {
+        ok: true,
+        command: "run-once",
+        dispatchPath: path.resolve(dispatchPath),
+        resultPath: path.resolve(resultPath)
+    };
+}
+function parseConnectArgs(argv) {
+    let serverUrl = null;
+    let runnerId = null;
+    let deviceToken = null;
+    let repoRoot = null;
+    let heartbeatIntervalMs = null;
+    const cliProviders = [];
+    const projectLabels = [];
+    let cleanupWorktrees = true;
+    for (let index = 1; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === "--server") {
+            serverUrl = argv[++index] ?? null;
+        }
+        else if (arg === "--runner-id") {
+            runnerId = argv[++index] ?? null;
+        }
+        else if (arg === "--device-token") {
+            deviceToken = argv[++index] ?? null;
+        }
+        else if (arg === "--repo-root") {
+            repoRoot = argv[++index] ?? null;
+        }
+        else if (arg === "--cli-provider") {
+            cliProviders.push(...splitCsv(argv[++index] ?? ""));
+        }
+        else if (arg === "--project-label") {
+            projectLabels.push(...splitCsv(argv[++index] ?? ""));
+        }
+        else if (arg === "--heartbeat-interval-ms") {
+            heartbeatIntervalMs = Number(argv[++index] ?? "");
+            if (!Number.isFinite(heartbeatIntervalMs) || heartbeatIntervalMs <= 0) {
+                return { ok: false, error: "--heartbeat-interval-ms must be a positive number." };
+            }
+        }
+        else if (arg === "--no-cleanup-worktrees") {
+            cleanupWorktrees = false;
+        }
+        else {
+            return { ok: false, error: `Unknown argument: ${arg}` };
+        }
+    }
+    const localConfig = readLocalConfigSync();
+    if (serverUrl === null && !process.env.FORGE_URL?.trim() && !localConfig.serverUrl?.trim()) {
+        return { ok: false, error: "forge-bridge connect requires --server or FORGE_URL." };
+    }
+    const overrides = { cleanupWorktrees };
+    if (serverUrl !== null)
+        overrides.serverUrl = serverUrl;
+    if (runnerId !== null)
+        overrides.runnerId = runnerId;
+    if (deviceToken !== null)
+        overrides.deviceToken = deviceToken;
+    if (repoRoot !== null)
+        overrides.defaultRepoRoot = path.resolve(repoRoot);
+    if (cliProviders.length > 0)
+        overrides.cliProviders = cliProviders;
+    if (projectLabels.length > 0)
+        overrides.projectLabels = projectLabels;
+    if (heartbeatIntervalMs !== null)
+        overrides.heartbeatIntervalMs = heartbeatIntervalMs;
+    return {
+        ok: true,
+        command: "connect",
+        config: configuredBridgeServiceConfig(overrides, localConfig)
+    };
+}
+function parseCleanupArgs(argv) {
+    let mode = "stale";
+    let force = false;
+    for (let index = 1; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === "--stale") {
+            mode = "stale";
+        }
+        else if (arg === "--merged") {
+            mode = "merged";
+        }
+        else if (arg === "--all") {
+            mode = "all";
+        }
+        else if (arg === "--force") {
+            force = true;
+        }
+        else {
+            return { ok: false, error: `Unknown argument: ${arg}` };
+        }
+    }
+    return { ok: true, command: "cleanup", config: configuredBridgeServiceConfig(), mode, force };
+}
+function configuredBridgeServiceConfig(overrides = {}, localConfig = readLocalConfigSync()) {
+    return {
+        ...applyLocalConfigDefaults(defaultBridgeServiceConfig(), localConfig),
+        ...overrides
+    };
+}
+function splitCsv(value) {
+    return value
+        .split(",")
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+}
+async function writeJsonAtomic(outputPath, value) {
+    await fs.mkdir(path.dirname(outputPath), { recursive: true });
+    const tempPath = `${outputPath}.${process.pid}.${Date.now()}.tmp`;
+    await fs.writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+    await fs.rename(tempPath, outputPath);
+}
+async function writeStatus(config, checkUpdates, io) {
+    const detected = await detectCliProviders([...new Set([...config.cliProviders, "codex", "cursor"])]);
+    const repos = config.repoMappings.filter((mapping) => mapping.localPath?.trim());
+    io.stdout.write(`Forge bridge ${config.version}\n`);
+    io.stdout.write(`Config: ${resolveLocalConfigPath()}\n`);
+    io.stdout.write(`Server: ${config.serverUrl || "not configured"}\n`);
+    io.stdout.write(`Device: ${config.runnerId || "not configured"}${config.deviceName ? ` (${config.deviceName})` : ""}\n`);
+    io.stdout.write(`Device token: ${config.deviceToken ? "configured" : "missing"}\n`);
+    io.stdout.write(`Active sessions: 0\n`);
+    io.stdout.write("Repos:\n");
+    if (repos.length === 0) {
+        io.stdout.write("  none\n");
+    }
+    else {
+        for (const repo of repos) {
+            io.stdout.write(`  ${repo.name ?? repo.repoId ?? "repo"} -> ${repo.localPath}\n`);
+        }
+    }
+    io.stdout.write("Detected CLIs:\n");
+    for (const cli of detected) {
+        io.stdout.write(`  ${cli.provider}: ${cli.found ? cli.version || "found" : "not found"}\n`);
+    }
+    if (checkUpdates) {
+        io.stdout.write("Update check: no update channel configured.\n");
+    }
+}
+async function cleanupRepos(config, mode, force, io) {
+    const repos = config.repoMappings.filter((mapping) => mapping.localPath?.trim());
+    if (repos.length === 0) {
+        io.stdout.write("No repos configured.\n");
+        return 0;
+    }
+    let failures = 0;
+    for (const repo of repos) {
+        const repoPath = path.resolve(repo.localPath);
+        const worktreeRoot = path.join(path.dirname(repoPath), ".forge-worktrees", path.basename(repoPath));
+        if (!force) {
+            const action = mode === "all" ? "remove" : "prune";
+            io.stdout.write(`[dry-run] Would ${action} ${worktreeRoot}\n`);
+            continue;
+        }
+        try {
+            if (mode === "all") {
+                await fs.rm(worktreeRoot, { recursive: true, force: true });
+                await runGit(repoPath, ["worktree", "prune"]);
+                io.stdout.write(`Removed ${worktreeRoot}\n`);
+            }
+            else {
+                await runGit(repoPath, ["worktree", "prune"]);
+                io.stdout.write(`Pruned stale worktree metadata for ${repoPath}\n`);
+            }
+        }
+        catch (error) {
+            failures += 1;
+            io.stderr.write(`${repoPath}: ${error instanceof Error ? error.message : String(error)}\n`);
+        }
+    }
+    return failures === 0 ? 0 : 1;
+}
+async function detectCliProviders(providers) {
+    const results = [];
+    for (const provider of providers) {
+        try {
+            const result = await execFileAsync(provider, ["--version"], { timeout: 2000 });
+            results.push({ provider, found: true, version: `${result.stdout || result.stderr}`.trim().split(/\r?\n/, 1)[0] ?? "" });
+        }
+        catch {
+            results.push({ provider, found: false, version: "" });
+        }
+    }
+    return results;
+}
+async function runGit(cwd, args) {
+    await execFileAsync("git", args, { cwd, timeout: 10_000 });
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+export { ForgeBridgeCliService } from "./cli.service.js";
+export type { CliIo, CliService } from "./cli.base.js";

package/dist/cli/index.js

@@ -0,0 +1 @@
+export { ForgeBridgeCliService } from "./cli.service.js";

package/dist/cli/internals.d.ts

@@ -0,0 +1 @@
+export { parseArgs } from "./cli.service.js";

package/dist/cli/internals.js

@@ -0,0 +1 @@
+export { parseArgs } from "./cli.service.js";

package/dist/cli/local-config.d.ts

@@ -0,0 +1,31 @@
+import type { BridgeProviderStatus, BridgeRepoMapping, BridgeServiceConfig } from "../bridge/bridge.types.js";
+export interface BridgeLocalConfig {
+    readonly schemaVersion: 1;
+    readonly serverUrl?: string;
+    readonly runnerId?: string;
+    readonly deviceToken?: string;
+    readonly deviceName?: string;
+    readonly defaultRepoRoot?: string;
+    readonly cleanupWorktrees?: boolean;
+    readonly cliProviders?: readonly string[];
+    readonly providerStatuses?: Readonly<Record<string, BridgeProviderStatus>>;
+    readonly projectLabels?: readonly string[];
+    readonly repoMappings?: readonly LocalRepoMapping[];
+    readonly sandboxProfiles?: readonly string[];
+    readonly supportsApiSecretGrant?: boolean;
+}
+export interface LocalRepoMapping extends BridgeRepoMapping {
+    readonly label: string;
+    readonly localPath: string;
+}
+export declare function resolveLocalConfigPath(): string;
+export declare function readLocalConfig(): Promise<BridgeLocalConfig>;
+export declare function readLocalConfigSync(): BridgeLocalConfig;
+export declare function writeLocalConfig(config: BridgeLocalConfig): Promise<void>;
+export declare function applyLocalConfigDefaults(config: BridgeServiceConfig, local: BridgeLocalConfig): BridgeServiceConfig;
+export declare function addRepoMapping(label: string, repoPath: string): Promise<BridgeLocalConfig>;
+export declare function removeRepoMapping(label: string): Promise<{
+    readonly config: BridgeLocalConfig;
+    readonly removed: boolean;
+}>;
+export declare function providerStatusesFor(providers: readonly string[]): Readonly<Record<string, BridgeProviderStatus>>;

package/dist/cli/local-config.js

@@ -0,0 +1,146 @@
+import fs from "node:fs/promises";
+import fsSync from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export function resolveLocalConfigPath() {
+    if (process.env.FORGE_BRIDGE_CONFIG?.trim()) {
+        return path.resolve(process.env.FORGE_BRIDGE_CONFIG);
+    }
+    const base = process.env.XDG_CONFIG_HOME?.trim()
+        ? process.env.XDG_CONFIG_HOME
+        : process.platform === "win32" && process.env.APPDATA?.trim()
+            ? process.env.APPDATA
+            : path.join(os.homedir(), ".config");
+    return path.join(base, "forge", "bridge.json");
+}
+export async function readLocalConfig() {
+    return parseLocalConfig(await fs.readFile(resolveLocalConfigPath(), "utf8").catch((error) => {
+        if (error.code === "ENOENT") {
+            return "";
+        }
+        throw error;
+    }));
+}
+export function readLocalConfigSync() {
+    const configPath = resolveLocalConfigPath();
+    if (!fsSync.existsSync(configPath)) {
+        return emptyConfig();
+    }
+    return parseLocalConfig(fsSync.readFileSync(configPath, "utf8"));
+}
+export async function writeLocalConfig(config) {
+    const configPath = resolveLocalConfigPath();
+    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    const tempPath = `${configPath}.${process.pid}.${Date.now()}.tmp`;
+    await fs.writeFile(tempPath, `${JSON.stringify(normalizeLocalConfig(config), null, 2)}\n`, "utf8");
+    await fs.rename(tempPath, configPath);
+}
+export function applyLocalConfigDefaults(config, local) {
+    const cliProviders = local.cliProviders && local.cliProviders.length > 0 ? [...local.cliProviders] : config.cliProviders;
+    return {
+        ...config,
+        serverUrl: process.env.FORGE_URL ?? local.serverUrl ?? config.serverUrl,
+        runnerId: process.env.FORGE_RUNNER_ID ?? local.runnerId ?? config.runnerId,
+        deviceToken: process.env.FORGE_DEVICE_TOKEN ?? local.deviceToken ?? config.deviceToken,
+        deviceName: process.env.FORGE_DEVICE_NAME ?? local.deviceName ?? config.deviceName,
+        defaultRepoRoot: process.env.FORGE_REPO_ROOT ?? local.defaultRepoRoot ?? config.defaultRepoRoot,
+        cleanupWorktrees: local.cleanupWorktrees ?? config.cleanupWorktrees,
+        cliProviders,
+        providerStatuses: local.providerStatuses ?? providerStatusesFor(cliProviders),
+        projectLabels: local.projectLabels ?? config.projectLabels,
+        repoMappings: local.repoMappings ?? config.repoMappings,
+        sandboxProfiles: local.sandboxProfiles ?? config.sandboxProfiles,
+        supportsApiSecretGrant: local.supportsApiSecretGrant ?? config.supportsApiSecretGrant
+    };
+}
+export async function addRepoMapping(label, repoPath) {
+    const normalizedLabel = normalizeLabel(label);
+    const localPath = path.resolve(repoPath);
+    const stat = await fs.stat(localPath).catch(() => null);
+    if (!stat?.isDirectory()) {
+        throw new Error(`Repo path must be an existing directory: ${localPath}`);
+    }
+    const current = await readLocalConfig();
+    const mappings = [
+        ...((current.repoMappings ?? []).filter((mapping) => mapping.label.toLowerCase() !== normalizedLabel.toLowerCase())),
+        {
+            label: normalizedLabel,
+            name: normalizedLabel,
+            localPath
+        }
+    ].sort((left, right) => left.label.localeCompare(right.label));
+    const next = normalizeLocalConfig({ ...current, repoMappings: mappings });
+    await writeLocalConfig(next);
+    return next;
+}
+export async function removeRepoMapping(label) {
+    const normalizedLabel = normalizeLabel(label);
+    const current = await readLocalConfig();
+    const before = current.repoMappings ?? [];
+    const after = before.filter((mapping) => mapping.label.toLowerCase() !== normalizedLabel.toLowerCase());
+    const next = normalizeLocalConfig({ ...current, repoMappings: after });
+    await writeLocalConfig(next);
+    return { config: next, removed: after.length !== before.length };
+}
+export function providerStatusesFor(providers) {
+    return Object.fromEntries(providers.map((provider) => [provider, { signedIn: true, version: "" }]));
+}
+function parseLocalConfig(raw) {
+    if (!raw.trim()) {
+        return emptyConfig();
+    }
+    return normalizeLocalConfig(JSON.parse(raw));
+}
+function normalizeLocalConfig(config) {
+    return {
+        schemaVersion: 1,
+        serverUrl: cleanString(config.serverUrl),
+        runnerId: cleanString(config.runnerId),
+        deviceToken: cleanString(config.deviceToken),
+        deviceName: cleanString(config.deviceName),
+        defaultRepoRoot: cleanString(config.defaultRepoRoot),
+        cleanupWorktrees: config.cleanupWorktrees,
+        cliProviders: cleanList(config.cliProviders),
+        providerStatuses: config.providerStatuses,
+        projectLabels: cleanList(config.projectLabels),
+        repoMappings: normalizeRepoMappings(config.repoMappings),
+        sandboxProfiles: cleanList(config.sandboxProfiles),
+        supportsApiSecretGrant: config.supportsApiSecretGrant
+    };
+}
+function emptyConfig() {
+    return {
+        schemaVersion: 1,
+        repoMappings: []
+    };
+}
+function normalizeRepoMappings(values) {
+    return (values ?? [])
+        .filter((mapping) => !!mapping.label?.trim() && !!mapping.localPath?.trim())
+        .map((mapping) => {
+        const label = normalizeLabel(mapping.label);
+        return {
+            label,
+            repoId: cleanString(mapping.repoId),
+            name: cleanString(mapping.name) ?? label,
+            remoteUrl: cleanString(mapping.remoteUrl),
+            localPath: path.resolve(mapping.localPath)
+        };
+    })
+        .sort((left, right) => left.label.localeCompare(right.label));
+}
+function normalizeLabel(value) {
+    const label = value.trim();
+    if (!label) {
+        throw new Error("Repo label is required.");
+    }
+    return label;
+}
+function cleanString(value) {
+    const clean = value?.trim();
+    return clean ? clean : undefined;
+}
+function cleanList(values) {
+    const clean = [...new Set((values ?? []).map((value) => value.trim()).filter(Boolean))];
+    return clean.length > 0 ? clean : undefined;
+}

package/dist/config.d.ts

@@ -0,0 +1,5 @@
+export interface ForgeBridgeConfig {
+    readonly defaultRepoRoot: string;
+    readonly cleanupWorktrees: boolean;
+}
+export declare function defaultForgeBridgeConfig(): ForgeBridgeConfig;

package/dist/config.js

@@ -0,0 +1,8 @@
+import os from "node:os";
+import path from "node:path";
+export function defaultForgeBridgeConfig() {
+    return {
+        defaultRepoRoot: path.join(os.tmpdir(), "forge-phase5-repos"),
+        cleanupWorktrees: true
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./version.js";
+export * from "./config.js";
+export * from "./bridge/index.js";
+export * from "./cli/index.js";
+export * from "./session/index.js";
+export * from "./worktree/index.js";
+export * from "./cleanup/index.js";

package/dist/index.js

@@ -0,0 +1,7 @@
+export * from "./version.js";
+export * from "./config.js";
+export * from "./bridge/index.js";
+export * from "./cli/index.js";
+export * from "./session/index.js";
+export * from "./worktree/index.js";
+export * from "./cleanup/index.js";

package/dist/session/index.d.ts

@@ -0,0 +1,2 @@
+export { BridgeSessionService } from "./session.service.js";
+export type { SessionService } from "./session.base.js";

package/dist/session/index.js

@@ -0,0 +1 @@
+export { BridgeSessionService } from "./session.service.js";