@loucompanion/forge-bridge 0.1.1-dev.03b8ba168599

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,34 @@
+import type { BridgeProviderStatus, BridgeRepoMapping, BridgeServiceConfig } from "../bridge/bridge.types.js";
+export interface BridgeLocalConfig {
+    readonly schemaVersion: 1 | 2;
+    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;
+    readonly supportsManagedWorktrees?: boolean;
+    readonly supportsManagedForgeArtifacts?: boolean;
+    readonly supportsRunnerAuthoredPhaseArtifacts?: 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,181 @@
+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: normalizeProviderStatuses(local.providerStatuses) ?? providerStatusesFor(cliProviders),
+        projectLabels: local.projectLabels ?? config.projectLabels,
+        repoMappings: local.repoMappings ?? config.repoMappings,
+        sandboxProfiles: local.sandboxProfiles ?? config.sandboxProfiles,
+        supportsApiSecretGrant: local.supportsApiSecretGrant ?? config.supportsApiSecretGrant,
+        supportsManagedWorktrees: local.supportsManagedWorktrees ?? config.supportsManagedWorktrees,
+        supportsManagedForgeArtifacts: local.supportsManagedForgeArtifacts ?? config.supportsManagedForgeArtifacts,
+        supportsRunnerAuthoredPhaseArtifacts: local.supportsRunnerAuthoredPhaseArtifacts ?? config.supportsRunnerAuthoredPhaseArtifacts
+    };
+}
+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: "", models: configuredModelsFor(provider) }]));
+}
+function parseLocalConfig(raw) {
+    if (!raw.trim()) {
+        return emptyConfig();
+    }
+    return normalizeLocalConfig(JSON.parse(raw));
+}
+function normalizeLocalConfig(config) {
+    return {
+        schemaVersion: 2,
+        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: normalizeProviderStatuses(config.providerStatuses),
+        projectLabels: cleanList(config.projectLabels),
+        repoMappings: normalizeRepoMappings(config.repoMappings),
+        sandboxProfiles: cleanList(config.sandboxProfiles),
+        supportsApiSecretGrant: config.supportsApiSecretGrant,
+        supportsManagedWorktrees: config.supportsManagedWorktrees,
+        supportsManagedForgeArtifacts: config.supportsManagedForgeArtifacts,
+        supportsRunnerAuthoredPhaseArtifacts: config.supportsRunnerAuthoredPhaseArtifacts
+    };
+}
+function emptyConfig() {
+    return {
+        schemaVersion: 2,
+        repoMappings: []
+    };
+}
+function normalizeProviderStatuses(values) {
+    if (!values)
+        return undefined;
+    const entries = [];
+    for (const [provider, status] of Object.entries(values)) {
+        const key = provider.trim();
+        if (!key)
+            continue;
+        entries.push([
+            key,
+            {
+                signedIn: status?.signedIn ?? true,
+                version: cleanString(status?.version),
+                models: cleanList(status?.models) ?? configuredModelsFor(key)
+            }
+        ]);
+    }
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function configuredModelsFor(provider) {
+    const envName = `FORGE_${provider.replace(/[^a-zA-Z0-9]/g, "_").toUpperCase()}_MODELS`;
+    return splitCsv(process.env[envName] ?? "");
+}
+function splitCsv(value) {
+    return value
+        .split(",")
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+}
+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";

package/dist/session/internals.d.ts

@@ -0,0 +1,7 @@
+export { parseRunOnceDispatchPacket, failureResult } from "./session.types.js";
+export type { SessionEventSink, SessionService } from "./session.base.js";
+export type { ApiKeySecretGrant, DispatchCycleRun, DispatchExecution, DispatchLease, DispatchSession, DispatchRepo, DispatchServerLocalConfig, DispatchWorkItem, RunOnceDispatchPacket, RunOnceResultPacket, RunnerDispatchArtifact, RunnerDispatchEvent, RunnerDispatchSpec, RunnerEventLine } from "./session.types.js";
+export { DeterministicProviderCliService, ProcessBackedProviderCliService, RoutingProviderCliService, buildProviderCliCommand } from "./provider-cli/provider-cli.service.js";
+export type { ProviderCliService } from "./provider-cli/provider-cli.base.js";
+export type { ProviderCliCommand, ProviderProcessRunner, ProviderProcessRunRequest, ProviderProcessRunResult } from "./provider-cli/provider-cli.service.js";
+export type { ProviderCliRunContext, ProviderCliRunResult } from "./provider-cli/provider-cli.types.js";

package/dist/session/internals.js

@@ -0,0 +1,2 @@
+export { parseRunOnceDispatchPacket, failureResult } from "./session.types.js";
+export { DeterministicProviderCliService, ProcessBackedProviderCliService, RoutingProviderCliService, buildProviderCliCommand } from "./provider-cli/provider-cli.service.js";

package/dist/session/provider-cli/index.d.ts

@@ -0,0 +1,3 @@
+export { DeterministicProviderCliService, ProcessBackedProviderCliService, RoutingProviderCliService, buildProviderCliCommand } from "./provider-cli.service.js";
+export type { ProviderCliService } from "./provider-cli.base.js";
+export type { ProviderCliCommand, ProviderProcessRunner, ProviderProcessRunRequest, ProviderProcessRunResult } from "./provider-cli.service.js";

package/dist/session/provider-cli/index.js

@@ -0,0 +1 @@
+export { DeterministicProviderCliService, ProcessBackedProviderCliService, RoutingProviderCliService, buildProviderCliCommand } from "./provider-cli.service.js";

package/dist/session/provider-cli/provider-cli.base.d.ts

@@ -0,0 +1,7 @@
+import type { ProviderCliRunContext, ProviderCliRunResult } from "./provider-cli.types.js";
+import type { RunOnceDispatchPacket, RunnerDispatchEvent } from "../session.types.js";
+export interface ProviderCliService {
+    runImplementation(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
+    runConflictResolve(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
+    runQa(dispatch: RunOnceDispatchPacket, emit: (event: RunnerDispatchEvent) => Promise<void>, signal?: AbortSignal): Promise<ProviderCliRunResult>;
+}

package/dist/session/provider-cli/provider-cli.base.js

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

package/dist/session/provider-cli/provider-cli.service.d.ts

@@ -0,0 +1,58 @@
+import { GitClient } from "../../shared/git/git.js";
+import type { ProviderCliService } from "./provider-cli.base.js";
+import type { ProviderCliRunContext, ProviderCliRunResult } from "./provider-cli.types.js";
+import type { RunOnceDispatchPacket, RunnerDispatchEvent } from "../session.types.js";
+export interface ProviderCliCommand {
+    readonly command: string;
+    readonly args: readonly string[];
+}
+export interface ProviderProcessRunRequest {
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly cwd: string;
+}
+export interface ProviderProcessRunResult {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export interface ProviderProcessRunner {
+    run(request: ProviderProcessRunRequest, handlers?: ProviderProcessHandlers, signal?: AbortSignal): Promise<ProviderProcessRunResult>;
+}
+export interface ProviderProcessHandlers {
+    onStdoutLine?(line: string): Promise<void> | void;
+    onStderrLine?(line: string): Promise<void> | void;
+}
+export declare class RoutingProviderCliService implements ProviderCliService {
+    private readonly realProvider;
+    private readonly deterministicProvider;
+    constructor(realProvider?: ProviderCliService, deterministicProvider?: ProviderCliService);
+    runImplementation(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
+    runConflictResolve(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
+    runQa(dispatch: RunOnceDispatchPacket, emit: (event: RunnerDispatchEvent) => Promise<void>, signal?: AbortSignal): Promise<ProviderCliRunResult>;
+}
+export declare class ProcessBackedProviderCliService implements ProviderCliService {
+    private readonly processRunner;
+    private readonly git;
+    constructor(processRunner?: ProviderProcessRunner, git?: GitClient);
+    runImplementation(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
+    runQa(dispatch: RunOnceDispatchPacket, emit: (event: RunnerDispatchEvent) => Promise<void>, signal?: AbortSignal): Promise<ProviderCliRunResult>;
+    runConflictResolve(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
+}
+export declare class DeterministicProviderCliService implements ProviderCliService {
+    private readonly git;
+    constructor(git?: GitClient);
+    runImplementation(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
+    runQa(dispatch: RunOnceDispatchPacket, emit: (event: RunnerDispatchEvent) => Promise<void>): Promise<ProviderCliRunResult>;
+    runConflictResolve(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
+}
+export declare class StreamingProviderProcessRunner implements ProviderProcessRunner {
+    run(request: ProviderProcessRunRequest, handlers?: ProviderProcessHandlers, signal?: AbortSignal): Promise<ProviderProcessRunResult>;
+}
+export declare function chooseWindowsCommandCandidate(candidates: readonly string[]): string | null;
+export declare function buildWindowsLaunchCommand(commandPath: string, args: readonly string[]): ProviderCliCommand;
+export declare function formatProviderCliCommand(command: ProviderCliCommand): string;
+export declare function buildProviderCliCommand(dispatch: RunOnceDispatchPacket, run?: {
+    readonly prompt?: string;
+    readonly worktreePath?: string;
+}): ProviderCliCommand;