@loucompanion/forge-bridge 0.1.3-dev.f66395c3ac21 → 0.1.4-dev.04a1e5b9e484

package/dist/session/provider-cli/provider-cli.qa-sidecars.d.ts

@@ -0,0 +1,11 @@
+import type { DispatchQaAppLaunchTarget } from "../session.types.js";
+interface QaSidecarFile {
+    readonly relativePath: string;
+    readonly content: string;
+}
+export declare function hasLaunchTarget(target: DispatchQaAppLaunchTarget | null): boolean;
+export declare function deterministicBrowserSidecar(workItemId: string, target: DispatchQaAppLaunchTarget, ownerType?: string | null, ownerId?: string | null): QaSidecarFile;
+export declare function deterministicBrowserCheck(target: DispatchQaAppLaunchTarget, screenshotPath: string): Record<string, unknown>;
+export declare function primaryLaunchRoute(target: DispatchQaAppLaunchTarget): string;
+export declare function writeQaSidecarFiles(worktreePath: string, files: readonly QaSidecarFile[]): Promise<Array<Record<string, unknown>>>;
+export {};

package/dist/session/provider-cli/provider-cli.qa-sidecars.js

@@ -0,0 +1,66 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+export function hasLaunchTarget(target) {
+    return Boolean(target?.url?.trim()
+        || target?.ready_url?.trim()
+        || target?.managed_runtime_port?.trim()
+        || target?.command?.trim()
+        || (target?.routes ?? []).some((route) => route.trim().length > 0));
+}
+export function deterministicBrowserSidecar(workItemId, target, ownerType, ownerId) {
+    const route = primaryLaunchRoute(target);
+    return {
+        relativePath: qaArtifactRelativePath(workItemId, "qa/screenshots/deterministic-browser-check.txt", ownerType, ownerId),
+        content: `Deterministic Forge QA browser evidence\nRoute: ${route}\nConsole errors: []\nNetwork errors: []\nResponsive checks: desktop, mobile\n`
+    };
+}
+export function deterministicBrowserCheck(target, screenshotPath) {
+    const route = primaryLaunchRoute(target);
+    return {
+        route,
+        url: route,
+        status: "pass",
+        summary: "Deterministic browser QA exercised the configured launch target.",
+        actions: ["open launch target", "walk acceptance criteria", "check console/network summaries", "check responsive viewport"],
+        screenshots: [screenshotPath],
+        console_errors: [],
+        network_errors: [],
+        responsive_checks: ["desktop", "mobile"]
+    };
+}
+export function primaryLaunchRoute(target) {
+    return target.ready_url?.trim()
+        || target.url?.trim()
+        || target.routes.find((route) => route.trim().length > 0)?.trim()
+        || target.command?.trim()
+        || "app launch command";
+}
+export async function writeQaSidecarFiles(worktreePath, files) {
+    const sidecars = [];
+    for (const file of files) {
+        const fullPath = path.resolve(worktreePath, file.relativePath);
+        const relativePath = path.relative(worktreePath, fullPath).split(path.sep).join("/");
+        if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+            throw new Error(`QA sidecar path must stay under the worktree: ${file.relativePath}`);
+        }
+        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+        await fs.writeFile(fullPath, file.content, "utf8");
+        sidecars.push({
+            path: relativePath,
+            content_hash: sha256(file.content),
+            bytes: Buffer.byteLength(file.content, "utf8")
+        });
+    }
+    return sidecars;
+}
+function qaArtifactRelativePath(workItemId, fileName, ownerType, ownerId) {
+    if (ownerType && ownerId) {
+        const ownerDirectory = ownerType.trim().toLowerCase() === "story" ? "stories" : "work-items";
+        return [".forge", ownerDirectory, ownerId, "artifacts", fileName].join("/");
+    }
+    return [".forge", "work-items", workItemId, "artifacts", fileName].join("/");
+}
+function sha256(content) {
+    return crypto.createHash("sha256").update(content).digest("hex");
+}

package/dist/session/provider-cli/provider-cli.repair-epoch.d.ts

@@ -0,0 +1,6 @@
+import type { GitClient } from "../../shared/git/git.js";
+import type { ProviderCliRunContext } from "./provider-cli.types.js";
+export declare function assertRepairHeadEpoch(context: ProviderCliRunContext, git: Pick<GitClient, "run">): Promise<{
+    expectedRepairHeadSha: string;
+    preparedHeadSha: string;
+}>;

package/dist/session/provider-cli/provider-cli.repair-epoch.js

@@ -0,0 +1,11 @@
+export async function assertRepairHeadEpoch(context, git) {
+    const expectedRepairHeadSha = context.dispatch.cycleRun.repairHeadSha?.trim();
+    if (!expectedRepairHeadSha) {
+        throw new Error("missing_repair_head_epoch: repair dispatch does not include repairHeadSha; refresh provider state before retrying.");
+    }
+    const preparedHeadSha = (await git.run(context.worktree.worktreePath, ["rev-parse", "HEAD"])).trim();
+    if (preparedHeadSha.toLowerCase() !== expectedRepairHeadSha.toLowerCase()) {
+        throw new Error(`stale_head: repair dispatch expected ${expectedRepairHeadSha} but prepared worktree is ${preparedHeadSha}; refresh provider state before retrying.`);
+    }
+    return { expectedRepairHeadSha, preparedHeadSha };
+}

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

@@ -0,0 +1,22 @@
+import type { RunOnceDispatchPacket } from "../session.types.js";
+import type { ProviderCliRunContext } from "./provider-cli.types.js";
+import type { ProviderOutputState } from "./provider-output-state.js";
+import { type ProviderUsage } from "./provider-usage.js";
+export declare function providerProcessEnv(dispatch: RunOnceDispatchPacket, runtimeEnvironment?: Readonly<Record<string, string>>): Readonly<Record<string, string>>;
+/**
+ * Pre-publication validation runs the attempt's own checks, whose E2E fixtures log in to the
+ * brokered attempt database. Unlike the provider's shell, it receives that capability; the
+ * validator redacts it from every command's output.
+ */
+export declare function prePublicationValidationEnv(dispatch: RunOnceDispatchPacket, runtimeEnvironment?: Readonly<Record<string, string>>): Readonly<Record<string, string>>;
+export declare function providerRuntimeEnvironment(runtimeEnvironment?: Readonly<Record<string, string>>): Readonly<Record<string, string>>;
+export declare function providerCredentialEnv(dispatch: RunOnceDispatchPacket): Readonly<Record<string, string>>;
+/**
+ * Non-secret CLI settings a provider needs to run headless under Forge. Claude Code's default MCP
+ * tool timeout is far shorter than Forge's managed verification commands, so match Codex's
+ * 7200s `tool_timeout_sec`, and keep the CLI from self-updating mid-attempt.
+ */
+export declare function providerCliDefaultsEnv(dispatch: RunOnceDispatchPacket): Readonly<Record<string, string>>;
+export declare function exactRedactionSecrets(dispatch: RunOnceDispatchPacket): readonly string[];
+export declare function emitProviderUsageEvent(emit: ProviderCliRunContext["emit"], dispatch: RunOnceDispatchPacket, outputState: ProviderOutputState): Promise<void>;
+export declare function estimatedDeterministicUsage(): ProviderUsage;

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

@@ -0,0 +1,92 @@
+import { attemptDatabaseCapabilityEnvironment } from "../../runtime/attempt-database-broker.js";
+import { completionRedactionEnv } from "../phase-completion.js";
+import { addUsage, buildProviderUsageEvent, emptyUsage, hasUsage } from "./provider-usage.js";
+export function providerProcessEnv(dispatch, runtimeEnvironment) {
+    const env = {
+        ...completionRedactionEnv(exactRedactionSecrets(dispatch)),
+        ...providerCliDefaultsEnv(dispatch),
+        ...providerCredentialEnv(dispatch),
+        ...providerRuntimeEnvironment(runtimeEnvironment),
+    };
+    // Always pass an explicit object. Alternate process runners must never receive
+    // `undefined`, which Node interprets as permission to inherit the entire
+    // Bridge environment, including credentials outside the provider contract.
+    return env;
+}
+/**
+ * Pre-publication validation runs the attempt's own checks, whose E2E fixtures log in to the
+ * brokered attempt database. Unlike the provider's shell, it receives that capability; the
+ * validator redacts it from every command's output.
+ */
+export function prePublicationValidationEnv(dispatch, runtimeEnvironment) {
+    const env = providerProcessEnv(dispatch, runtimeEnvironment);
+    const capability = runtimeEnvironment?.[attemptDatabaseCapabilityEnvironment]?.trim();
+    return capability ? { ...env, [attemptDatabaseCapabilityEnvironment]: capability } : env;
+}
+export function providerRuntimeEnvironment(runtimeEnvironment) {
+    if (!runtimeEnvironment)
+        return {};
+    return Object.fromEntries(Object.entries(runtimeEnvironment).filter(([name]) => {
+        const normalized = name.trim().toUpperCase();
+        return normalized !== "FORGE_TEST_POSTGRES_ADMIN_CONNECTION_STRING"
+            && normalized !== "FORGE_TEST_POSTGRES_CONNECTION_STRING"
+            // The attempt database login reaches the application runtime, pre-publication checks and
+            // managed commands (which redact it); the provider's own shell does not need it.
+            && normalized !== "FORGE_ATTEMPT_DATABASE_CAPABILITY"
+            && !normalized.startsWith("CONNECTIONSTRINGS__")
+            && !normalized.startsWith("CONNECTIONSTRINGS:")
+            && !normalized.endsWith("_CONNECTION_STRING");
+    }));
+}
+export function providerCredentialEnv(dispatch) {
+    const secret = dispatch.apiKeySecretGrant?.secret;
+    if (!secret || !dispatch.execution.requiresApiKeySecretGrant) {
+        return {};
+    }
+    const provider = dispatch.execution.provider.trim().toLowerCase();
+    if (provider === "codex" || provider === "openai") {
+        return { OPENAI_API_KEY: secret };
+    }
+    if (provider === "claude" || provider === "anthropic") {
+        return { ANTHROPIC_API_KEY: secret };
+    }
+    return {};
+}
+/**
+ * Non-secret CLI settings a provider needs to run headless under Forge. Claude Code's default MCP
+ * tool timeout is far shorter than Forge's managed verification commands, so match Codex's
+ * 7200s `tool_timeout_sec`, and keep the CLI from self-updating mid-attempt.
+ */
+export function providerCliDefaultsEnv(dispatch) {
+    const provider = dispatch.execution.provider.trim().toLowerCase();
+    if (provider === "claude") {
+        return {
+            MCP_TOOL_TIMEOUT: "7200000",
+            MCP_TIMEOUT: "60000",
+            DISABLE_AUTOUPDATER: "1"
+        };
+    }
+    return {};
+}
+export function exactRedactionSecrets(dispatch) {
+    const secret = dispatch.apiKeySecretGrant?.secret;
+    if (!secret || !dispatch.execution.requiresApiKeySecretGrant) {
+        return [];
+    }
+    return [secret];
+}
+export async function emitProviderUsageEvent(emit, dispatch, outputState) {
+    const usage = outputState.usage;
+    if (hasUsage(usage)) {
+        await emit(buildProviderUsageEvent(dispatch, usage));
+    }
+}
+export function estimatedDeterministicUsage() {
+    return addUsage(emptyUsage("estimated"), {
+        inputTokens: 1000,
+        uncachedInputTokens: 1000,
+        outputTokens: 400,
+        source: "estimated",
+        inputTokenSemantics: "includes_cached_input"
+    });
+}

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

@@ -1,42 +1,51 @@
 import { GitClient } from "../../shared/git/git.js";
-import { type CompletionToolRuntime } from "../phase-completion.js";
+import type { WorktreeLifecycleCoordinator } from "../../worktree/worktree.base.js";
+import { type RunnerDispatchEvent } from "../session.types.js";
 import type { ProviderCliService } from "./provider-cli.base.js";
 import type { ProviderCliDraftContext, ProviderCliRunContext, ProviderCliRunResult } from "./provider-cli.types.js";
-import type { RunOnceDispatchPacket } from "../session.types.js";
-export interface ProviderCliCommand {
-    readonly command: string;
-    readonly args: readonly string[];
+import { type ProviderProcessRunner, type ProviderProcessRunResult } from "./provider-cli.process.js";
+import { PrePublicationValidator } from "../pre-publication-validation.js";
+export { parseClaudeMcpToolName } from "./provider-output-state.js";
+export { DeterministicProviderCliService } from "./provider-cli.deterministic.js";
+export { buildProviderCliCommand, codexSandboxModeForPlatform, formatProviderCliCommand, formatProviderCliCommandForCheckpoint } from "./provider-cli.prompts.js";
+export { buildProviderChildEnvironment, chooseWindowsCommandCandidate, resolveCodexNpmDirectLaunch, resolveClaudeNpmDirectLaunch, resolvePackageManagerDirectLaunch, resolveWindowsCommandFromPath, PROVIDER_OUTPUT_CAPTURE_LIMIT_CHARS, CodexModelsCacheRecoveringProcessRunner, CodexResumeRecoveringProcessRunner, isTransientCodexProviderNotFoundFailure, StreamingProviderProcessRunner } from "./provider-cli.process.js";
+export { buildWindowsLaunchCommand } from "../../shared/process/windows-launch.js";
+export type { ProviderCliCommand, ProviderProcessRunner, ProviderProcessRunRequest, ProviderProcessRunResult } from "./provider-cli.process.js";
+/**
+ * Capacity is trusted only when a nonzero provider process writes one of the
+ * narrow service-level messages to stderr. Stdout can contain arbitrary agent
+ * command output and account usage-limit messages remain ordinary failures.
+ */
+export declare function isProviderCapacityFailure(result: ProviderProcessRunResult): boolean;
+/** Only a nonzero Codex service diagnostic can classify a configuration rejection.
+ * JSONL turn.failed is a provider envelope; item/tool output is not retry authority. */
+export declare function isProviderConfigurationFailure(command: string, result: ProviderProcessRunResult): boolean;
+/**
+ * A context limit is trusted only at the provider process boundary. The exact
+ * Codex message can be embedded in its JSONL stderr envelope, so substring
+ * matching is intentional but remains narrow and stderr-only.
+ */
+export declare function isProviderContextWindowExhausted(command: string, result: ProviderProcessRunResult): boolean;
+export declare class ManagedVerificationProgressEmitter {
+    private readonly logDirectory;
+    private readonly emit;
+    private readonly intervalMs;
+    private timer;
+    private readonly observedStatuses;
+    private readonly completedCommands;
+    constructor(logDirectory: string | undefined, emit: (event: RunnerDispatchEvent) => Promise<void>, intervalMs?: number);
+    start(): void;
+    stop(): Promise<void>;
+    private scan;
+    private emitTransition;
 }
-export interface ProviderProcessRunRequest {
-    readonly command: string;
-    readonly args: readonly string[];
-    readonly cwd: string;
-    readonly env?: Readonly<Record<string, 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;
-}
-interface ProviderChildEnvironmentOptions {
-    readonly parentEnv?: NodeJS.ProcessEnv;
-    readonly platform?: NodeJS.Platform;
-    readonly homeDir?: string;
-}
-export declare function buildProviderChildEnvironment(requestEnv?: Readonly<Record<string, string>>, options?: ProviderChildEnvironmentOptions): NodeJS.ProcessEnv;
 export declare class RoutingProviderCliService implements ProviderCliService {
     private readonly realProvider;
     private readonly deterministicProvider;
     constructor(realProvider?: ProviderCliService, deterministicProvider?: ProviderCliService);
     runImplementation(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
     runArchitect(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
+    runCiRepair(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
     runConflictResolve(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
     runQa(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
     runDraft(context: ProviderCliDraftContext): Promise<ProviderCliRunResult>;
@@ -44,33 +53,18 @@ export declare class RoutingProviderCliService implements ProviderCliService {
 export declare class ProcessBackedProviderCliService implements ProviderCliService {
     private readonly processRunner;
     private readonly git;
-    constructor(processRunner?: ProviderProcessRunner, git?: GitClient);
+    private readonly providerToolHeartbeatIntervalMs;
+    private readonly publicationCoordinator;
+    private readonly prePublicationValidator;
+    constructor(processRunner?: ProviderProcessRunner, git?: GitClient, providerToolHeartbeatIntervalMs?: number, publicationCoordinator?: WorktreeLifecycleCoordinator, prePublicationValidator?: PrePublicationValidator);
     runDraft(context: ProviderCliDraftContext): Promise<ProviderCliRunResult>;
     runImplementation(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
     runArchitect(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
     runQa(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
+    runCiRepair(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
     runConflictResolve(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
+    private runPullRequestRepair;
+    private recoverMissingQaCompletion;
+    private recoverMissingCommentRepairCompletion;
+    private validatePrePublicationWithRecovery;
 }
-export declare class DeterministicProviderCliService implements ProviderCliService {
-    private readonly git;
-    constructor(git?: GitClient);
-    runDraft(context: ProviderCliDraftContext): Promise<ProviderCliRunResult>;
-    runImplementation(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
-    runArchitect(context: ProviderCliRunContext): Promise<ProviderCliRunResult>;
-    runQa(context: ProviderCliRunContext): 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;
-    readonly completionTools?: CompletionToolRuntime;
-    readonly skipGitRepoCheck?: boolean;
-}): ProviderCliCommand;
-export declare function codexSandboxModeForPlatform(platform?: NodeJS.Platform): "workspace-write" | "danger-full-access";
-export {};