@sentry/junior 0.74.1 → 0.75.0

package/dist/chunk-WBZ4M5N5.js

@@ -0,0 +1,59 @@
+import {
+  normalizeSlackConversationId
+} from "./chunk-62FUNJYS.js";
+import {
+  isSlackConversationId,
+  isSlackTeamId
+} from "./chunk-MCMROINU.js";
+
+// src/chat/destination.ts
+import {
+  destinationSchema
+} from "@sentry/junior-plugin-api";
+function createSlackDestination(input) {
+  const channelId = normalizeSlackConversationId(input.channelId);
+  const teamId = input.teamId?.trim();
+  if (!channelId || !teamId) {
+    return void 0;
+  }
+  if (!isSlackConversationId(channelId) || !isSlackTeamId(teamId)) {
+    return void 0;
+  }
+  return { platform: "slack", teamId, channelId };
+}
+function parseDestination(value) {
+  const parsed = destinationSchema.safeParse(value);
+  return parsed.success ? parsed.data : void 0;
+}
+function requireSlackDestination(destination, action) {
+  if (destination?.platform === "slack") {
+    return destination;
+  }
+  throw new Error(`${action} requires a Slack destination`);
+}
+function sameDestination(left, right) {
+  if (left.platform !== right.platform) {
+    return false;
+  }
+  if (left.platform === "local" && right.platform === "local") {
+    return left.conversationId === right.conversationId;
+  }
+  if (left.platform === "slack" && right.platform === "slack") {
+    return left.teamId === right.teamId && left.channelId === right.channelId;
+  }
+  return false;
+}
+function destinationKey(destination) {
+  if (destination.platform === "local") {
+    return destination.conversationId;
+  }
+  return `slack:${destination.teamId}:${destination.channelId}`;
+}
+
+export {
+  createSlackDestination,
+  parseDestination,
+  requireSlackDestination,
+  sameDestination,
+  destinationKey
+};

package/dist/{chunk-6UP2Z2RZ.js → chunk-XJHDZUGD.js}

@@ -1,19 +1,19 @@
 import {
   SANDBOX_WORKSPACE_ROOT
 } from "./chunk-G3E7SCME.js";
-import {
-  getPluginRuntimeDependencies,
-  getPluginRuntimePostinstall
-} from "./chunk-7Q5YOUUT.js";
 import {
   getStateAdapter
-} from "./chunk-F6HWCPOC.js";
+} from "./chunk-ZNNTSPNF.js";
 import {
   toOptionalTrimmed
-} from "./chunk-GM7HTXYC.js";
+} from "./chunk-FCZO7LAR.js";
+import {
+  getPluginRuntimeDependencies,
+  getPluginRuntimePostinstall
+} from "./chunk-2RWFUS5F.js";
 import {
   withSpan
-} from "./chunk-3BYAPS6B.js";
+} from "./chunk-OK4KKR7B.js";
 
 // src/chat/sandbox/runtime-dependency-snapshots.ts
 import { createHash } from "crypto";

package/dist/chunk-Y2CM7HXH.js

@@ -0,0 +1,111 @@
+// src/plugin-module.ts
+import { statSync } from "fs";
+import { createRequire } from "module";
+import path from "path";
+import { pathToFileURL } from "url";
+var PLUGIN_MODULE_EXTENSIONS = [
+  "",
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".mjs",
+  ".js",
+  ".cjs"
+];
+function resolveRelativePluginModule(cwd, specifier) {
+  const basePath = path.resolve(cwd, specifier);
+  for (const extension of PLUGIN_MODULE_EXTENSIONS) {
+    const candidate = `${basePath}${extension}`;
+    try {
+      if (statSync(candidate).isFile()) {
+        return candidate;
+      }
+    } catch {
+    }
+  }
+  for (const extension of PLUGIN_MODULE_EXTENSIONS) {
+    const candidate = path.join(basePath, `index${extension}`);
+    try {
+      if (statSync(candidate).isFile()) {
+        return candidate;
+      }
+    } catch {
+    }
+  }
+  throw new Error(`Plugin module "${specifier}" could not be resolved`);
+}
+function resolvePluginModule(cwd, input) {
+  const moduleSpecifier = typeof input === "string" ? input : input.module;
+  const exportName = typeof input === "string" ? "plugins" : input.exportName ?? "plugins";
+  if (!moduleSpecifier.trim()) {
+    throw new Error("Plugin module specifier must not be empty");
+  }
+  if (moduleSpecifier.startsWith(".") || path.isAbsolute(moduleSpecifier)) {
+    const resolvedPath2 = resolveRelativePluginModule(cwd, moduleSpecifier);
+    return {
+      exportName,
+      importPath: resolvedPath2,
+      importUrl: pathToFileURL(resolvedPath2).href,
+      kind: "file",
+      sourceSpecifier: moduleSpecifier
+    };
+  }
+  const requireFromApp = createRequire(path.join(cwd, "package.json"));
+  const resolvedPath = requireFromApp.resolve(moduleSpecifier);
+  return {
+    exportName,
+    importPath: resolvedPath,
+    importUrl: pathToFileURL(resolvedPath).href,
+    kind: "package",
+    sourceSpecifier: moduleSpecifier
+  };
+}
+function assertPluginSet(value, source) {
+  if (!value || typeof value !== "object" || !Array.isArray(value.packageNames) || !Array.isArray(value.registrations)) {
+    throw new Error(
+      `Plugin module ${source} must export a defineJuniorPlugins(...) set`
+    );
+  }
+  const pluginSet = value;
+  const invalidPackageName = pluginSet.packageNames?.find(
+    (packageName) => typeof packageName !== "string"
+  );
+  if (invalidPackageName !== void 0) {
+    throw new Error(`Plugin module ${source} must export string package names`);
+  }
+  const invalidRegistration = pluginSet.registrations?.find(
+    (registration) => !registration || typeof registration !== "object" || !("manifest" in registration) || !registration.manifest || typeof registration.manifest !== "object" || !("name" in registration.manifest) || typeof registration.manifest.name !== "string"
+  );
+  if (invalidRegistration) {
+    throw new Error(
+      `Plugin module ${source} must export plugin registrations with manifest names`
+    );
+  }
+  return value;
+}
+async function loadPluginSetFromModule(moduleRef, importModule = async (ref) => await import(ref.importUrl)) {
+  const mod = await importModule(moduleRef);
+  const value = moduleRef.exportName === "default" ? mod.default : mod[moduleRef.exportName];
+  return assertPluginSet(
+    value,
+    `${moduleRef.importUrl}#${moduleRef.exportName}`
+  );
+}
+async function loadAppPluginSet(cwd, importModule) {
+  let pluginModule;
+  try {
+    pluginModule = resolvePluginModule(cwd, "./plugins");
+  } catch (error) {
+    if (error instanceof Error && error.message === 'Plugin module "./plugins" could not be resolved') {
+      return void 0;
+    }
+    throw error;
+  }
+  return await loadPluginSetFromModule(pluginModule, importModule);
+}
+
+export {
+  resolvePluginModule,
+  loadPluginSetFromModule,
+  loadAppPluginSet
+};

package/dist/{chunk-F6HWCPOC.js → chunk-ZNNTSPNF.js}

@@ -1,6 +1,6 @@
 import {
   getChatConfig
-} from "./chunk-GM7HTXYC.js";
+} from "./chunk-FCZO7LAR.js";
 
 // src/chat/state/adapter.ts
 import { createMemoryState } from "@chat-adapter/state-memory";

package/dist/cli/chat.js

@@ -1,3 +1,6 @@
+import {
+  loadAppPluginSet
+} from "../chunk-Y2CM7HXH.js";
 import "../chunk-2KG3PWR4.js";
 
 // src/cli/chat.ts
@@ -8,6 +11,7 @@ import {
 } from "process";
 import { randomUUID } from "crypto";
 import * as readline from "readline/promises";
+import { createJiti } from "jiti";
 
 // src/chat/local/conversation.ts
 import { createHash } from "crypto";
@@ -40,6 +44,7 @@ var DEFAULT_IO = {
   output: defaultStdout,
   write: (text) => writeStream(defaultStdout, text)
 };
+var localPluginLoader = createJiti(import.meta.url, { moduleCache: false });
 var ChatOutputError = class extends Error {
   constructor(error) {
     super(errorMessage(error));
@@ -87,6 +92,49 @@ function defaultStateAdapterForLocalChat() {
   }
   process.env.JUNIOR_STATE_ADAPTER = "memory";
 }
+async function loadLocalPluginSet() {
+  return await loadAppPluginSet(
+    process.cwd(),
+    async (moduleRef) => localPluginLoader.import(moduleRef.importPath)
+  );
+}
+async function configureLocalChatPlugins() {
+  const [
+    pluginsModule,
+    agentHooksModule,
+    registryModule,
+    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")
+  ]);
+  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);
+  agentHooksModule.validatePlugins(plugins);
+  const previousPluginCatalogConfig = registryModule.setPluginCatalogConfig(pluginConfig);
+  try {
+    if (shouldValidatePluginCatalog) {
+      registryModule.getPluginCatalogSignature();
+      validationModule.validatePluginRegistrations(
+        pluginSet?.registrations ?? []
+      );
+      validationModule.validatePluginEgressCredentialHooks(
+        pluginSet?.registrations ?? []
+      );
+    }
+    databaseModule.validatePluginDatabaseRequirements(plugins);
+    agentHooksModule.setPlugins(plugins);
+  } catch (error) {
+    registryModule.setPluginCatalogConfig(previousPluginCatalogConfig);
+    throw error;
+  }
+}
 function parseChatArgs(argv) {
   if (argv.length === 0) {
     return { mode: "interactive" };
@@ -120,8 +168,9 @@ function newRunConversationId() {
 }
 async function runPrompt(options, io) {
   defaultStateAdapterForLocalChat();
+  await configureLocalChatPlugins();
   const conversationId = newRunConversationId();
-  const { runLocalAgentTurn } = await import("../runner-27NP2TEO.js");
+  const { runLocalAgentTurn } = await import("../runner-LUQZ5G67.js");
   const result = await runLocalAgentTurn(
     {
       conversationId,
@@ -140,8 +189,9 @@ async function runPrompt(options, io) {
 }
 async function runInteractive(io) {
   defaultStateAdapterForLocalChat();
+  await configureLocalChatPlugins();
   const conversationId = newRunConversationId();
-  const { runLocalAgentTurn } = await import("../runner-27NP2TEO.js");
+  const { runLocalAgentTurn } = await import("../runner-LUQZ5G67.js");
   const rl = readline.createInterface({
     input: io.input,
     output: io.output,

package/dist/cli/check.js

@@ -1,13 +1,14 @@
 import {
   parseSkillFile
-} from "../chunk-OR6NQJ5E.js";
+} from "../chunk-OJODNL2P.js";
 import {
   parseInlinePluginManifest,
   parsePluginManifest
-} from "../chunk-7Q5YOUUT.js";
-import "../chunk-KVZL5NZS.js";
-import "../chunk-CYUI7JU5.js";
-import "../chunk-3BYAPS6B.js";
+} from "../chunk-2RWFUS5F.js";
+import "../chunk-Q3XNY442.js";
+import "../chunk-EIYL7I4S.js";
+import "../chunk-MCMROINU.js";
+import "../chunk-OK4KKR7B.js";
 import {
   JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE,
   JUNIOR_HEARTBEAT_ROUTE,

package/dist/cli/snapshot-warmup.js

@@ -1,19 +1,20 @@
 import {
   resolveRuntimeDependencySnapshot
-} from "../chunk-6UP2Z2RZ.js";
+} from "../chunk-XJHDZUGD.js";
 import "../chunk-G3E7SCME.js";
+import {
+  disconnectStateAdapter
+} from "../chunk-ZNNTSPNF.js";
+import "../chunk-FCZO7LAR.js";
 import {
   getPluginProviders,
   getPluginRuntimeDependencies,
   getPluginRuntimePostinstall
-} from "../chunk-7Q5YOUUT.js";
-import "../chunk-KVZL5NZS.js";
-import {
-  disconnectStateAdapter
-} from "../chunk-F6HWCPOC.js";
-import "../chunk-GM7HTXYC.js";
-import "../chunk-CYUI7JU5.js";
-import "../chunk-3BYAPS6B.js";
+} from "../chunk-2RWFUS5F.js";
+import "../chunk-Q3XNY442.js";
+import "../chunk-EIYL7I4S.js";
+import "../chunk-MCMROINU.js";
+import "../chunk-OK4KKR7B.js";
 import "../chunk-SJHUF3DP.js";
 import "../chunk-2KG3PWR4.js";
 

package/dist/cli/upgrade.js

@@ -1,34 +1,63 @@
 import {
   coerceThreadConversationState
-} from "../chunk-M4FLLXXD.js";
+} from "../chunk-74HO27II.js";
+import {
+  defineJuniorPlugins,
+  pluginCatalogConfigFromEnv,
+  pluginCatalogConfigFromPluginSet,
+  pluginHookRegistrationsFromPluginSet
+} from "../chunk-EE6PJWY4.js";
 import {
   JUNIOR_THREAD_STATE_TTL_MS,
-  createNeonJuniorSqlExecutor,
   createSqlStore,
   createStateConversationStore,
   getConversation,
   requestConversationWork
-} from "../chunk-JL2SLRAT.js";
+} from "../chunk-UJ7OTHPO.js";
 import {
   parseDestination,
   sameDestination
-} from "../chunk-YRDS7VKO.js";
+} from "../chunk-WBZ4M5N5.js";
+import {
+  createPluginLogger,
+  createPluginState
+} from "../chunk-BNJIEFQC.js";
+import "../chunk-62FUNJYS.js";
+import {
+  createJuniorSqlExecutor,
+  createPluginDbForExecutor,
+  getPluginDbForRegistration,
+  migratePluginSchemas,
+  readPluginMigrations
+} from "../chunk-D7NFH5GD.js";
+import {
+  loadAppPluginSet
+} from "../chunk-Y2CM7HXH.js";
 import {
   disconnectStateAdapter,
   getConnectedStateContext
-} from "../chunk-F6HWCPOC.js";
+} from "../chunk-ZNNTSPNF.js";
 import {
   getChatConfig
-} from "../chunk-GM7HTXYC.js";
-import "../chunk-CYUI7JU5.js";
+} from "../chunk-FCZO7LAR.js";
+import {
+  getPluginMigrationRoots,
+  setPluginCatalogConfig
+} from "../chunk-2RWFUS5F.js";
+import "../chunk-Q3XNY442.js";
+import "../chunk-EIYL7I4S.js";
+import "../chunk-MCMROINU.js";
 import {
   isRecord,
   toOptionalNumber,
   toOptionalString
-} from "../chunk-3BYAPS6B.js";
+} from "../chunk-OK4KKR7B.js";
 import "../chunk-SJHUF3DP.js";
 import "../chunk-2KG3PWR4.js";
 
+// src/cli/upgrade.ts
+import { createJiti } from "jiti";
+
 // src/chat/conversations/sql/backfill.ts
 async function backfillToSql(args) {
   const limit = Math.max(0, args.limit ?? 500);
@@ -60,8 +89,9 @@ async function migrateConversationsToSql(context, options = {}) {
   let closeTarget;
   if (!target) {
     const databaseUrl = requireConversationSqlDatabaseUrl(context);
-    const executor = createNeonJuniorSqlExecutor({
-      connectionString: databaseUrl
+    const executor = createJuniorSqlExecutor({
+      connectionString: databaseUrl,
+      driver: context.sqlDriver ?? getChatConfig().sql.driver
     });
     target = createSqlStore(executor);
     closeTarget = () => executor.close();
@@ -88,6 +118,183 @@ var sqlConversationMigration = {
   run: migrateConversationsToSql
 };
 
+// src/cli/upgrade/migrations/upgrade-plugins.ts
+function unique(values) {
+  return [...new Set(values)];
+}
+function baseCatalogConfig(context) {
+  return context.pluginCatalogConfig ?? (context.pluginSet ? pluginCatalogConfigFromPluginSet(context.pluginSet) : pluginCatalogConfigFromEnv());
+}
+function inlinePluginName(definition) {
+  return definition.manifest.name;
+}
+function mergeInlineManifests(left, right) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const definition of [...left ?? [], ...right ?? []]) {
+    merged.set(inlinePluginName(definition), definition);
+  }
+  return merged.size > 0 ? [...merged.values()] : void 0;
+}
+function mergeCatalogConfig(base, added) {
+  if (!base) {
+    return added;
+  }
+  if (!added) {
+    return base;
+  }
+  const inlineManifests = mergeInlineManifests(
+    base.inlineManifests,
+    added.inlineManifests
+  );
+  const packages = unique([
+    ...base.packages ?? [],
+    ...added.packages ?? []
+  ]);
+  const manifests = base.manifests || added.manifests ? { ...base.manifests, ...added.manifests } : void 0;
+  return {
+    ...inlineManifests ? { inlineManifests } : {},
+    ...packages.length > 0 ? { packages } : {},
+    ...manifests ? { manifests } : {}
+  };
+}
+function packageNamesFromContext(context, catalog) {
+  return unique([
+    ...context.pluginSet?.packageNames ?? [],
+    ...catalog?.packages ?? []
+  ]);
+}
+async function resolveUpgradePlugins(context) {
+  const catalog = baseCatalogConfig(context);
+  const packageNames = packageNamesFromContext(context, catalog);
+  const registrations = context.pluginSet?.registrations ?? [];
+  const manifests = context.pluginSet?.manifests || catalog?.manifests ? {
+    ...catalog?.manifests,
+    ...context.pluginSet?.manifests
+  } : void 0;
+  const pluginSet = packageNames.length > 0 || registrations.length > 0 || context.pluginSet ? defineJuniorPlugins(
+    [...packageNames, ...registrations],
+    manifests ? { manifests } : {}
+  ) : void 0;
+  return {
+    pluginCatalogConfig: mergeCatalogConfig(
+      catalog,
+      pluginCatalogConfigFromPluginSet(pluginSet)
+    ),
+    ...pluginSet ? { pluginSet } : {}
+  };
+}
+
+// src/cli/upgrade/migrations/plugin-storage.ts
+function emptyResult() {
+  return {
+    existing: 0,
+    migrated: 0,
+    missing: 0,
+    scanned: 0
+  };
+}
+function addResult(left, right) {
+  return {
+    existing: left.existing + right.existing,
+    migrated: left.migrated + right.migrated,
+    missing: left.missing + right.missing,
+    scanned: left.scanned + right.scanned,
+    ...left.skipped !== void 0 || right.skipped !== void 0 ? { skipped: (left.skipped ?? 0) + (right.skipped ?? 0) } : {}
+  };
+}
+function dbForPlugin(context, plugin, sqlUrlDb) {
+  if (!plugin.database) {
+    return void 0;
+  }
+  return context.pluginDb ?? sqlUrlDb ?? getPluginDbForRegistration(plugin);
+}
+async function runPluginStorageMigrations(context) {
+  const { pluginCatalogConfig, pluginSet } = await resolveUpgradePlugins(context);
+  if (!pluginSet) {
+    return emptyResult();
+  }
+  const previousConfig = setPluginCatalogConfig(pluginCatalogConfig);
+  const ownedExecutor = context.pluginDb || !context.sqlDatabaseUrl ? void 0 : createJuniorSqlExecutor({
+    connectionString: context.sqlDatabaseUrl,
+    driver: context.sqlDriver ?? getChatConfig().sql.driver
+  });
+  const sqlUrlDb = ownedExecutor ? createPluginDbForExecutor(ownedExecutor) : void 0;
+  try {
+    let result = emptyResult();
+    const plugins = pluginHookRegistrationsFromPluginSet(pluginSet).filter((plugin) => plugin.hooks?.migrateStorage).sort(
+      (left, right) => left.manifest.name.localeCompare(right.manifest.name)
+    );
+    for (const plugin of plugins) {
+      const pluginName = plugin.manifest.name;
+      const hook = plugin.hooks?.migrateStorage;
+      if (!hook) {
+        continue;
+      }
+      const db = dbForPlugin(context, plugin, sqlUrlDb);
+      if (!db) {
+        throw new Error(
+          `Plugin "${pluginName}" storage migration requires database access`
+        );
+      }
+      const pluginResult = await hook({
+        db,
+        log: createPluginLogger(pluginName),
+        plugin: { name: pluginName },
+        state: createPluginState(pluginName, context.stateAdapter)
+      });
+      if (pluginResult) {
+        result = addResult(result, pluginResult);
+      }
+    }
+    return result;
+  } finally {
+    setPluginCatalogConfig(previousConfig);
+    await ownedExecutor?.close();
+  }
+}
+var pluginStorageMigration = {
+  name: "run-plugin-storage-migrations",
+  run: runPluginStorageMigrations
+};
+
+// src/cli/upgrade/migrations/plugin-sql.ts
+var REQUIRED_SQL_DATABASE_URL_MESSAGE2 = "Junior SQL database URL is required for plugin schema migration. Set JUNIOR_DATABASE_URL or DATABASE_URL.";
+function requirePluginSqlDatabaseUrl(context) {
+  const databaseUrl = context.sqlDatabaseUrl ?? getChatConfig().sql.databaseUrl;
+  if (!databaseUrl) {
+    throw new Error(REQUIRED_SQL_DATABASE_URL_MESSAGE2);
+  }
+  return databaseUrl;
+}
+async function migratePluginsToSql(context) {
+  const databaseUrl = requirePluginSqlDatabaseUrl(context);
+  const { pluginCatalogConfig } = await resolveUpgradePlugins(context);
+  const previousConfig = setPluginCatalogConfig(pluginCatalogConfig);
+  const executor = createJuniorSqlExecutor({
+    connectionString: databaseUrl,
+    driver: context.sqlDriver ?? getChatConfig().sql.driver
+  });
+  try {
+    const migrations = getPluginMigrationRoots().flatMap(
+      (root) => readPluginMigrations(root)
+    );
+    const result = await migratePluginSchemas(executor, migrations);
+    return {
+      existing: result.existing,
+      migrated: result.migrated,
+      missing: 0,
+      scanned: result.scanned
+    };
+  } finally {
+    setPluginCatalogConfig(previousConfig);
+    await executor.close();
+  }
+}
+var sqlPluginMigration = {
+  name: "migrate-plugin-sql",
+  run: migratePluginsToSql
+};
+
 // src/cli/upgrade/migrations/redis-conversation-state.ts
 var CONVERSATION_PREFIX = "junior:conversation";
 var CONVERSATION_SCHEMA_VERSION = 1;
@@ -624,10 +831,34 @@ var redisConversationStateMigration = {
 var DEFAULT_IO = {
   info: console.log
 };
+var localPluginLoader = createJiti(import.meta.url, { moduleCache: false });
 var MIGRATIONS = [
   redisConversationStateMigration,
-  sqlConversationMigration
+  sqlConversationMigration,
+  sqlPluginMigration,
+  pluginStorageMigration
 ];
+function isMissingVirtualConfig(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const code = error.code;
+  return (code === "ERR_PACKAGE_IMPORT_NOT_DEFINED" || code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND") && error.message.includes("#junior/config");
+}
+async function resolveUpgradePluginSet() {
+  try {
+    const mod = await import("#junior/config");
+    return mod.pluginSet;
+  } catch (error) {
+    if (!isMissingVirtualConfig(error)) {
+      throw error;
+    }
+  }
+  return await loadAppPluginSet(
+    process.cwd(),
+    async (moduleRef) => localPluginLoader.import(moduleRef.importPath)
+  );
+}
 function formatMigrationResult(result) {
   const fields = [
     `scanned=${result.scanned}`,
@@ -641,12 +872,14 @@ function formatMigrationResult(result) {
   return fields.join(" ");
 }
 async function runUpgradeMigrations(context) {
-  requireConversationSqlDatabaseUrl(context);
+  const plugins = await resolveUpgradePlugins(context);
+  const migrationContext = { ...context, ...plugins };
+  migrationContext.sqlDatabaseUrl ??= requireConversationSqlDatabaseUrl(migrationContext);
   const results = [];
   for (const migration of MIGRATIONS) {
-    context.io.info(`Running migration ${migration.name}...`);
-    const result = await migration.run(context);
-    context.io.info(
+    migrationContext.io.info(`Running migration ${migration.name}...`);
+    const result = await migration.run(migrationContext);
+    migrationContext.io.info(
       `Finished migration ${migration.name}: ${formatMigrationResult(result)}`
     );
     results.push(result);
@@ -656,14 +889,21 @@ async function runUpgradeMigrations(context) {
 async function runUpgrade(io = DEFAULT_IO) {
   try {
     const { redisStateAdapter, stateAdapter } = await getConnectedStateContext();
+    const pluginSet = await resolveUpgradePluginSet();
     io.info("Running Junior upgrade migrations...");
-    await runUpgradeMigrations({ io, redisStateAdapter, stateAdapter });
+    await runUpgradeMigrations({
+      io,
+      pluginSet,
+      redisStateAdapter,
+      stateAdapter
+    });
     io.info("Junior upgrade complete.");
   } finally {
     await disconnectStateAdapter();
   }
 }
 export {
+  resolveUpgradePluginSet,
   runUpgrade,
   runUpgradeMigrations
 };