@sentry/junior 0.75.0 → 0.76.0

package/dist/{chunk-2RWFUS5F.js → chunk-ZLMBNBUG.js}

@@ -1,16 +1,16 @@
+import {
+  parseActorUserId
+} from "./chunk-VALUBQ7R.js";
 import {
   discoverInstalledPluginPackageContent,
   normalizePluginPackageNames,
   pluginRoots
 } from "./chunk-Q3XNY442.js";
-import {
-  parseActorUserId
-} from "./chunk-EIYL7I4S.js";
 import {
   logInfo,
   logWarn,
   setSpanAttributes
-} from "./chunk-OK4KKR7B.js";
+} from "./chunk-EJN6G5A2.js";
 
 // src/chat/plugins/registry.ts
 import { readFileSync, readdirSync, statSync } from "fs";
@@ -1252,6 +1252,7 @@ function createApiHeadersBroker(manifest) {
 }
 
 // src/chat/plugins/auth/oauth-request.ts
+import { z as z3 } from "zod";
 var DEFAULT_TOKEN_CONTENT_TYPE = "application/x-www-form-urlencoded";
 function requireNonEmptyTokenField(data, field) {
   const value = data[field];
@@ -1260,6 +1261,19 @@ function requireNonEmptyTokenField(data, field) {
   }
   return value;
 }
+function requireTokenResponseObject(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) {
+    throw new Error("OAuth token response must be an object");
+  }
+  return data;
+}
+var parsedOAuthTokenResponseSchema = z3.object({
+  accessToken: z3.string().min(1),
+  refreshToken: z3.string().min(1),
+  expiresAt: z3.number().positive().optional(),
+  refreshTokenExpiresAt: z3.number().positive().optional(),
+  scope: z3.string().min(1).optional()
+}).strict();
 function contentTypeToBody(contentType, payload) {
   const mediaType = contentType.split(";", 1)[0]?.trim().toLowerCase();
   if (!mediaType || mediaType === DEFAULT_TOKEN_CONTENT_TYPE) {
@@ -1299,10 +1313,12 @@ function buildOAuthTokenRequest(input) {
   };
 }
 function parseOAuthTokenResponse(data, requestedScope, options) {
-  const accessToken = requireNonEmptyTokenField(data, "access_token");
-  const refreshToken = requireNonEmptyTokenField(data, "refresh_token");
-  const expiresIn = data.expires_in;
-  const responseScope = data.scope;
+  const response = requireTokenResponseObject(data);
+  const accessToken = requireNonEmptyTokenField(response, "access_token");
+  const refreshToken = requireNonEmptyTokenField(response, "refresh_token");
+  const expiresIn = response.expires_in;
+  const refreshTokenExpiresIn = response.refresh_token_expires_in;
+  const responseScope = response.scope;
   let scope;
   if (responseScope !== void 0) {
     if (typeof responseScope !== "string") {
@@ -1319,23 +1335,28 @@ function parseOAuthTokenResponse(data, requestedScope, options) {
   } else {
     scope = normalizeOAuthScope(requestedScope);
   }
-  if (expiresIn === void 0) {
-    return { accessToken, refreshToken, ...scope ? { scope } : {} };
+  const result = { accessToken, refreshToken, ...scope ? { scope } : {} };
+  if (expiresIn !== void 0) {
+    if (typeof expiresIn !== "number" || !Number.isFinite(expiresIn) || expiresIn <= 0) {
+      throw new Error("OAuth token response returned invalid expires_in");
+    }
+    result.expiresAt = Date.now() + expiresIn * 1e3;
   }
-  if (typeof expiresIn !== "number" || !Number.isFinite(expiresIn) || expiresIn <= 0) {
-    throw new Error("OAuth token response returned invalid expires_in");
+  if (refreshTokenExpiresIn !== void 0) {
+    if (typeof refreshTokenExpiresIn !== "number" || !Number.isFinite(refreshTokenExpiresIn) || refreshTokenExpiresIn <= 0) {
+      throw new Error(
+        "OAuth token response returned invalid refresh_token_expires_in"
+      );
+    }
+    result.refreshTokenExpiresAt = Date.now() + refreshTokenExpiresIn * 1e3;
   }
-  return {
-    accessToken,
-    refreshToken,
-    expiresAt: Date.now() + expiresIn * 1e3,
-    ...scope ? { scope } : {}
-  };
+  return parsedOAuthTokenResponseSchema.parse(result);
 }
 
 // src/chat/plugins/auth/oauth-bearer-broker.ts
 var MAX_LEASE_MS2 = 60 * 60 * 1e3;
 var REFRESH_BUFFER_MS = 5 * 60 * 1e3;
+var TOKEN_REFRESH_TIMEOUT_MS = 2e4;
 var OAuthRefreshRejectedError = class extends Error {
   constructor(message) {
     super(message);
@@ -1374,7 +1395,8 @@ async function refreshAccessToken(refreshToken, oauth, requestedScope) {
   const response = await fetch(oauth.tokenEndpoint, {
     method: "POST",
     headers: request.headers,
-    body: request.body
+    body: request.body,
+    signal: AbortSignal.timeout(TOKEN_REFRESH_TIMEOUT_MS)
   });
   if (!response.ok) {
     const errorCode = parseRefreshError(await response.text());
@@ -1395,6 +1417,12 @@ async function refreshAccessToken(refreshToken, oauth, requestedScope) {
 function getLeaseExpiry(expiresAt) {
   return expiresAt ? Math.min(expiresAt, Date.now() + MAX_LEASE_MS2) : Date.now() + MAX_LEASE_MS2;
 }
+function canUseStoredToken(stored) {
+  return stored !== void 0 && (stored.expiresAt === void 0 || stored.expiresAt > Date.now());
+}
+function shouldRefreshStoredToken(stored) {
+  return stored !== void 0 && stored.expiresAt !== void 0 && stored.expiresAt - Date.now() < REFRESH_BUFFER_MS;
+}
 function createOAuthBearerBroker(manifest, credentials, deps) {
   const provider = manifest.name;
   const { domains, apiHeaders, authTokenEnv } = credentials;
@@ -1442,33 +1470,62 @@ function createOAuthBearerBroker(manifest, credentials, deps) {
               `Your ${provider} connection needs to be reauthorized.`
             );
           }
-          const now = Date.now();
-          if (stored.expiresAt !== void 0 && stored.expiresAt - now < REFRESH_BUFFER_MS) {
+          if (shouldRefreshStoredToken(stored)) {
             try {
-              const refreshed = await refreshAccessToken(
-                stored.refreshToken,
-                oauth,
-                stored.scope ?? oauth.scope
-              );
-              if (!hasRequiredOAuthScope(refreshed.scope, oauth.scope)) {
-                throw new CredentialUnavailableError(
-                  provider,
-                  `Your ${provider} connection needs to be reauthorized.`
-                );
-              }
-              const refreshedTokens = {
-                ...refreshed,
-                ...stored.account ? { account: stored.account } : {}
-              };
-              await deps.userTokenStore.set(
+              return await deps.userTokenStore.withRefresh(
                 userSubjectId,
                 provider,
-                refreshedTokens
-              );
-              return buildLease(
-                refreshed.accessToken,
-                getLeaseExpiry(refreshed.expiresAt),
-                input.reason
+                async () => {
+                  const latest = await deps.userTokenStore.get(
+                    userSubjectId,
+                    provider
+                  );
+                  if (latest && !hasRequiredOAuthScope(latest.scope, oauth.scope)) {
+                    throw new CredentialUnavailableError(
+                      provider,
+                      `Your ${provider} connection needs to be reauthorized.`
+                    );
+                  }
+                  if (!shouldRefreshStoredToken(latest) && canUseStoredToken(latest)) {
+                    return buildLease(
+                      latest.accessToken,
+                      getLeaseExpiry(latest.expiresAt),
+                      input.reason
+                    );
+                  }
+                  if (!latest) {
+                    throw new CredentialUnavailableError(
+                      provider,
+                      `No ${provider} credentials available.`
+                    );
+                  }
+                  const refreshed = await refreshAccessToken(
+                    latest.refreshToken,
+                    oauth,
+                    latest.scope ?? oauth.scope
+                  );
+                  if (!hasRequiredOAuthScope(refreshed.scope, oauth.scope)) {
+                    throw new CredentialUnavailableError(
+                      provider,
+                      `Your ${provider} connection needs to be reauthorized.`
+                    );
+                  }
+                  const refreshedTokens = {
+                    ...latest.refreshTokenExpiresAt ? { refreshTokenExpiresAt: latest.refreshTokenExpiresAt } : {},
+                    ...refreshed,
+                    ...latest.account ? { account: latest.account } : {}
+                  };
+                  await deps.userTokenStore.set(
+                    userSubjectId,
+                    provider,
+                    refreshedTokens
+                  );
+                  return buildLease(
+                    refreshed.accessToken,
+                    getLeaseExpiry(refreshed.expiresAt),
+                    input.reason
+                  );
+                }
               );
             } catch (error) {
               if (error instanceof CredentialUnavailableError) {
@@ -1483,7 +1540,7 @@ function createOAuthBearerBroker(manifest, credentials, deps) {
               throw error;
             }
           }
-          if (stored.expiresAt === void 0 || stored.expiresAt > Date.now()) {
+          if (canUseStoredToken(stored)) {
             return buildLease(
               stored.accessToken,
               getLeaseExpiry(stored.expiresAt),

package/dist/{chunk-JEELK46E.js → chunk-ZQB37HUX.js}

@@ -1,22 +1,22 @@
-import {
-  normalizeSlackConversationId
-} from "./chunk-62FUNJYS.js";
 import {
   getStateAdapter
-} from "./chunk-ZNNTSPNF.js";
+} from "./chunk-Y5OFBCBZ.js";
+import {
+  normalizeSlackConversationId
+} from "./chunk-Q6XFTRV5.js";
 import {
   parseSlackThreadId
-} from "./chunk-FCZO7LAR.js";
+} from "./chunk-T77LUIX3.js";
 import {
   parseStoredSlackRequester
-} from "./chunk-EIYL7I4S.js";
+} from "./chunk-VALUBQ7R.js";
 import {
   isRecord,
   toOptionalNumber
-} from "./chunk-OK4KKR7B.js";
+} from "./chunk-EJN6G5A2.js";
 import {
-  sentry_exports
-} from "./chunk-SJHUF3DP.js";
+  getClient
+} from "./chunk-ST6YNAXG.js";
 
 // src/handlers/health.ts
 function GET() {
@@ -44,7 +44,7 @@ function buildSentryWebBaseUrl(dsn) {
   return `${dsn.protocol}://${dsn.host}${port}${path}`;
 }
 function buildSentryConversationUrl(conversationId) {
-  const client = sentry_exports.getClient();
+  const client = getClient();
   const dsn = client?.getDsn();
   if (!dsn?.host || !dsn.projectId) {
     return void 0;
@@ -63,7 +63,7 @@ function buildSentryConversationUrl(conversationId) {
   return `${buildSentryWebBaseUrl(dsn)}/organizations/${orgSlug}/${path}`;
 }
 function buildSentryTraceUrl(traceId) {
-  const client = sentry_exports.getClient();
+  const client = getClient();
   const dsn = client?.getDsn();
   if (!dsn?.host || !dsn.projectId) {
     return void 0;

package/dist/cli/chat.js

@@ -1,7 +1,7 @@
 import {
   loadAppPluginSet
 } from "../chunk-Y2CM7HXH.js";
-import "../chunk-2KG3PWR4.js";
+import "../chunk-MLKGABMK.js";
 
 // src/cli/chat.ts
 import {
@@ -75,6 +75,29 @@ async function reportStatus(io, status) {
     throw new ChatOutputError(error);
   }
 }
+function formatToolPayload(payload) {
+  if (payload && typeof payload === "object" && !Array.isArray(payload) && Object.keys(payload).length === 0) {
+    return "";
+  }
+  const rendered = JSON.stringify(payload);
+  if (rendered.length <= 500) {
+    return ` ${rendered}`;
+  }
+  return ` ${rendered.slice(0, 497)}...`;
+}
+async function reportToolResult(io, result) {
+  if (!result.ok) {
+    await reportStatus(
+      io,
+      `tool: ${result.toolName} error ${result.error ?? "Tool execution failed"}`
+    );
+    return;
+  }
+  await reportStatus(
+    io,
+    `tool: ${result.toolName} ok${formatToolPayload(result.result ?? {})}`
+  );
+}
 function writeStream(stream, text) {
   return new Promise((resolve, reject) => {
     stream.write(text, (error) => {
@@ -98,7 +121,7 @@ async function loadLocalPluginSet() {
     async (moduleRef) => localPluginLoader.import(moduleRef.importPath)
   );
 }
-async function configureLocalChatPlugins() {
+async function configureLocalChatPlugins(pluginSet) {
   const [
     pluginsModule,
     agentHooksModule,
@@ -106,29 +129,29 @@ async function configureLocalChatPlugins() {
     validationModule,
     databaseModule
   ] = await Promise.all([
-    import("../plugins-OMJKLRJ2.js"),
-    import("../agent-hooks-2HEB4C3Q.js"),
-    import("../registry-NLZFIW23.js"),
-    import("../validation-VMCPP3YO.js"),
-    import("../db-A3ILH67H.js")
+    import("../plugins-PZMDS7AT.js"),
+    import("../agent-hooks-ZOE7RIED.js"),
+    import("../registry-OIPAJU2O.js"),
+    import("../validation-SLA6IGF7.js"),
+    import("../db-7A7PFRGL.js")
   ]);
-  const pluginSet = await loadLocalPluginSet();
-  const plugins = pluginsModule.pluginHookRegistrationsFromPluginSet(pluginSet);
-  const pluginConfig = pluginSet ? pluginsModule.pluginCatalogConfigFromPluginSet(pluginSet) : pluginsModule.pluginCatalogConfigFromEnv();
-  const shouldValidatePluginCatalog = Boolean(pluginConfig) || Boolean(pluginSet?.registrations.length);
+  const resolvedPluginSet = pluginSet === void 0 ? await loadLocalPluginSet() : pluginSet ?? void 0;
+  const plugins = pluginsModule.pluginRuntimeRegistrationsFromPluginSet(resolvedPluginSet);
+  const pluginConfig = resolvedPluginSet ? pluginsModule.pluginCatalogConfigFromPluginSet(resolvedPluginSet) : pluginsModule.pluginCatalogConfigFromEnv();
+  const shouldValidatePluginCatalog = Boolean(pluginConfig) || Boolean(resolvedPluginSet?.registrations.length);
   agentHooksModule.validatePlugins(plugins);
   const previousPluginCatalogConfig = registryModule.setPluginCatalogConfig(pluginConfig);
   try {
     if (shouldValidatePluginCatalog) {
       registryModule.getPluginCatalogSignature();
       validationModule.validatePluginRegistrations(
-        pluginSet?.registrations ?? []
+        resolvedPluginSet?.registrations ?? []
       );
       validationModule.validatePluginEgressCredentialHooks(
-        pluginSet?.registrations ?? []
+        resolvedPluginSet?.registrations ?? []
       );
     }
-    databaseModule.validatePluginDatabaseRequirements(plugins);
+    databaseModule.getDb();
     agentHooksModule.setPlugins(plugins);
   } catch (error) {
     registryModule.setPluginCatalogConfig(previousPluginCatalogConfig);
@@ -166,11 +189,11 @@ function newRunConversationId() {
   }
   return conversationId;
 }
-async function runPrompt(options, io) {
+async function runPrompt(options, io, pluginSet) {
   defaultStateAdapterForLocalChat();
-  await configureLocalChatPlugins();
+  await configureLocalChatPlugins(pluginSet);
   const conversationId = newRunConversationId();
-  const { runLocalAgentTurn } = await import("../runner-LUQZ5G67.js");
+  const { runLocalAgentTurn } = await import("../runner-KPLNHDCV.js");
   const result = await runLocalAgentTurn(
     {
       conversationId,
@@ -182,16 +205,19 @@ async function runPrompt(options, io) {
       },
       onStatus: async (status) => {
         await reportStatus(io, status);
+      },
+      onToolResult: async (result2) => {
+        await reportToolResult(io, result2);
       }
     }
   );
   return result.outcome === "success" ? 0 : 1;
 }
-async function runInteractive(io) {
+async function runInteractive(io, pluginSet) {
   defaultStateAdapterForLocalChat();
-  await configureLocalChatPlugins();
+  await configureLocalChatPlugins(pluginSet);
   const conversationId = newRunConversationId();
-  const { runLocalAgentTurn } = await import("../runner-LUQZ5G67.js");
+  const { runLocalAgentTurn } = await import("../runner-KPLNHDCV.js");
   const rl = readline.createInterface({
     input: io.input,
     output: io.output,
@@ -218,6 +244,9 @@ async function runInteractive(io) {
             },
             onStatus: async (status) => {
               await reportStatus(io, status);
+            },
+            onToolResult: async (result) => {
+              await reportToolResult(io, result);
             }
           }
         );
@@ -232,7 +261,7 @@ async function runInteractive(io) {
     rl.close();
   }
 }
-async function runChat(argv, io = DEFAULT_IO) {
+async function runChat(argv, io = DEFAULT_IO, deps = {}) {
   const options = parseChatArgs(argv);
   if (!options) {
     await io.error(CHAT_USAGE);
@@ -240,9 +269,9 @@ async function runChat(argv, io = DEFAULT_IO) {
   }
   try {
     if (options.mode === "prompt") {
-      return await runPrompt(options, io);
+      return await runPrompt(options, io, deps.pluginSet);
     }
-    await runInteractive(io);
+    await runInteractive(io, deps.pluginSet);
     return 0;
   } catch (error) {
     await io.error(errorMessage(error));

package/dist/cli/check.js

@@ -1,20 +1,20 @@
 import {
   parseSkillFile
-} from "../chunk-OJODNL2P.js";
+} from "../chunk-4SCWV7TJ.js";
 import {
   parseInlinePluginManifest,
   parsePluginManifest
-} from "../chunk-2RWFUS5F.js";
+} from "../chunk-ZLMBNBUG.js";
+import "../chunk-VALUBQ7R.js";
 import "../chunk-Q3XNY442.js";
-import "../chunk-EIYL7I4S.js";
-import "../chunk-MCMROINU.js";
-import "../chunk-OK4KKR7B.js";
+import "../chunk-EJN6G5A2.js";
 import {
   JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE,
   JUNIOR_HEARTBEAT_ROUTE,
   LEGACY_JUNIOR_CONVERSATION_WORK_FUNCTION
-} from "../chunk-SJHUF3DP.js";
-import "../chunk-2KG3PWR4.js";
+} from "../chunk-OJ53FYVG.js";
+import "../chunk-ST6YNAXG.js";
+import "../chunk-MLKGABMK.js";
 
 // src/cli/check.ts
 import fs from "fs/promises";

package/dist/cli/env.js

@@ -1,56 +1,7 @@
-import "../chunk-2KG3PWR4.js";
-
-// src/cli/env.ts
-import fs from "fs";
-import path from "path";
-function envFileNames(nodeEnv) {
-  return [
-    `.env.${nodeEnv}.local`,
-    ...nodeEnv === "test" ? [] : [".env.local"],
-    `.env.${nodeEnv}`,
-    ".env"
-  ];
-}
-function hasEnvRootMarker(dir) {
-  return fs.existsSync(path.join(dir, "package.json")) || fs.existsSync(path.join(dir, "pnpm-workspace.yaml"));
-}
-function resolveCliEnvRoots(cwd) {
-  const roots = [];
-  const seen = /* @__PURE__ */ new Set();
-  const addRoot = (candidate) => {
-    const resolved = path.resolve(candidate);
-    if (seen.has(resolved)) {
-      return;
-    }
-    seen.add(resolved);
-    roots.push(resolved);
-  };
-  let current = path.resolve(cwd);
-  addRoot(current);
-  while (true) {
-    if (hasEnvRootMarker(current)) {
-      addRoot(current);
-    }
-    const parent = path.dirname(current);
-    if (parent === current) {
-      break;
-    }
-    current = parent;
-  }
-  return roots;
-}
-function loadCliEnvFiles(cwd = process.cwd()) {
-  const nodeEnv = process.env.NODE_ENV ?? "development";
-  for (const root of resolveCliEnvRoots(cwd)) {
-    for (const envFile of envFileNames(nodeEnv)) {
-      const absolutePath = path.join(root, envFile);
-      if (!fs.existsSync(absolutePath)) {
-        continue;
-      }
-      process.loadEnvFile(absolutePath);
-    }
-  }
-}
+import {
+  loadCliEnvFiles
+} from "../chunk-RV5RYIJW.js";
+import "../chunk-MLKGABMK.js";
 export {
   loadCliEnvFiles
 };

package/dist/cli/init.js

@@ -1,7 +1,7 @@
 import {
   juniorVercelConfig
 } from "../chunk-Y7X25LFY.js";
-import "../chunk-2KG3PWR4.js";
+import "../chunk-MLKGABMK.js";
 
 // src/cli/init.ts
 import fs from "fs";
@@ -35,8 +35,10 @@ function writePluginsFile(targetDir) {
   fs.writeFileSync(
     path.join(targetDir, "plugins.ts"),
     `import { defineJuniorPlugins } from "@sentry/junior";
+import { createMemoryPlugin } from "@sentry/junior-memory";
 
 export const plugins = defineJuniorPlugins([
+  createMemoryPlugin(),
   "@sentry/junior-maintenance",
 ]);
 `
@@ -144,6 +146,7 @@ async function runInit(dir, log = console.log) {
     },
     dependencies: {
       "@sentry/junior": "latest",
+      "@sentry/junior-memory": "latest",
       "@sentry/junior-maintenance": "latest",
       hono: "^4.12.0"
     },
@@ -205,6 +208,8 @@ JUNIOR_BOT_NAME=
 JUNIOR_SLASH_COMMAND=
 AI_MODEL=
 AI_FAST_MODEL=
+AI_MEMORY_MODEL=
+AI_EMBEDDING_MODEL=
 AI_VISION_MODEL=
 AI_WEB_SEARCH_MODEL=
 REDIS_URL=

package/dist/cli/main.js

@@ -0,0 +1,84 @@
+import {
+  loadCliEnvFiles
+} from "../chunk-RV5RYIJW.js";
+import {
+  runCli
+} from "../chunk-4UO6FK4G.js";
+import "../chunk-MLKGABMK.js";
+
+// src/cli/main.ts
+import { pathToFileURL } from "url";
+var SENTRY_FLUSH_TIMEOUT_MS = 2e3;
+async function flushSentry() {
+  const mod = await import("../sentry-4CP5NNQ5.js");
+  await mod.flush(SENTRY_FLUSH_TIMEOUT_MS);
+}
+async function initSentry() {
+  const mod = await import("../instrumentation.js");
+  mod.initSentry();
+}
+async function runInit(dir) {
+  const mod = await import("./init.js");
+  await mod.runInit(dir);
+}
+async function runSnapshotCreate() {
+  const mod = await import("./snapshot-warmup.js");
+  await mod.runSnapshotCreate();
+}
+async function runCheck(dir) {
+  const mod = await import("./check.js");
+  await mod.runCheck(dir);
+}
+async function runUpgrade(pluginSet) {
+  const mod = await import("./upgrade.js");
+  await mod.runUpgrade(void 0, { pluginSet });
+}
+async function runChat(argv, pluginSet) {
+  const mod = await import("./chat.js");
+  return await mod.runChat(argv, void 0, { pluginSet });
+}
+function topLevelCommand(argv) {
+  const normalized = argv[0] === "--" ? argv.slice(1) : argv;
+  return normalized[0];
+}
+async function runMain(argv, options = {}) {
+  loadCliEnvFiles();
+  const instrument = options.instrument ?? true;
+  if (instrument) {
+    await initSentry();
+  }
+  const command = topLevelCommand(argv);
+  const cliPluginsModule = command && command !== "init" ? await import("./plugins.js") : void 0;
+  const pluginSet = cliPluginsModule ? await cliPluginsModule.loadCliPluginSet() ?? null : void 0;
+  const pluginCommands = cliPluginsModule ? await cliPluginsModule.loadCliPluginCommands(pluginSet) : void 0;
+  const exitCode = await runCli(argv, {
+    runChat: async (chatArgv) => await runChat(chatArgv, pluginSet),
+    runInit,
+    runSnapshotCreate,
+    runCheck,
+    runUpgrade: async () => await runUpgrade(pluginSet),
+    ...pluginCommands ? { runPluginCommand: pluginCommands.run } : {}
+  });
+  if (instrument) {
+    await flushSentry();
+  }
+  process.exit(exitCode);
+}
+function isDirectCliEntry() {
+  return Boolean(
+    process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href
+  );
+}
+if (isDirectCliEntry()) {
+  runMain(process.argv.slice(2)).catch((error) => {
+    void (async () => {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`junior command failed: ${message}`);
+      await flushSentry();
+      process.exit(1);
+    })();
+  });
+}
+export {
+  runMain
+};