@sentry/junior 0.113.0 → 0.115.0

package/dist/oauth-callback-server-EYRMJTCS.js

@@ -0,0 +1,231 @@
+import {
+  GET,
+  GET2,
+  syncLocalOAuthCredential
+} from "./chunk-YCLO7D7M.js";
+import "./chunk-FA6POGLH.js";
+import "./chunk-AGLQYELI.js";
+import "./chunk-4CODA7P5.js";
+import "./chunk-MIAKQNYX.js";
+import "./chunk-KNFROR7R.js";
+import {
+  createUserTokenStore
+} from "./chunk-LYA2AB5G.js";
+import "./chunk-CEYOL62C.js";
+import "./chunk-MU6HHZEN.js";
+import "./chunk-PDO5BLNM.js";
+import "./chunk-RAVKCKXA.js";
+import "./chunk-67CVNDJ7.js";
+import "./chunk-CWEZEPD4.js";
+import "./chunk-HWCQRGLL.js";
+import "./chunk-JQFJO5WH.js";
+import "./chunk-4ZNGQH7C.js";
+import "./chunk-SYJT7AKB.js";
+import "./chunk-VFUK3X5B.js";
+import "./chunk-FXOYURO4.js";
+import "./chunk-2QG4MZQ7.js";
+import "./chunk-6FKLPVF3.js";
+import "./chunk-EW5MLKT5.js";
+import "./chunk-W3U3YQYI.js";
+import "./chunk-HZF5P5UN.js";
+import "./chunk-NVUQSFWX.js";
+import "./chunk-OB42YVAE.js";
+import "./chunk-F3B2YJ76.js";
+import "./chunk-6GWA276C.js";
+import "./chunk-B3IT5END.js";
+import "./chunk-3V7OFJZC.js";
+import "./chunk-TVE25LPW.js";
+import "./chunk-FHC4JUSF.js";
+import "./chunk-MLKGABMK.js";
+
+// src/chat/local/oauth-callback-server.ts
+import { createServer } from "http";
+var LOCAL_OAUTH_TIMEOUT_MS = 10 * 60 * 1e3;
+var LOCAL_OAUTH_CALLBACK_TIMEOUT_MS = 60 * 1e3;
+function decodeProvider(value) {
+  if (!value) {
+    return void 0;
+  }
+  try {
+    const provider = decodeURIComponent(value);
+    return /^[a-z][a-z0-9-]*$/.test(provider) ? provider : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function startLocalOAuthCallbackServer(agentRunner) {
+  let pendingAuthorization;
+  const completeAuthorization = (authorization, result) => {
+    if (authorization.settled) {
+      return;
+    }
+    authorization.settled = true;
+    clearTimeout(authorization.timeout);
+    authorization.finish(result);
+  };
+  const cancelAuthorization = () => {
+    const authorization = pendingAuthorization;
+    if (!authorization) {
+      return;
+    }
+    pendingAuthorization = void 0;
+    completeAuthorization(
+      authorization,
+      new Error("Local OAuth authorization canceled")
+    );
+  };
+  const server = createServer(async (incoming, outgoing) => {
+    const host = incoming.headers.host ?? "127.0.0.1";
+    let requestUrl;
+    try {
+      requestUrl = new URL(incoming.url ?? "/", `http://${host}`);
+    } catch {
+      outgoing.writeHead(400).end("Invalid callback request");
+      return;
+    }
+    const mcpMatch = requestUrl.pathname.match(
+      /^\/api\/oauth\/callback\/mcp\/([^/]+)$/
+    );
+    const pluginMatch = requestUrl.pathname.match(
+      /^\/api\/oauth\/callback\/([^/]+)$/
+    );
+    const provider = decodeProvider(mcpMatch?.[1] ?? pluginMatch?.[1]);
+    if (!provider) {
+      outgoing.writeHead(404).end("Not found");
+      return;
+    }
+    const authorization = pendingAuthorization;
+    if (!authorization || authorization.callbackStarted || authorization.settled || requestUrl.searchParams.get("state") !== authorization.state) {
+      outgoing.writeHead(409).end("No matching authorization request");
+      return;
+    }
+    authorization.callbackStarted = true;
+    clearTimeout(authorization.timeout);
+    authorization.timeout = setTimeout(() => {
+      if (!outgoing.headersSent) {
+        outgoing.writeHead(504).end("Authorization callback timed out");
+      }
+      completeAuthorization(
+        authorization,
+        new Error("Timed out completing OAuth authorization")
+      );
+    }, LOCAL_OAUTH_CALLBACK_TIMEOUT_MS);
+    const backgroundTasks = [];
+    const waitUntil = (task) => {
+      backgroundTasks.push(
+        typeof task === "function" ? Promise.resolve().then(task) : task
+      );
+    };
+    try {
+      const request = new Request(requestUrl, { method: "GET" });
+      const response = mcpMatch ? await GET(request, provider, waitUntil, {
+        agentRunner
+      }) : await GET2(request, provider, waitUntil, {
+        agentRunner
+      });
+      const body = Buffer.from(await response.arrayBuffer());
+      await Promise.all(backgroundTasks);
+      if (response.ok) {
+        if (!mcpMatch) {
+          const tokens = await createUserTokenStore().get(
+            "local-cli",
+            provider
+          );
+          if (!tokens) {
+            throw new Error(
+              `${provider} authorization completed without a stored credential`
+            );
+          }
+          await syncLocalOAuthCredential(provider, tokens);
+        }
+      }
+      if (authorization.settled) {
+        return;
+      }
+      if (response.ok) {
+        completeAuthorization(authorization, true);
+      } else {
+        completeAuthorization(
+          authorization,
+          new Error(
+            `${provider} authorization callback failed with HTTP ${response.status}`
+          )
+        );
+      }
+      outgoing.writeHead(
+        response.status,
+        Object.fromEntries(response.headers.entries())
+      );
+      outgoing.end(body);
+    } catch (error) {
+      if (!outgoing.headersSent) {
+        outgoing.writeHead(500).end("Authorization callback failed");
+      }
+      completeAuthorization(
+        authorization,
+        error instanceof Error ? error : new Error(String(error))
+      );
+    }
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+  const address = server.address();
+  return {
+    beginAuthorization: (authorizationUrl) => {
+      if (pendingAuthorization) {
+        throw new Error("Local OAuth already has an active authorization");
+      }
+      const state = new URL(authorizationUrl).searchParams.get("state");
+      if (!state) {
+        throw new Error("Local OAuth authorization URL is missing state");
+      }
+      let finish = () => void 0;
+      const result = new Promise((resolve) => {
+        finish = resolve;
+      });
+      const authorization = {
+        callbackStarted: false,
+        finish,
+        result,
+        settled: false,
+        state,
+        timeout: setTimeout(() => {
+          completeAuthorization(
+            authorization,
+            new Error("Timed out waiting for OAuth authorization")
+          );
+        }, LOCAL_OAUTH_TIMEOUT_MS)
+      };
+      pendingAuthorization = authorization;
+    },
+    cancelAuthorization,
+    port: address.port,
+    waitForAuthorization: async () => {
+      const authorization = pendingAuthorization;
+      if (!authorization) {
+        throw new Error("Local OAuth has no active authorization");
+      }
+      const result = await authorization.result;
+      if (pendingAuthorization === authorization) {
+        pendingAuthorization = void 0;
+      }
+      if (result instanceof Error) {
+        throw result;
+      }
+    },
+    close: async () => {
+      cancelAuthorization();
+      await new Promise((resolve, reject) => {
+        server.close((error) => error ? reject(error) : resolve());
+      });
+    }
+  };
+}
+export {
+  startLocalOAuthCallbackServer
+};

package/dist/oauth-relay-3ZU72UGL.js

@@ -0,0 +1,9 @@
+import {
+  createLocalOAuthState,
+  relayLocalOAuthCallback
+} from "./chunk-FA6POGLH.js";
+import "./chunk-MLKGABMK.js";
+export {
+  createLocalOAuthState,
+  relayLocalOAuthCallback
+};

package/dist/reporting-schema.d.ts

@@ -4,10 +4,18 @@ export declare const healthReportSchema: z.ZodObject<{
     service: z.ZodString;
     timestamp: z.ZodString;
 }, z.core.$strict>;
-export declare const pluginReportSchema: z.ZodObject<{
+export declare const pluginSchema: z.ZodObject<{
+    capabilities: z.ZodArray<z.ZodString>;
+    configKeys: z.ZodArray<z.ZodString>;
+    description: z.ZodString;
+    displayName: z.ZodString;
     name: z.ZodString;
 }, z.core.$strict>;
-export declare const pluginReportsSchema: z.ZodArray<z.ZodObject<{
+export declare const pluginsSchema: z.ZodArray<z.ZodObject<{
+    capabilities: z.ZodArray<z.ZodString>;
+    configKeys: z.ZodArray<z.ZodString>;
+    description: z.ZodString;
+    displayName: z.ZodString;
     name: z.ZodString;
 }, z.core.$strict>>;
 export declare const skillReportSchema: z.ZodObject<{
@@ -175,8 +183,8 @@ export declare const pluginOperationalReportFeedSchema: z.ZodObject<{
     source: z.ZodLiteral<"plugins">;
 }, z.core.$strict>;
 export type HealthReport = z.infer<typeof healthReportSchema>;
-export type PluginReport = z.infer<typeof pluginReportSchema>;
-export type PluginReports = z.infer<typeof pluginReportsSchema>;
+export type Plugin = z.infer<typeof pluginSchema>;
+export type Plugins = z.infer<typeof pluginsSchema>;
 export type SkillReport = z.infer<typeof skillReportSchema>;
 export type SkillReports = z.infer<typeof skillReportsSchema>;
 export type RuntimeInfoReport = z.infer<typeof runtimeInfoReportSchema>;

package/dist/reporting.d.ts

@@ -1,11 +1,11 @@
-import type { PluginOperationalReportFeed, PluginReport, RuntimeInfoReport, SkillReport } from "./reporting-schema";
-export { healthReportSchema, pluginOperationalReportFeedSchema, pluginOperationalReportSchema, pluginPackageContentItemReportSchema, pluginPackageContentReportSchema, pluginReportSchema, pluginReportsSchema, runtimeInfoReportSchema, skillReportSchema, skillReportsSchema, } from "./reporting-schema";
+import type { PluginOperationalReportFeed, Plugin, RuntimeInfoReport, SkillReport } from "./reporting-schema";
+export { healthReportSchema, pluginOperationalReportFeedSchema, pluginOperationalReportSchema, pluginPackageContentItemReportSchema, pluginPackageContentReportSchema, pluginSchema, pluginsSchema, runtimeInfoReportSchema, skillReportSchema, skillReportsSchema, } from "./reporting-schema";
 export { readHealthReport } from "./handlers/health";
-export type { HealthReport, PluginOperationalReport, PluginOperationalReportFeed, PluginPackageContentItemReport, PluginPackageContentReport, PluginReport, PluginReports, RuntimeInfoReport, SkillReport, SkillReports, } from "./reporting-schema";
+export type { HealthReport, PluginOperationalReport, PluginOperationalReportFeed, PluginPackageContentItemReport, PluginPackageContentReport, Plugin, Plugins, RuntimeInfoReport, SkillReport, SkillReports, } from "./reporting-schema";
 /** Read discovered skill names for authenticated runtime diagnostics. */
 export declare function readSkillReports(): Promise<SkillReport[]>;
-/** Read configured plugin names for authenticated runtime diagnostics. */
-export declare function readPluginReports(): Promise<PluginReport[]>;
+/** Read safe configured plugin metadata for authenticated runtime diagnostics. */
+export declare function readPlugins(): Promise<Plugin[]>;
 /** Read authenticated runtime discovery data. */
 export declare function readRuntimeInfoReport(): Promise<RuntimeInfoReport>;
 /** Read sanitized operational summaries contributed by plugins. */

package/dist/{runner-L363K62Z.js → runner-RQGZ5Z2S.js}

@@ -1,11 +1,15 @@
 import {
   ConversationTurnLifecycleService,
   buildDeliveredTurnStatePatch,
+  completeAuthPauseTurn,
   finalizeFailedTurnReplyWithEvent,
   processPluginTask,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-WBB22ANL.js";
+} from "./chunk-AGLQYELI.js";
 import "./chunk-KNFROR7R.js";
+import {
+  authorizationId
+} from "./chunk-DIB4GX3G.js";
 import {
   buildConversationContext,
   coerceThreadArtifactsState,
@@ -21,34 +25,36 @@ import {
   persistConversationMessages,
   persistThreadStateById,
   persistWithRetry,
+  recordAuthorizationCompleted,
   recordDeliveredAssistantMessage,
   startActiveTurn,
   stripRuntimeTurnContext,
   trimTrailingAssistantMessages,
   updateConversationStats,
   upsertConversationMessage
-} from "./chunk-DXRPHBOU.js";
+} from "./chunk-CEYOL62C.js";
 import "./chunk-MU6HHZEN.js";
 import "./chunk-PDO5BLNM.js";
-import "./chunk-YJ44UT7D.js";
-import "./chunk-HMRVILWZ.js";
-import "./chunk-QTS66GMR.js";
+import "./chunk-RAVKCKXA.js";
+import "./chunk-67CVNDJ7.js";
+import "./chunk-CWEZEPD4.js";
 import {
   getConversationEventStore
-} from "./chunk-LLKDNPYV.js";
+} from "./chunk-HWCQRGLL.js";
 import "./chunk-JQFJO5WH.js";
 import "./chunk-4ZNGQH7C.js";
-import "./chunk-RCBUZGIT.js";
+import "./chunk-SYJT7AKB.js";
 import "./chunk-VFUK3X5B.js";
-import "./chunk-6Y5L4BOM.js";
-import "./chunk-C4MZ3GP5.js";
+import "./chunk-FXOYURO4.js";
+import "./chunk-HZF5P5UN.js";
 import {
   logException
-} from "./chunk-36UJA3OD.js";
-import "./chunk-42WRQLJ6.js";
+} from "./chunk-NVUQSFWX.js";
+import "./chunk-OB42YVAE.js";
+import "./chunk-F3B2YJ76.js";
 import "./chunk-6GWA276C.js";
-import "./chunk-NP7TYFYR.js";
-import "./chunk-ZRSUCJGA.js";
+import "./chunk-TVE25LPW.js";
+import "./chunk-FHC4JUSF.js";
 import "./chunk-MLKGABMK.js";
 
 // src/chat/local/runner.ts
@@ -77,11 +83,17 @@ function localDestination(conversationId) {
 function localTurnId() {
   return `local-turn-${randomUUID()}`;
 }
+function localRunId() {
+  return `local-run-${randomUUID()}`;
+}
 function captureLocalBoundaryFailure(args) {
   const eventId = args.capture(
     args.error,
     LOCAL_FAILURE_EVENT_NAMES[args.failureCode],
-    { conversationId: args.conversationId, runId: args.turnId },
+    {
+      conversationId: args.conversationId,
+      ...args.runId ? { runId: args.runId } : {}
+    },
     { "app.ai.failure_code": args.failureCode },
     "Local agent turn failed at its owning runtime boundary"
   );
@@ -157,6 +169,8 @@ async function runLocalAgentTurn(input, deps) {
   let failureCode = "persistence_failed";
   let modelFailureEventId;
   let modelFailureCaptureAttempted = false;
+  let currentRunId;
+  let completionSliceId = 1;
   const localActor = {
     fullName: "Local CLI",
     platform: "local",
@@ -201,66 +215,117 @@ async function runLocalAgentTurn(input, deps) {
       conversationId: input.conversationId
     });
     failureCode = "agent_run_failed";
-    const outcome = await deps.agentRunner.run({
-      conversationId: input.conversationId,
-      turnId,
-      runId: turnId,
-      input: {
-        messageText: text,
-        conversationContext: buildConversationContext(conversation, {
-          excludeMessageId: userMessageId
-        }),
-        piMessages
-      },
-      routing: {
-        credentialContext: {
-          actor: { platform: "system", name: "local-cli" }
+    const runAgent = async (messages) => {
+      currentRunId = localRunId();
+      const authorization = deps.authorization ? {
+        createState: deps.authorization.createState,
+        deliver: deps.authorization.deliver
+      } : void 0;
+      return await deps.agentRunner.run({
+        conversationId: input.conversationId,
+        turnId,
+        runId: currentRunId,
+        input: {
+          messageText: text,
+          conversationContext: buildConversationContext(conversation, {
+            excludeMessageId: userMessageId
+          }),
+          piMessages: messages
         },
-        destination,
-        source,
-        actor: localActor,
-        surface: "internal"
-      },
-      policy: {
-        authorizationFlowMode: "disabled"
-      },
-      state: {
-        artifactState: artifacts,
-        sandboxRef
-      },
-      observers: {
-        onStatus: async (status) => {
-          await deps.onStatus?.(status.text);
+        routing: {
+          credentialContext: {
+            actor: { type: "user", userId: "local-cli" }
+          },
+          destination,
+          source,
+          actor: localActor,
+          surface: "internal"
         },
-        onToolInvocation: async (invocation) => {
-          await deps.onToolInvocation?.(invocation);
+        authorization,
+        policy: {
+          authorizationFlowMode: deps.authorization ? "interactive" : "disabled",
+          sandboxEgressSignals: deps.sandboxEgressSignals
         },
-        onToolResult: async (result) => {
-          await deps.onToolResult?.(result);
-        }
-      },
-      delivery: {
-        onAssistantMessage: deliverAssistantMessage
-      },
-      durability: {
-        onArtifactStateUpdated: async (nextArtifacts) => {
-          artifacts = nextArtifacts;
-          await persistThreadStateById(input.conversationId, {
-            artifacts,
-            conversation,
-            sandboxRef
-          });
+        state: {
+          artifactState: artifacts,
+          pendingAuth: conversation.processing.pendingAuth,
+          sandboxRef
+        },
+        observers: {
+          onStatus: async (status) => {
+            await deps.onStatus?.(status.text);
+          },
+          onToolInvocation: async (invocation) => {
+            await deps.onToolInvocation?.(invocation);
+          },
+          onToolResult: async (result) => {
+            await deps.onToolResult?.(result);
+          }
+        },
+        delivery: {
+          onAssistantMessage: deliverAssistantMessage
         },
-        onSandboxRefChanged: async (nextSandboxRef) => {
-          sandboxRef = nextSandboxRef;
-          await persistThreadStateById(input.conversationId, {
-            artifacts,
-            conversation,
-            sandboxRef
-          });
+        durability: {
+          onArtifactStateUpdated: async (nextArtifacts) => {
+            artifacts = nextArtifacts;
+            await persistThreadStateById(input.conversationId, {
+              artifacts,
+              conversation,
+              sandboxRef
+            });
+          },
+          onSandboxRefChanged: async (nextSandboxRef) => {
+            sandboxRef = nextSandboxRef;
+            await persistThreadStateById(input.conversationId, {
+              artifacts,
+              conversation,
+              sandboxRef
+            });
+          },
+          recordPendingAuth: async (pendingAuth) => {
+            conversation.processing.pendingAuth = pendingAuth;
+            await persistThreadStateById(input.conversationId, {
+              artifacts,
+              conversation,
+              sandboxRef
+            });
+          }
         }
+      });
+    };
+    let outcome = await runAgent(piMessages);
+    while (outcome.status === "awaiting_auth") {
+      const pendingAuth = conversation.processing.pendingAuth;
+      if (!pendingAuth || !deps.authorization) {
+        throw new Error(
+          "Local OAuth requires an active callback server and authorization delivery."
+        );
       }
-    });
+      completeAuthPauseTurn({ conversation, sessionId: turnId });
+      await persistThreadStateById(input.conversationId, {
+        artifacts,
+        conversation,
+        sandboxRef
+      });
+      await deps.authorization.wait();
+      await recordAuthorizationCompleted({
+        conversationId: input.conversationId,
+        kind: pendingAuth.kind,
+        provider: pendingAuth.provider,
+        actorId: pendingAuth.actorId,
+        authorizationId: authorizationId({
+          sessionId: turnId,
+          kind: pendingAuth.kind,
+          provider: pendingAuth.provider
+        })
+      });
+      completionSliceId += 1;
+      outcome = await runAgent(
+        await (deps.loadPiMessages ?? loadLocalPiMessages)({
+          conversationId: input.conversationId
+        })
+      );
+    }
     if (outcome.status !== "completed") {
       throw new Error(`Local agent run ended with ${outcome.status}`);
     }
@@ -284,12 +349,13 @@ async function runLocalAgentTurn(input, deps) {
       userMessageId
     });
   } catch (error) {
+    deps.authorization?.cancel();
     const failureEventId = modelFailureCaptureAttempted && failureCode === "agent_run_failed" ? modelFailureEventId : captureLocalBoundaryFailure({
       capture: deps.logException ?? logException,
       conversationId: input.conversationId,
       error,
       failureCode,
-      turnId
+      runId: currentRunId
     });
     try {
       markTurnFailed({
@@ -311,7 +377,7 @@ async function runLocalAgentTurn(input, deps) {
         conversationId: input.conversationId,
         error: persistenceError,
         failureCode: "persistence_failed",
-        turnId
+        runId: currentRunId
       });
       await lifecycle.fail({
         conversationId: input.conversationId,
@@ -334,6 +400,7 @@ async function runLocalAgentTurn(input, deps) {
     });
     throw error;
   }
+  deps.authorization?.cancel();
   try {
     await persistThreadStateById(input.conversationId, {
       artifacts: completedState.artifacts ?? artifacts,
@@ -344,7 +411,7 @@ async function runLocalAgentTurn(input, deps) {
       await (deps.completeDeliveredTurn ?? completeDeliveredTurn)({
         conversationId: input.conversationId,
         sessionId: turnId,
-        sliceId: 1,
+        sliceId: completionSliceId,
         messages: reply.piMessages,
         modelId: reply.diagnostics.modelId,
         durationMs: reply.diagnostics.durationMs,
@@ -362,7 +429,7 @@ async function runLocalAgentTurn(input, deps) {
       conversationId: input.conversationId,
       error,
       failureCode: "persistence_failed",
-      turnId
+      runId: currentRunId
     });
     await lifecycle.fail({
       conversationId: input.conversationId,

package/dist/sandbox-egress-signals-CDFAP67O.js

@@ -0,0 +1,75 @@
+import {
+  sandboxEgressSignalsResponseSchema
+} from "./chunk-HDSDCEPK.js";
+import "./chunk-W3U3YQYI.js";
+import "./chunk-HZF5P5UN.js";
+import "./chunk-F3B2YJ76.js";
+import "./chunk-MLKGABMK.js";
+
+// src/chat/local/sandbox-egress-signals.ts
+var SANDBOX_EGRESS_SIGNALS_PATH = "/api/internal/sandbox-egress/signals";
+var LOCAL_DEV_SERVER_TIMEOUT_MS = 1e3;
+function signalRequest(baseUrl, credentialToken) {
+  return {
+    headers: {
+      "x-junior-sandbox-egress-token": credentialToken
+    },
+    url: `${baseUrl}${SANDBOX_EGRESS_SIGNALS_PATH}`
+  };
+}
+async function requestLocalDevServer(request, init) {
+  try {
+    return await fetch(request.url, {
+      ...init,
+      headers: request.headers,
+      signal: AbortSignal.timeout(LOCAL_DEV_SERVER_TIMEOUT_MS)
+    });
+  } catch {
+    return void 0;
+  }
+}
+function createLocalSandboxEgressSignalTransport(baseUrl) {
+  return {
+    clear: async (credentialToken) => {
+      const request = signalRequest(baseUrl, credentialToken);
+      const response = await requestLocalDevServer(request, {
+        method: "DELETE"
+      });
+      if (!response) {
+        return;
+      }
+      if (!response.ok) {
+        throw new Error(
+          `Could not clear dev-server sandbox egress signals: HTTP ${response.status}`
+        );
+      }
+    },
+    consume: async (credentialToken) => {
+      const request = signalRequest(baseUrl, credentialToken);
+      const response = await requestLocalDevServer(request);
+      if (!response) {
+        return {};
+      }
+      if (!response.ok) {
+        throw new Error(
+          `Could not consume dev-server sandbox egress signals: HTTP ${response.status}`
+        );
+      }
+      const value = sandboxEgressSignalsResponseSchema.safeParse(
+        await response.json()
+      );
+      if (!value.success) {
+        throw new Error("Dev-server sandbox egress signals were invalid");
+      }
+      const authRequired = value.data.auth_required;
+      const permissionDenied = value.data.permission_denied;
+      return {
+        ...authRequired ? { authRequired } : {},
+        ...permissionDenied ? { permissionDenied } : {}
+      };
+    }
+  };
+}
+export {
+  createLocalSandboxEgressSignalTransport
+};