@sentry/junior 0.75.0 → 0.76.0

package/dist/cli/plugins.js

@@ -0,0 +1,244 @@
+import {
+  validatePluginEgressCredentialHooks,
+  validatePluginRegistrations
+} from "../chunk-XBBC6W45.js";
+import {
+  pluginCatalogConfigFromPluginSet,
+  pluginCliRegistrationsFromPluginSet,
+  pluginRuntimeRegistrationsFromPluginSet
+} from "../chunk-SG5WAA7H.js";
+import {
+  setPlugins,
+  validatePlugins
+} from "../chunk-NFTMTIP3.js";
+import {
+  createPluginLogger
+} from "../chunk-56TBVRJG.js";
+import {
+  getDb
+} from "../chunk-NYKJ3KON.js";
+import "../chunk-G3E7SCME.js";
+import "../chunk-Y5OFBCBZ.js";
+import "../chunk-Q6XFTRV5.js";
+import "../chunk-T77LUIX3.js";
+import {
+  loadAppPluginSet
+} from "../chunk-Y2CM7HXH.js";
+import {
+  setPluginCatalogConfig
+} from "../chunk-ZLMBNBUG.js";
+import "../chunk-VALUBQ7R.js";
+import "../chunk-Q3XNY442.js";
+import "../chunk-EJN6G5A2.js";
+import "../chunk-OJ53FYVG.js";
+import "../chunk-ST6YNAXG.js";
+import "../chunk-MLKGABMK.js";
+
+// src/cli/plugins.ts
+import { stderr as defaultStderr, stdout as defaultStdout } from "process";
+import { createJiti } from "jiti";
+import { Command, CommanderError } from "commander";
+var pluginCliLoader = createJiti(import.meta.url, { moduleCache: false });
+var CORE_COMMAND_NAMES = /* @__PURE__ */ new Set([
+  "chat",
+  "check",
+  "init",
+  "snapshot",
+  "upgrade"
+]);
+var PLUGIN_COMMAND_NAME_RE = /^[a-z][a-z0-9-]*$/;
+var DEFAULT_IO = {
+  writeError: (text) => writeStream(defaultStderr, text),
+  writeOutput: (text) => writeStream(defaultStdout, text)
+};
+function writeStream(stream, text) {
+  return new Promise((resolve, reject) => {
+    stream.write(text, (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+async function loadCliPluginSet() {
+  return await loadAppPluginSet(
+    process.cwd(),
+    async (moduleRef) => pluginCliLoader.import(moduleRef.importPath)
+  );
+}
+function findPluginCommand(plugins, commandName) {
+  for (const plugin of plugins) {
+    const command = plugin.cli?.commands.find(
+      (candidate) => candidate.name === commandName
+    );
+    if (command) {
+      return { command, plugin };
+    }
+  }
+  return void 0;
+}
+function createPluginCliHost(args) {
+  return {
+    action(handler) {
+      return async (...actionArgs) => {
+        const pluginName = args.plugin.manifest.name;
+        const result = await handler(
+          {
+            db: getDb(),
+            command: {
+              name: args.command.name,
+              summary: args.command.summary
+            },
+            io: args.io,
+            log: createPluginLogger(pluginName),
+            plugin: { name: pluginName }
+          },
+          ...actionArgs
+        );
+        args.setExitCode(result ?? 0);
+      };
+    }
+  };
+}
+function createPluginCommanderCommand(args) {
+  const command = new Command(args.command.name).description(args.command.summary).exitOverride().showHelpAfterError().showSuggestionAfterError().configureOutput({
+    writeOut: (text) => {
+      void args.io.writeOutput(text);
+    },
+    writeErr: (text) => {
+      void args.io.writeError(text);
+    },
+    outputError: (text, write) => {
+      write(text);
+    }
+  });
+  args.command.configure(command, createPluginCliHost(args));
+  return command;
+}
+function validateConfiguredPluginCommand(args) {
+  const pluginName = args.plugin.manifest.name;
+  if (args.command.name() !== args.definition.name) {
+    throw new Error(
+      `Plugin CLI command "${args.definition.name}" from plugin "${pluginName}" must not rename its top-level command`
+    );
+  }
+  if (args.command.commands.length === 0) {
+    throw new Error(
+      `Plugin CLI command "${args.definition.name}" from plugin "${pluginName}" must define at least one subcommand`
+    );
+  }
+  if (args.command.aliases().length > 0) {
+    throw new Error(
+      `Plugin CLI command "${args.definition.name}" from plugin "${pluginName}" must not define top-level aliases`
+    );
+  }
+}
+function validateConfiguredPluginCommands(plugins) {
+  const ownerByName = /* @__PURE__ */ new Map();
+  const validationIo = DEFAULT_IO;
+  for (const plugin of plugins) {
+    for (const definition of plugin.cli?.commands ?? []) {
+      const pluginName = plugin.manifest.name;
+      const existingOwner = ownerByName.get(definition.name);
+      if (!PLUGIN_COMMAND_NAME_RE.test(definition.name)) {
+        throw new Error(
+          `Plugin CLI command "${definition.name}" from plugin "${pluginName}" must be a lowercase command identifier`
+        );
+      }
+      if (CORE_COMMAND_NAMES.has(definition.name)) {
+        throw new Error(
+          `Plugin CLI command "${definition.name}" from plugin "${pluginName}" conflicts with a core command`
+        );
+      }
+      if (existingOwner) {
+        throw new Error(
+          `Plugin CLI command "${definition.name}" from plugin "${pluginName}" conflicts with plugin "${existingOwner}"`
+        );
+      }
+      ownerByName.set(definition.name, pluginName);
+      if (typeof definition.configure !== "function") {
+        throw new Error(
+          `Plugin CLI command "${definition.name}" from plugin "${pluginName}" must define a configure function`
+        );
+      }
+      let exitCode = 0;
+      validateConfiguredPluginCommand({
+        command: createPluginCommanderCommand({
+          command: definition,
+          io: validationIo,
+          plugin,
+          setExitCode: (nextExitCode) => {
+            exitCode = nextExitCode;
+          }
+        }),
+        definition,
+        plugin
+      });
+      void exitCode;
+    }
+  }
+}
+async function loadPluginRegistrations(args) {
+  const pluginSet = args.pluginSet;
+  if (!pluginSet) {
+    return { cliPlugins: [], runtimePlugins: [] };
+  }
+  const cliPlugins = pluginCliRegistrationsFromPluginSet(pluginSet);
+  const runtimePlugins = pluginRuntimeRegistrationsFromPluginSet(pluginSet);
+  const pluginConfig = pluginCatalogConfigFromPluginSet(pluginSet);
+  validatePlugins(runtimePlugins);
+  const previousPluginCatalogConfig = setPluginCatalogConfig(pluginConfig);
+  try {
+    validatePluginRegistrations(pluginSet.registrations);
+    validatePluginEgressCredentialHooks(pluginSet.registrations);
+    args.validateConfiguredCommands?.(cliPlugins);
+    setPlugins(runtimePlugins);
+    return { cliPlugins, runtimePlugins };
+  } catch (error) {
+    setPluginCatalogConfig(previousPluginCatalogConfig);
+    throw error;
+  }
+}
+async function loadCliPluginCommands(pluginSet) {
+  const resolvedPluginSet = pluginSet === void 0 ? await loadCliPluginSet() : pluginSet ?? void 0;
+  const { cliPlugins } = await loadPluginRegistrations({
+    pluginSet: resolvedPluginSet,
+    validateConfiguredCommands: validateConfiguredPluginCommands
+  });
+  const commandNames = cliPlugins.flatMap(
+    (plugin) => (plugin.cli?.commands ?? []).map((command) => command.name)
+  );
+  return {
+    commandNames,
+    async run(commandName, argv, io = DEFAULT_IO) {
+      const resolved = findPluginCommand(cliPlugins, commandName);
+      if (!resolved) {
+        return void 0;
+      }
+      let exitCode = 0;
+      const command = createPluginCommanderCommand({
+        command: resolved.command,
+        io,
+        plugin: resolved.plugin,
+        setExitCode: (nextExitCode) => {
+          exitCode = nextExitCode;
+        }
+      });
+      try {
+        await command.parseAsync(argv, { from: "user" });
+      } catch (error) {
+        if (error instanceof CommanderError) {
+          return error.exitCode;
+        }
+        throw error;
+      }
+      return exitCode;
+    }
+  };
+}
+export {
+  loadCliPluginCommands,
+  loadCliPluginSet
+};

package/dist/cli/run.js

@@ -1,55 +1,8 @@
-import "../chunk-2KG3PWR4.js";
-
-// src/cli/run.ts
-var CLI_USAGE = "usage: junior init <dir>\n       junior snapshot create\n       junior check [dir]\n       junior upgrade\n       junior chat\n       junior chat -p <message>";
-var DEFAULT_IO = {
-  error: console.error
-};
-function normalizeCliArgv(argv) {
-  return argv[0] === "--" ? argv.slice(1) : argv;
-}
-async function runCli(argv, handlers, io = DEFAULT_IO) {
-  const [command, subcommand, ...rest] = normalizeCliArgv(argv);
-  if (command === "chat") {
-    return await handlers.runChat(
-      subcommand === void 0 ? [] : [subcommand, ...rest]
-    );
-  }
-  if (command === "init") {
-    if (!subcommand || rest.length > 0) {
-      io.error(CLI_USAGE);
-      return 1;
-    }
-    await handlers.runInit(subcommand);
-    return 0;
-  }
-  if (command === "snapshot" && subcommand === "create") {
-    if (rest.length > 0) {
-      io.error(CLI_USAGE);
-      return 1;
-    }
-    await handlers.runSnapshotCreate();
-    return 0;
-  }
-  if (command === "check") {
-    if (rest.length > 0) {
-      io.error(CLI_USAGE);
-      return 1;
-    }
-    await handlers.runCheck(subcommand);
-    return 0;
-  }
-  if (command === "upgrade") {
-    if (subcommand || rest.length > 0) {
-      io.error(CLI_USAGE);
-      return 1;
-    }
-    await handlers.runUpgrade();
-    return 0;
-  }
-  io.error(CLI_USAGE);
-  return 1;
-}
+import {
+  CLI_USAGE,
+  runCli
+} from "../chunk-4UO6FK4G.js";
+import "../chunk-MLKGABMK.js";
 export {
   CLI_USAGE,
   runCli

package/dist/cli/snapshot-warmup.js

@@ -1,22 +1,22 @@
 import {
   resolveRuntimeDependencySnapshot
-} from "../chunk-XJHDZUGD.js";
+} from "../chunk-JBASI5VV.js";
 import "../chunk-G3E7SCME.js";
 import {
   disconnectStateAdapter
-} from "../chunk-ZNNTSPNF.js";
-import "../chunk-FCZO7LAR.js";
+} from "../chunk-Y5OFBCBZ.js";
+import "../chunk-T77LUIX3.js";
 import {
   getPluginProviders,
   getPluginRuntimeDependencies,
   getPluginRuntimePostinstall
-} 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-SJHUF3DP.js";
-import "../chunk-2KG3PWR4.js";
+import "../chunk-EJN6G5A2.js";
+import "../chunk-OJ53FYVG.js";
+import "../chunk-ST6YNAXG.js";
+import "../chunk-MLKGABMK.js";
 
 // src/cli/snapshot-warmup.ts
 var DEFAULT_RUNTIME = "node22";

package/dist/cli/upgrade.js

@@ -1,59 +1,56 @@
 import {
+  getConversation,
+  listConversationsByActivity,
+  recordConversationActivity,
+  requestConversationWork
+} from "../chunk-R6Z5XWY3.js";
+import {
+  JUNIOR_THREAD_STATE_TTL_MS,
   coerceThreadConversationState
-} from "../chunk-74HO27II.js";
+} from "../chunk-Z4CIQ3EB.js";
 import {
   defineJuniorPlugins,
   pluginCatalogConfigFromEnv,
   pluginCatalogConfigFromPluginSet,
-  pluginHookRegistrationsFromPluginSet
-} from "../chunk-EE6PJWY4.js";
-import {
-  JUNIOR_THREAD_STATE_TTL_MS,
-  createSqlStore,
-  createStateConversationStore,
-  getConversation,
-  requestConversationWork
-} from "../chunk-UJ7OTHPO.js";
-import {
-  parseDestination,
-  sameDestination
-} from "../chunk-WBZ4M5N5.js";
+  pluginRuntimeRegistrationsFromPluginSet
+} from "../chunk-SG5WAA7H.js";
 import {
   createPluginLogger,
   createPluginState
-} from "../chunk-BNJIEFQC.js";
-import "../chunk-62FUNJYS.js";
+} from "../chunk-56TBVRJG.js";
 import {
   createJuniorSqlExecutor,
-  createPluginDbForExecutor,
-  getPluginDbForRegistration,
-  migratePluginSchemas,
-  readPluginMigrations
-} from "../chunk-D7NFH5GD.js";
-import {
-  loadAppPluginSet
-} from "../chunk-Y2CM7HXH.js";
+  createSqlStore,
+  getDb
+} from "../chunk-NYKJ3KON.js";
 import {
   disconnectStateAdapter,
   getConnectedStateContext
-} from "../chunk-ZNNTSPNF.js";
+} from "../chunk-Y5OFBCBZ.js";
+import {
+  parseDestination,
+  sameDestination
+} from "../chunk-Q6XFTRV5.js";
 import {
   getChatConfig
-} from "../chunk-FCZO7LAR.js";
+} from "../chunk-T77LUIX3.js";
+import {
+  loadAppPluginSet
+} from "../chunk-Y2CM7HXH.js";
 import {
   getPluginMigrationRoots,
   setPluginCatalogConfig
-} 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 {
   isRecord,
   toOptionalNumber,
   toOptionalString
-} from "../chunk-OK4KKR7B.js";
-import "../chunk-SJHUF3DP.js";
-import "../chunk-2KG3PWR4.js";
+} from "../chunk-EJN6G5A2.js";
+import "../chunk-OJ53FYVG.js";
+import "../chunk-ST6YNAXG.js";
+import "../chunk-MLKGABMK.js";
 
 // src/cli/upgrade.ts
 import { createJiti } from "jiti";
@@ -73,6 +70,17 @@ async function backfillToSql(args) {
   };
 }
 
+// src/chat/conversations/state.ts
+function createStateConversationStore(state) {
+  return {
+    get: (args) => getConversation({ ...args, state }),
+    recordActivity: (args) => recordConversationActivity({ ...args, state }),
+    recordExecution: async () => {
+    },
+    listByActivity: (args) => listConversationsByActivity({ ...args, state })
+  };
+}
+
 // src/cli/upgrade/migrations/conversations-sql.ts
 var CONVERSATION_BACKFILL_LIMIT = 1e4;
 var REQUIRED_SQL_DATABASE_URL_MESSAGE = "Junior SQL database URL is required for conversation metadata upgrade. Set JUNIOR_DATABASE_URL or DATABASE_URL.";
@@ -202,11 +210,8 @@ function addResult(left, right) {
     ...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);
+function dbForPlugin(context, sqlUrlDb) {
+  return context.db ?? sqlUrlDb ?? getDb();
 }
 async function runPluginStorageMigrations(context) {
   const { pluginCatalogConfig, pluginSet } = await resolveUpgradePlugins(context);
@@ -214,14 +219,14 @@ async function runPluginStorageMigrations(context) {
     return emptyResult();
   }
   const previousConfig = setPluginCatalogConfig(pluginCatalogConfig);
-  const ownedExecutor = context.pluginDb || !context.sqlDatabaseUrl ? void 0 : createJuniorSqlExecutor({
+  const ownedExecutor = context.db || !context.sqlDatabaseUrl ? void 0 : createJuniorSqlExecutor({
     connectionString: context.sqlDatabaseUrl,
     driver: context.sqlDriver ?? getChatConfig().sql.driver
   });
-  const sqlUrlDb = ownedExecutor ? createPluginDbForExecutor(ownedExecutor) : void 0;
+  const sqlUrlDb = ownedExecutor ? ownedExecutor.db() : void 0;
   try {
     let result = emptyResult();
-    const plugins = pluginHookRegistrationsFromPluginSet(pluginSet).filter((plugin) => plugin.hooks?.migrateStorage).sort(
+    const plugins = pluginRuntimeRegistrationsFromPluginSet(pluginSet).filter((plugin) => plugin.hooks?.migrateStorage).sort(
       (left, right) => left.manifest.name.localeCompare(right.manifest.name)
     );
     for (const plugin of plugins) {
@@ -230,12 +235,7 @@ async function runPluginStorageMigrations(context) {
       if (!hook) {
         continue;
       }
-      const db = dbForPlugin(context, plugin, sqlUrlDb);
-      if (!db) {
-        throw new Error(
-          `Plugin "${pluginName}" storage migration requires database access`
-        );
-      }
+      const db = dbForPlugin(context, sqlUrlDb);
       const pluginResult = await hook({
         db,
         log: createPluginLogger(pluginName),
@@ -257,6 +257,125 @@ var pluginStorageMigration = {
   run: runPluginStorageMigrations
 };
 
+// src/chat/plugins/db.ts
+import { createHash } from "crypto";
+import { readdirSync, readFileSync, statSync } from "fs";
+import path from "path";
+import { z } from "zod";
+var PLUGIN_SCHEMA_LOCK_NAME = "junior_plugin_schema";
+var MIGRATION_FILENAME_RE = /^[0-9]{4}_[a-z0-9_]+\.sql$/;
+var migrationRecordSchema = z.object({
+  id: z.string().min(1),
+  checksum: z.string().min(1)
+}).strict();
+function checksumSql(sql) {
+  return createHash("sha256").update(sql).digest("hex");
+}
+function parseStoredMigrationRecord(value) {
+  return migrationRecordSchema.parse(value);
+}
+function assertMigrationFilename(filename) {
+  if (!filename || filename !== path.basename(filename) || !MIGRATION_FILENAME_RE.test(filename)) {
+    throw new Error(`Plugin migration filename "${filename}" is invalid`);
+  }
+}
+function assertUniqueMigrationIds(migrations) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const migration of migrations) {
+    if (seen.has(migration.id)) {
+      throw new Error(`Duplicate plugin migration id ${migration.id}`);
+    }
+    seen.add(migration.id);
+  }
+}
+function migrationId(pluginName, filename) {
+  return `plugin:${pluginName}/${filename}`;
+}
+function createMigrationTableSql() {
+  return `
+CREATE TABLE IF NOT EXISTS junior_schema_migrations (
+  id TEXT PRIMARY KEY,
+  checksum TEXT NOT NULL,
+  applied_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
+)
+`;
+}
+async function listAppliedMigrations(executor) {
+  const rows = await executor.query(
+    "SELECT id, checksum FROM junior_schema_migrations ORDER BY id ASC"
+  );
+  const records = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const record = parseStoredMigrationRecord(row);
+    records.set(record.id, record);
+  }
+  return records;
+}
+async function applyPluginMigration(executor, migration) {
+  await executor.transaction(async () => {
+    await executor.execute(migration.sql);
+    await executor.execute(
+      "INSERT INTO junior_schema_migrations (id, checksum) VALUES ($1, $2)",
+      [migration.id, migration.checksum]
+    );
+  });
+}
+function readPluginMigrations(root) {
+  const migrationsDir = root.dir;
+  let stat;
+  try {
+    stat = statSync(migrationsDir);
+  } catch {
+    return [];
+  }
+  if (!stat.isDirectory()) {
+    throw new Error(
+      `Plugin "${root.pluginName}" migrations path is not a directory`
+    );
+  }
+  return readdirSync(migrationsDir).filter((filename) => filename.endsWith(".sql")).sort((left, right) => left.localeCompare(right)).map((filename) => {
+    assertMigrationFilename(filename);
+    const sql = readFileSync(path.join(migrationsDir, filename), "utf8");
+    if (!sql.trim()) {
+      throw new Error(
+        `Plugin "${root.pluginName}" migration "${filename}" is empty`
+      );
+    }
+    return {
+      checksum: checksumSql(sql),
+      filename,
+      id: migrationId(root.pluginName, filename),
+      pluginName: root.pluginName,
+      sql
+    };
+  });
+}
+async function migratePluginSchemas(executor, migrations) {
+  assertUniqueMigrationIds(migrations);
+  const result = {
+    existing: 0,
+    migrated: 0,
+    scanned: migrations.length
+  };
+  await executor.withLock(PLUGIN_SCHEMA_LOCK_NAME, async () => {
+    await executor.execute(createMigrationTableSql());
+    const applied = await listAppliedMigrations(executor);
+    for (const migration of migrations) {
+      const existing = applied.get(migration.id);
+      if (existing) {
+        if (existing.checksum !== migration.checksum) {
+          throw new Error(`Plugin migration ${migration.id} checksum changed`);
+        }
+        result.existing++;
+        continue;
+      }
+      await applyPluginMigration(executor, migration);
+      result.migrated++;
+    }
+  });
+  return result;
+}
+
 // 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) {
@@ -886,10 +1005,10 @@ async function runUpgradeMigrations(context) {
   }
   return results;
 }
-async function runUpgrade(io = DEFAULT_IO) {
+async function runUpgrade(io = DEFAULT_IO, options = {}) {
   try {
     const { redisStateAdapter, stateAdapter } = await getConnectedStateContext();
-    const pluginSet = await resolveUpgradePluginSet();
+    const pluginSet = options.pluginSet === void 0 ? await resolveUpgradePluginSet() : options.pluginSet ?? void 0;
     io.info("Running Junior upgrade migrations...");
     await runUpgradeMigrations({
       io,

package/dist/db-7A7PFRGL.js

@@ -0,0 +1,17 @@
+import {
+  closeDb,
+  getConversationStore,
+  getDb
+} from "./chunk-NYKJ3KON.js";
+import "./chunk-Q6XFTRV5.js";
+import "./chunk-T77LUIX3.js";
+import "./chunk-VALUBQ7R.js";
+import "./chunk-EJN6G5A2.js";
+import "./chunk-OJ53FYVG.js";
+import "./chunk-ST6YNAXG.js";
+import "./chunk-MLKGABMK.js";
+export {
+  closeDb,
+  getConversationStore,
+  getDb
+};

package/dist/deployment.d.ts

@@ -1,6 +1,7 @@
 export declare const JUNIOR_HEARTBEAT_ROUTE = "/api/internal/heartbeat";
 export declare const JUNIOR_HEARTBEAT_CRON_SCHEDULE = "* * * * *";
 export declare const JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE = "/api/internal/agent/continue";
+export declare const JUNIOR_PLUGIN_TASK_CALLBACK_ROUTE = "/api/internal/plugin/tasks";
 export declare const LEGACY_JUNIOR_CONVERSATION_WORK_FUNCTION = "api/internal/agent/continue.ts";
 /** Resolve the deployment version used for release and telemetry correlation. */
 export declare function getDeploymentServiceVersion(): string | undefined;