@loucompanion/forge-bridge 0.1.1-dev.8dcbc6245e51 → 0.1.1-dev.9acab970e5d1

package/dist/bridge/bridge.service.js

@@ -87,11 +87,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));
@@ -123,6 +132,7 @@ export class ForgeBridgeService {
         const mapping = findRepoMapping(dispatch, this.config.repoMappings);
         const localPath = mapping?.localPath?.trim();
         const repoRoot = localPath ? path.dirname(path.resolve(localPath)) : this.config.defaultRepoRoot;
+        const qaLaunchTarget = normalizeQaAppLaunchTarget(mapping?.qaAppLaunchTarget) ?? dispatch.qaBrowser?.launchTarget ?? null;
         return {
             ...dispatch,
             repo: {
@@ -133,7 +143,13 @@ export class ForgeBridgeService {
             serverLocal: {
                 repoRoot,
                 cleanupWorktrees: this.config.cleanupWorktrees
-            }
+            },
+            qaBrowser: dispatch.qaBrowser
+                ? {
+                    ...dispatch.qaBrowser,
+                    launchTarget: qaLaunchTarget
+                }
+                : dispatch.qaBrowser
         };
     }
     async sendResult(leaseId, fencingToken, result) {
@@ -142,7 +158,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();
@@ -176,7 +200,10 @@ export class ForgeBridgeService {
             repoMappings: this.config.repoMappings,
             os: this.config.os,
             sandboxProfiles: this.config.sandboxProfiles,
-            supportsApiSecretGrant: this.config.supportsApiSecretGrant
+            supportsApiSecretGrant: this.config.supportsApiSecretGrant,
+            supportsManagedWorktrees: this.config.supportsManagedWorktrees,
+            supportsManagedForgeArtifacts: this.config.supportsManagedForgeArtifacts,
+            supportsRunnerAuthoredPhaseArtifacts: this.config.supportsRunnerAuthoredPhaseArtifacts
         };
     }
     async invokeAck(methodName, payload) {
@@ -186,7 +213,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;
     }
@@ -204,6 +231,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);
@@ -270,6 +311,9 @@ export function defaultBridgeServiceConfig(overrides = {}) {
         os: process.platform,
         sandboxProfiles: ["default"],
         supportsApiSecretGrant: true,
+        supportsManagedWorktrees: true,
+        supportsManagedForgeArtifacts: true,
+        supportsRunnerAuthoredPhaseArtifacts: true,
         version: process.env.FORGE_BRIDGE_VERSION ?? forgeBridgeVersion,
         protocolVersion: 1,
         minServerVersion: null,
@@ -317,6 +361,27 @@ function findRepoMapping(dispatch, mappings) {
             (!!mapping.remoteUrl?.trim() && equalsIgnoreCase(mapping.remoteUrl, dispatch.repo.remoteUrl)));
     });
 }
+function normalizeQaAppLaunchTarget(target) {
+    if (!target) {
+        return null;
+    }
+    const routes = [...new Set((target.routes ?? []).map((route) => route.trim()).filter(Boolean))];
+    const normalized = {
+        url: cleanString(target.url),
+        command: cleanString(target.command),
+        working_directory: cleanString(target.working_directory),
+        ready_url: cleanString(target.ready_url),
+        routes,
+        notes: cleanString(target.notes)
+    };
+    return normalized.url || normalized.command || normalized.ready_url || routes.length > 0
+        ? normalized
+        : null;
+}
+function cleanString(value) {
+    const clean = value?.trim();
+    return clean ? clean : null;
+}
 function equalsIgnoreCase(left, right) {
     return !!left?.trim() && !!right?.trim() && left.trim().toLowerCase() === right.trim().toLowerCase();
 }

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

@@ -13,6 +13,9 @@ export interface BridgeServiceConfig {
     readonly os: string;
     readonly sandboxProfiles: readonly string[];
     readonly supportsApiSecretGrant: boolean;
+    readonly supportsManagedWorktrees: boolean;
+    readonly supportsManagedForgeArtifacts: boolean;
+    readonly supportsRunnerAuthoredPhaseArtifacts: boolean;
     readonly version: string;
     readonly protocolVersion: number;
     readonly minServerVersion?: string | null;
@@ -24,6 +27,15 @@ export interface BridgeRepoMapping {
     readonly name?: string | null;
     readonly remoteUrl?: string | null;
     readonly localPath?: string | null;
+    readonly qaAppLaunchTarget?: QaAppLaunchTarget | null;
+}
+export interface QaAppLaunchTarget {
+    readonly url?: string | null;
+    readonly command?: string | null;
+    readonly working_directory?: string | null;
+    readonly ready_url?: string | null;
+    readonly routes?: readonly string[] | null;
+    readonly notes?: string | null;
 }
 export interface BridgeProviderStatus {
     readonly signedIn?: boolean | null;
@@ -40,6 +52,9 @@ export interface BridgeCapabilities {
     readonly os?: string | null;
     readonly sandboxProfiles?: readonly string[] | null;
     readonly supportsApiSecretGrant?: boolean | null;
+    readonly supportsManagedWorktrees?: boolean | null;
+    readonly supportsManagedForgeArtifacts?: boolean | null;
+    readonly supportsRunnerAuthoredPhaseArtifacts?: boolean | null;
 }
 export interface BridgeHelloRequest {
     readonly version: string;

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

@@ -5,7 +5,8 @@ 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);
+    private readonly pairRunner;
+    constructor(sessions?: SessionService, bridgeFactory?: (config: BridgeServiceConfig) => BridgeService, pairRunner?: PairRunnerClient);
     run(argv: readonly string[], io?: CliIo): Promise<number>;
 }
 export declare function parseArgs(argv: readonly string[]): {
@@ -13,11 +14,18 @@ export declare function parseArgs(argv: readonly string[]): {
     readonly command: "run-once";
     readonly dispatchPath: string;
     readonly resultPath: string;
+} | {
+    readonly ok: true;
+    readonly command: "mcp";
+    readonly argv: readonly string[];
 } | {
     readonly ok: true;
     readonly command: "connect";
     readonly config: BridgeServiceConfig;
-} | {
+} | ({
+    readonly ok: true;
+    readonly command: "pair";
+} & PairArgs) | {
     readonly ok: true;
     readonly command: "add-repo";
     readonly label: string;
@@ -41,5 +49,22 @@ export declare function parseArgs(argv: readonly string[]): {
     readonly ok: false;
     readonly error: string;
 };
+interface PairArgs {
+    readonly serverUrl: string;
+    readonly code?: string;
+    readonly name: string;
+    readonly fingerprint: string;
+    readonly repoRoot?: string;
+    readonly cleanupWorktrees: boolean;
+    readonly cliProviders: readonly string[];
+    readonly projectLabels: readonly string[];
+}
+interface PairRunnerClaim {
+    readonly runnerId: string;
+    readonly deviceToken: string;
+}
+type PairRunnerClient = (args: PairArgs) => Promise<PairRunnerClaim>;
+export declare function parseCodexModelCatalog(raw: string): string[];
+export declare function parseCursorModelList(raw: string): string[];
 type CleanupMode = "stale" | "merged" | "all";
 export {};