@loucompanion/forge-bridge 0.1.1-dev.e52b249f07a8 → 0.1.1-dev.f599637d804e

package/dist/bridge/bridge.service.d.ts

@@ -15,6 +15,7 @@ export declare class ForgeBridgeService implements BridgeService {
     run(signal?: AbortSignal): Promise<void>;
     stop(): Promise<void>;
     private handleDispatch;
+    private parseDispatchOrReport;
     private handleCancel;
     private abortActiveSessions;
     private normalizeDispatch;

package/dist/bridge/bridge.service.js

@@ -51,7 +51,7 @@ export class ForgeBridgeService {
                     attempt = 0;
                     await this.waitForClose(signal);
                 }
-                catch (error) {
+                catch {
                     if (this.stopped || signal?.aborted) {
                         break;
                     }
@@ -73,10 +73,14 @@ export class ForgeBridgeService {
         this.abortActiveSessions("bridge stopping");
         await this.stopConnection();
     }
-    async handleDispatch(dispatch) {
+    async handleDispatch(rawDispatch) {
+        const dispatch = this.parseDispatchOrReport(rawDispatch);
+        if (!dispatch) {
+            return;
+        }
         const leaseId = dispatch.lease.id;
         const fencingToken = dispatch.lease.fencingToken;
-        const redactionSecrets = exactSecrets(dispatch);
+        const redactionSecrets = exactSecrets(dispatch, this.config);
         if (this.activeSessions.has(leaseId)) {
             await this.sendResult(leaseId, fencingToken, failureResult("Dispatch is already active on this bridge.")).catch(() => undefined);
             return;
@@ -87,11 +91,20 @@ export class ForgeBridgeService {
             const normalized = this.normalizeDispatch(dispatch);
             const result = await this.sessions.runOnce(normalized, {
                 emit: async (event) => {
-                    await this.invokeAck("DispatchEvent", {
-                        leaseId,
-                        fencingToken,
-                        event: redactSecrets(event, redactionSecrets)
-                    });
+                    try {
+                        await this.invokeAck("DispatchEvent", {
+                            leaseId,
+                            fencingToken,
+                            event: redactSecrets(event, redactionSecrets)
+                        });
+                    }
+                    catch (error) {
+                        if (isDispatchNoLongerPending(error)) {
+                            controller.abort(error instanceof Error ? error.message : "Dispatch is no longer pending.");
+                            return;
+                        }
+                        throw error;
+                    }
                 }
             }, controller.signal);
             await this.sendResult(leaseId, fencingToken, redactSecrets(result, redactionSecrets));
@@ -106,6 +119,27 @@ export class ForgeBridgeService {
             this.activeSessions.delete(leaseId);
         }
     }
+    parseDispatchOrReport(rawDispatch) {
+        try {
+            return parseRunOnceDispatchPacket(rawDispatch);
+        }
+        catch (error) {
+            const identifiers = readDispatchIdentifiers(rawDispatch);
+            if (!identifiers) {
+                return null;
+            }
+            const summary = invalidDispatchSummary(error);
+            void this.sendResult(identifiers.leaseId, identifiers.fencingToken, failureResult(summary, [
+                {
+                    role: "runner",
+                    kind: "error",
+                    content: summary,
+                    eventType: "invalid_dispatch"
+                }
+            ])).catch(() => undefined);
+            return null;
+        }
+    }
     async handleCancel(request) {
         const active = this.activeSessions.get(request.leaseId);
         if (!active || active.fencingToken !== request.fencingToken) {
@@ -149,7 +183,15 @@ export class ForgeBridgeService {
             fencingToken,
             result
         };
-        await this.invokeAck("DispatchResult", payload);
+        try {
+            await this.invokeAck("DispatchResult", payload);
+        }
+        catch (error) {
+            if (isDispatchNoLongerPending(error)) {
+                return;
+            }
+            throw error;
+        }
     }
     startHeartbeat() {
         this.stopHeartbeat();
@@ -196,7 +238,7 @@ export class ForgeBridgeService {
         }
         const ack = await connection.invoke(methodName, payload);
         if (!ack.accepted) {
-            throw new Error(ack.message ?? ack.code ?? `${methodName} callback was rejected.`);
+            throw new BridgeCallbackRejectedError(ack.code ?? null, ack.message ?? ack.code ?? `${methodName} callback was rejected.`);
         }
         return ack;
     }
@@ -214,6 +256,20 @@ export class ForgeBridgeService {
         }
     }
 }
+class BridgeCallbackRejectedError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "BridgeCallbackRejectedError";
+    }
+}
+function isDispatchNoLongerPending(error) {
+    if (error instanceof BridgeCallbackRejectedError) {
+        return error.code === "bridge.dispatch_not_pending" || error.code === "bridge.stale_dispatch";
+    }
+    return error instanceof Error && error.message === "Dispatch is no longer pending.";
+}
 export class SignalRBridgeConnectionFactory {
     create(config) {
         return new SignalRBridgeConnection(config);
@@ -244,14 +300,7 @@ export class SignalRBridgeConnection {
     }
     onDispatch(handler) {
         this.connection.on("Dispatch", (raw) => {
-            let dispatch;
-            try {
-                dispatch = parseRunOnceDispatchPacket(raw);
-            }
-            catch {
-                return;
-            }
-            void handler(dispatch).catch(() => undefined);
+            void handler(raw).catch(() => undefined);
         });
     }
     onCancel(handler) {
@@ -278,7 +327,7 @@ export function defaultBridgeServiceConfig(overrides = {}) {
         projectLabels: splitCsv(process.env.FORGE_PROJECT_LABELS ?? ""),
         repoMappings: [],
         os: process.platform,
-        sandboxProfiles: ["default"],
+        sandboxProfiles: overrides.sandboxProfiles,
         supportsApiSecretGrant: true,
         supportsManagedWorktrees: true,
         supportsManagedForgeArtifacts: true,
@@ -292,6 +341,7 @@ export function defaultBridgeServiceConfig(overrides = {}) {
     };
     return {
         ...config,
+        sandboxProfiles: config.sandboxProfiles ?? defaultSandboxProfiles(config.cliProviders),
         heartbeatIntervalMs: positiveFiniteNumber(config.heartbeatIntervalMs, 30_000)
     };
 }
@@ -310,6 +360,11 @@ function positiveFiniteNumber(value, fallback) {
 function providerStatusesFor(providers) {
     return Object.fromEntries(providers.map((provider) => [provider, { signedIn: true, version: "", models: configuredModelsFor(provider) }]));
 }
+function defaultSandboxProfiles(providers) {
+    return providers.some((provider) => provider.toLowerCase() === "codex")
+        ? ["provider-workspace-write"]
+        : ["none"];
+}
 function configuredModelsFor(provider) {
     const envName = `FORGE_${provider.replace(/[^a-zA-Z0-9]/g, "_").toUpperCase()}_MODELS`;
     return splitCsv(process.env[envName] ?? "");
@@ -354,6 +409,28 @@ function cleanString(value) {
 function equalsIgnoreCase(left, right) {
     return !!left?.trim() && !!right?.trim() && left.trim().toLowerCase() === right.trim().toLowerCase();
 }
+function readDispatchIdentifiers(rawDispatch) {
+    if (!rawDispatch || typeof rawDispatch !== "object" || Array.isArray(rawDispatch)) {
+        return null;
+    }
+    const packet = rawDispatch;
+    const rawLease = packet.lease ?? packet.Lease;
+    if (!rawLease || typeof rawLease !== "object" || Array.isArray(rawLease)) {
+        return null;
+    }
+    const lease = rawLease;
+    const leaseId = readString(lease, "id", "Id");
+    const fencingToken = readString(lease, "fencingToken", "FencingToken");
+    return leaseId && fencingToken ? { leaseId, fencingToken } : null;
+}
+function readString(source, camelKey, pascalKey) {
+    const value = source[camelKey] ?? source[pascalKey];
+    return typeof value === "string" && value.trim() ? value : null;
+}
+function invalidDispatchSummary(error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return `Invalid bridge dispatch packet: ${detail}`;
+}
 function delay(ms, signal) {
     if (signal?.aborted) {
         return Promise.resolve();
@@ -376,6 +453,9 @@ function abortPromise(signal) {
     }
     return new Promise((resolve) => signal.addEventListener("abort", () => resolve(), { once: true }));
 }
-function exactSecrets(dispatch) {
-    return dispatch.apiKeySecretGrant?.secret ? [dispatch.apiKeySecretGrant.secret] : [];
+function exactSecrets(dispatch, config) {
+    return [
+        dispatch.apiKeySecretGrant?.secret,
+        config.deviceToken
+    ].filter((secret) => typeof secret === "string" && secret.length > 0);
 }

package/dist/bridge/bridge.types.d.ts

@@ -1,4 +1,4 @@
-import type { RunOnceDispatchPacket, RunOnceResultPacket, RunnerDispatchEvent } from "../session/session.types.js";
+import type { RunOnceResultPacket, RunnerDispatchEvent } from "../session/session.types.js";
 export interface BridgeServiceConfig {
     readonly serverUrl: string;
     readonly runnerId: string;
@@ -88,5 +88,5 @@ export interface BridgeCancelRequest {
     readonly fencingToken: string;
     readonly reason?: string | null;
 }
-export type BridgeDispatchHandler = (dispatch: RunOnceDispatchPacket) => Promise<void>;
+export type BridgeDispatchHandler = (dispatch: unknown) => Promise<void>;
 export type BridgeCancelHandler = (request: BridgeCancelRequest) => Promise<void>;

package/dist/cli/cli.service.js

@@ -176,19 +176,23 @@ function parseEnvSecretGrant(raw) {
     };
 }
 function exactSecrets(dispatch) {
-    return dispatch.apiKeySecretGrant?.secret ? [dispatch.apiKeySecretGrant.secret] : [];
+    return exactSecretValues(dispatch.apiKeySecretGrant?.secret, process.env.FORGE_DEVICE_TOKEN);
 }
 function readEnvSecretValuesForRedaction() {
+    const secrets = [];
     const raw = process.env[apiKeySecretGrantEnv];
-    if (!raw) {
-        return [];
-    }
-    try {
-        return [parseEnvSecretGrant(raw).secret];
-    }
-    catch {
-        return [];
+    if (raw) {
+        try {
+            secrets.push(parseEnvSecretGrant(raw).secret);
+        }
+        catch {
+            // Ignore malformed grant env here; command handling will report the parse error.
+        }
     }
+    return exactSecretValues(...secrets, process.env.FORGE_DEVICE_TOKEN);
+}
+function exactSecretValues(...values) {
+    return values.filter((value) => typeof value === "string" && value.length > 0);
 }
 export function parseArgs(argv) {
     if (argv[0] === "connect") {

package/dist/session/internals.d.ts

@@ -2,7 +2,7 @@ export { parseRunOnceDispatchPacket, failureResult } from "./session.types.js";
 export { buildCompletionToolServerArgs, codexMcpConfigArgs, completionPhaseFromDispatch, expectedCompletionToolName, prepareCompletionToolRuntime, readCompletionArtifact, writeCompletionArtifact } from "./phase-completion.js";
 export type { CompletionArtifactReference, CompletionPhase, CompletionToolRuntime } from "./phase-completion.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 type { ApiKeySecretGrant, DispatchCycleRun, DispatchExecution, DispatchLease, DispatchPullRequestContext, 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";

package/dist/session/phase-completion.d.ts

@@ -1,6 +1,10 @@
 import type { RunOnceDispatchPacket, RunnerDispatchArtifact } from "./session.types.js";
 import type { WorktreeHandle } from "../worktree/worktree.types.js";
-export type CompletionPhase = "implementation" | "self_review" | "validation" | "qa";
+export type DevelopCompletionPhase = "implementation" | "self_review" | "validation";
+export type DebugCompletionPhase = "debug_repro" | "debug_root_cause" | "debug_fix" | "debug_regression";
+export type ArchitectCompletionPhase = "architect";
+export type CompletionPhase = DevelopCompletionPhase | "qa" | DebugCompletionPhase | ArchitectCompletionPhase;
+export type QaCompletionGate = "qa_plan" | "qa_regression" | "qa_api" | "qa_manual_web" | "qa_bug_repro" | "qa_findings" | "qa_verdict";
 export interface CompletionToolRuntime {
     readonly serverName: string;
     readonly command: string;
@@ -23,6 +27,9 @@ export interface CompletionToolServerConfig {
     readonly producedBy?: string;
     readonly redactionSecrets?: readonly string[];
     readonly developCycle?: boolean;
+    readonly qaCycle?: boolean;
+    readonly debugCycle?: boolean;
+    readonly architectCycle?: boolean;
 }
 export interface CompletionToolCallResult {
     readonly content: readonly {
@@ -32,11 +39,12 @@ export interface CompletionToolCallResult {
     readonly structuredContent: CompletionArtifactReference & {
         readonly gate: {
             readonly phase: CompletionPhase;
+            readonly qaGate?: QaCompletionGate;
             readonly status: string;
             readonly allowed: boolean;
             readonly reason: string;
         };
-        readonly nextPhase: CompletionPhase | "dev_test_ready" | "sign_off_ready";
+        readonly nextPhase: CompletionPhase | "dev_test_ready" | "qa_ready" | "sign_off_ready";
         readonly nextInstruction: string;
     };
 }
@@ -52,33 +60,50 @@ export interface CompletionArtifactReference {
     readonly status: string;
     readonly producedBy: string;
 }
+export declare const debugCompletionPhaseOrder: readonly DebugCompletionPhase[];
+export declare const qaCompletionGateOrder: readonly QaCompletionGate[];
 export declare function completionPhaseFromDispatch(dispatch: RunOnceDispatchPacket): CompletionPhase;
 export declare function normalizeCompletionPhase(value: string | null | undefined): CompletionPhase;
 export declare function usesDevelopCycleCompletion(dispatch: RunOnceDispatchPacket): boolean;
+export declare function usesQaCycleCompletion(dispatch: RunOnceDispatchPacket): boolean;
+export declare function usesDebugCycleCompletion(dispatch: RunOnceDispatchPacket): boolean;
+export declare function usesArchitectCycleCompletion(dispatch: RunOnceDispatchPacket): boolean;
 export declare function completionToolNamesForPhase(phase: CompletionPhase): readonly string[];
+export declare function completionToolNamesForQaGate(gate: QaCompletionGate): readonly string[];
+export declare function completionToolNamesForDebugGate(gate: DebugCompletionPhase): readonly string[];
 export declare function expectedCompletionToolName(phase: CompletionPhase): string;
+export declare function expectedQaCompletionToolName(gate: QaCompletionGate): string;
+export declare function expectedDebugCompletionToolName(gate: DebugCompletionPhase): string;
 export declare function artifactRootFor(worktreePath: string, workItemId: string): string;
-export declare function completionArtifactJsonPath(worktreePath: string, workItemId: string, phase: CompletionPhase): string;
-export declare function completionArtifactReportPath(worktreePath: string, workItemId: string, phase: CompletionPhase): string;
+export declare function artifactRootForOwner(worktreePath: string, ownerType: string, ownerId: string): string;
+export declare function completionArtifactJsonPath(worktreePath: string, workItemId: string, phase: CompletionPhase, ownerType?: string | null, ownerId?: string | null): string;
+export declare function completionArtifactReportPath(worktreePath: string, workItemId: string, phase: CompletionPhase, ownerType?: string | null, ownerId?: string | null): string;
 export declare function prepareCompletionToolRuntime(options: CompletionToolRuntimeOptions): Promise<CompletionToolRuntime>;
 export declare function buildCompletionToolServerArgs(config: CompletionToolServerConfig): readonly string[];
 export declare function codexMcpConfigArgs(runtime: CompletionToolRuntime): readonly string[];
 export declare function cursorMcpServerConfig(runtime: CompletionToolRuntime): unknown;
 export declare function completionPromptForPhase(phase: CompletionPhase): string;
 export declare function completionPromptForDevelopCycle(phase: CompletionPhase): string;
+export declare function completionPromptForQaCycle(currentGate?: QaCompletionGate): string;
+export declare function completionPromptForDebugCycle(currentGate?: DebugCompletionPhase): string;
 export declare function completionToolNamesForServer(config: CompletionToolServerConfig): readonly string[];
 export declare class CompletionToolServerSession {
     private readonly config;
     private currentPhase;
+    private currentQaGate;
     private completed;
     constructor(config: CompletionToolServerConfig);
     get instructions(): string;
     toolDefinitions(): readonly unknown[];
     callTool(toolName: string, input: unknown): Promise<CompletionToolCallResult>;
+    private callDebugGateTool;
+    private callQaGateTool;
     private advanceAfterPass;
+    private advanceAfterQaGate;
+    private advanceAfterDebugGate;
 }
 export declare function writeCompletionArtifact(config: CompletionToolServerConfig, toolName: string, input: unknown): Promise<CompletionArtifactReference>;
-export declare function readCompletionArtifact(worktreePath: string, workItemId: string, phase: CompletionPhase): Promise<RunnerDispatchArtifact | null>;
+export declare function readCompletionArtifact(worktreePath: string, workItemId: string, phase: CompletionPhase, ownerType?: string | null, ownerId?: string | null): Promise<RunnerDispatchArtifact | null>;
 export declare function runCompletionMcpServer(config: CompletionToolServerConfig): Promise<void>;
 export declare function parseCompletionMcpArgs(argv: readonly string[]): {
     readonly ok: true;