@sentry/junior 0.74.1 → 0.75.0

package/dist/chunk-D7NFH5GD.js

@@ -0,0 +1,570 @@
+import {
+  getChatConfig
+} from "./chunk-FCZO7LAR.js";
+
+// src/chat/plugins/db.ts
+import { createHash } from "crypto";
+import { readdirSync, readFileSync, statSync } from "fs";
+import path from "path";
+import { z } from "zod";
+
+// src/chat/sql/neon.ts
+import { AsyncLocalStorage } from "async_hooks";
+import {
+  Pool
+} from "@neondatabase/serverless";
+import { drizzle } from "drizzle-orm/neon-serverless";
+
+// src/chat/conversations/sql/schema/conversations.ts
+import { sql } from "drizzle-orm";
+import { index as index3, integer, jsonb as jsonb3, pgTable as pgTable3, text as text3 } from "drizzle-orm/pg-core";
+
+// src/chat/conversations/sql/schema/destinations.ts
+import { index, jsonb, pgTable, text, uniqueIndex } from "drizzle-orm/pg-core";
+
+// src/chat/conversations/sql/schema/timestamps.ts
+import { timestamp } from "drizzle-orm/pg-core";
+var timestamptz = (name) => timestamp(name, { withTimezone: true });
+
+// src/chat/conversations/sql/schema/destinations.ts
+var juniorDestinations = pgTable(
+  "junior_destinations",
+  {
+    id: text("id").primaryKey(),
+    provider: text("provider").notNull(),
+    providerTenantId: text("provider_tenant_id").notNull().default(""),
+    providerDestinationId: text("provider_destination_id").notNull(),
+    kind: text("kind").$type().notNull(),
+    parentDestinationId: text("parent_destination_id"),
+    displayName: text("display_name"),
+    visibility: text("visibility").$type().notNull().default("unknown"),
+    metadata: jsonb("metadata_json"),
+    createdAt: timestamptz("created_at").notNull(),
+    updatedAt: timestamptz("updated_at").notNull()
+  },
+  (table) => [
+    uniqueIndex("junior_destinations_provider_destination_uidx").on(
+      table.provider,
+      table.providerTenantId,
+      table.providerDestinationId
+    ),
+    index("junior_destinations_provider_kind_idx").on(
+      table.provider,
+      table.kind
+    )
+  ]
+);
+
+// src/chat/conversations/sql/schema/identities.ts
+import { index as index2, jsonb as jsonb2, pgTable as pgTable2, text as text2, uniqueIndex as uniqueIndex2 } from "drizzle-orm/pg-core";
+var juniorIdentities = pgTable2(
+  "junior_identities",
+  {
+    id: text2("id").primaryKey(),
+    kind: text2("kind").$type().notNull(),
+    provider: text2("provider").notNull(),
+    providerTenantId: text2("provider_tenant_id").notNull().default(""),
+    providerSubjectId: text2("provider_subject_id").notNull(),
+    displayName: text2("display_name"),
+    handle: text2("handle"),
+    email: text2("email"),
+    avatarUrl: text2("avatar_url"),
+    metadata: jsonb2("metadata_json"),
+    createdAt: timestamptz("created_at").notNull(),
+    updatedAt: timestamptz("updated_at").notNull()
+  },
+  (table) => [
+    uniqueIndex2("junior_identities_provider_subject_uidx").on(
+      table.provider,
+      table.providerTenantId,
+      table.providerSubjectId
+    ),
+    index2("junior_identities_kind_provider_idx").on(table.kind, table.provider)
+  ]
+);
+
+// src/chat/conversations/sql/schema/conversations.ts
+var juniorConversations = pgTable3(
+  "junior_conversations",
+  {
+    conversationId: text3("conversation_id").primaryKey(),
+    schemaVersion: integer("schema_version").notNull().default(1),
+    source: text3("source").$type(),
+    originType: text3("origin_type"),
+    originId: text3("origin_id"),
+    originRunId: text3("origin_run_id"),
+    destinationId: text3("destination_id").references(
+      () => juniorDestinations.id
+    ),
+    destination: jsonb3("destination_json").$type(),
+    actorIdentityId: text3("actor_identity_id").references(
+      () => juniorIdentities.id
+    ),
+    requesterIdentityId: text3("requester_identity_id").references(
+      () => juniorIdentities.id
+    ),
+    creatorIdentityId: text3("creator_identity_id").references(
+      () => juniorIdentities.id
+    ),
+    credentialSubjectIdentityId: text3(
+      "credential_subject_identity_id"
+    ).references(() => juniorIdentities.id),
+    requester: jsonb3("requester_json").$type(),
+    channelName: text3("channel_name"),
+    title: text3("title"),
+    createdAt: timestamptz("created_at").notNull(),
+    lastActivityAt: timestamptz("last_activity_at").notNull(),
+    updatedAt: timestamptz("updated_at").notNull(),
+    executionUpdatedAt: timestamptz("execution_updated_at"),
+    executionStatus: text3("execution_status").$type().notNull(),
+    runId: text3("run_id"),
+    lastCheckpointAt: timestamptz("last_checkpoint_at"),
+    lastEnqueuedAt: timestamptz("last_enqueued_at")
+  },
+  (table) => [
+    index3("junior_conversations_last_activity_idx").on(
+      table.lastActivityAt.desc(),
+      table.conversationId
+    ),
+    index3("junior_conversations_active_idx").using(
+      "btree",
+      sql`coalesce(${table.executionUpdatedAt}, ${table.updatedAt})`,
+      table.conversationId
+    ).where(sql`${table.executionStatus} <> 'idle'`),
+    index3("junior_conversations_destination_activity_idx").on(
+      table.destinationId,
+      table.lastActivityAt.desc()
+    ),
+    index3("junior_conversations_actor_activity_idx").on(
+      table.actorIdentityId,
+      table.lastActivityAt.desc()
+    ),
+    index3("junior_conversations_requester_activity_idx").on(
+      table.requesterIdentityId,
+      table.lastActivityAt.desc()
+    ),
+    index3("junior_conversations_origin_idx").on(
+      table.originType,
+      table.originId,
+      table.lastActivityAt.desc()
+    )
+  ]
+);
+
+// src/chat/conversations/sql/schema/migrations.ts
+import { pgTable as pgTable4, text as text4 } from "drizzle-orm/pg-core";
+var juniorSchemaMigrations = pgTable4("junior_schema_migrations", {
+  id: text4("id").primaryKey(),
+  checksum: text4("checksum").notNull(),
+  appliedAt: timestamptz("applied_at").notNull().defaultNow()
+});
+
+// src/chat/conversations/sql/schema.ts
+var schema = {
+  juniorConversations,
+  juniorDestinations,
+  juniorIdentities,
+  juniorSchemaMigrations
+};
+
+// src/chat/sql/schema.ts
+var juniorSqlSchema = {
+  ...schema
+};
+
+// src/chat/sql/neon.ts
+var NeonExecutor = class {
+  constructor(pool) {
+    this.pool = pool;
+  }
+  pool;
+  transactionClient = new AsyncLocalStorage();
+  savepointId = 0;
+  db() {
+    return drizzle(this.queryClient(), {
+      schema: juniorSqlSchema
+    });
+  }
+  async execute(statement, params = []) {
+    await this.queryClient().query(statement, [...params]);
+  }
+  async query(statement, params = []) {
+    const result = await this.queryClient().query(statement, [
+      ...params
+    ]);
+    return result.rows;
+  }
+  async transaction(callback) {
+    const existingClient = this.transactionClient.getStore();
+    if (existingClient) {
+      const savepoint = `junior_savepoint_${++this.savepointId}`;
+      await existingClient.query(`SAVEPOINT ${savepoint}`);
+      try {
+        const result = await callback();
+        await existingClient.query(`RELEASE SAVEPOINT ${savepoint}`);
+        return result;
+      } catch (error) {
+        await existingClient.query(`ROLLBACK TO SAVEPOINT ${savepoint}`);
+        await existingClient.query(`RELEASE SAVEPOINT ${savepoint}`);
+        throw error;
+      }
+    }
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const result = await this.transactionClient.run(client, callback);
+      await client.query("COMMIT");
+      return result;
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  async withLock(lockName, callback) {
+    if (!lockName) {
+      throw new Error("SQL lock name is required");
+    }
+    const existingClient = this.transactionClient.getStore();
+    if (existingClient) {
+      await existingClient.query("SELECT pg_advisory_xact_lock(hashtext($1))", [
+        lockName
+      ]);
+      return await callback();
+    }
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      return await this.transactionClient.run(client, async () => {
+        try {
+          await client.query("SELECT pg_advisory_xact_lock(hashtext($1))", [
+            lockName
+          ]);
+          const result = await callback();
+          await client.query("COMMIT");
+          return result;
+        } catch (error) {
+          await client.query("ROLLBACK");
+          throw error;
+        }
+      });
+    } finally {
+      client.release();
+    }
+  }
+  async close() {
+    await this.pool.end();
+  }
+  queryClient() {
+    return this.transactionClient.getStore() ?? this.pool;
+  }
+};
+function createNeonJuniorSqlExecutor(args) {
+  return new NeonExecutor(
+    new Pool({
+      connectionString: args.connectionString,
+      max: 3
+    })
+  );
+}
+
+// src/chat/sql/postgres.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+import pg from "pg";
+import { drizzle as drizzle2 } from "drizzle-orm/node-postgres";
+var { Pool: Pool2 } = pg;
+var PostgresExecutor = class {
+  constructor(pool) {
+    this.pool = pool;
+  }
+  pool;
+  transactionClient = new AsyncLocalStorage2();
+  savepointId = 0;
+  db() {
+    return drizzle2(this.queryClient(), {
+      schema: juniorSqlSchema
+    });
+  }
+  async execute(statement, params = []) {
+    await this.queryClient().query(statement, [...params]);
+  }
+  async query(statement, params = []) {
+    const result = await this.queryClient().query(statement, [
+      ...params
+    ]);
+    return result.rows;
+  }
+  async transaction(callback) {
+    const existingClient = this.transactionClient.getStore();
+    if (existingClient) {
+      const savepoint = `junior_savepoint_${++this.savepointId}`;
+      await existingClient.query(`SAVEPOINT ${savepoint}`);
+      try {
+        const result = await callback();
+        await existingClient.query(`RELEASE SAVEPOINT ${savepoint}`);
+        return result;
+      } catch (error) {
+        await existingClient.query(`ROLLBACK TO SAVEPOINT ${savepoint}`);
+        await existingClient.query(`RELEASE SAVEPOINT ${savepoint}`);
+        throw error;
+      }
+    }
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      const result = await this.transactionClient.run(client, callback);
+      await client.query("COMMIT");
+      return result;
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  async withLock(lockName, callback) {
+    if (!lockName) {
+      throw new Error("SQL lock name is required");
+    }
+    const existingClient = this.transactionClient.getStore();
+    if (existingClient) {
+      await existingClient.query("SELECT pg_advisory_xact_lock(hashtext($1))", [
+        lockName
+      ]);
+      return await callback();
+    }
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      return await this.transactionClient.run(client, async () => {
+        try {
+          await client.query("SELECT pg_advisory_xact_lock(hashtext($1))", [
+            lockName
+          ]);
+          const result = await callback();
+          await client.query("COMMIT");
+          return result;
+        } catch (error) {
+          await client.query("ROLLBACK");
+          throw error;
+        }
+      });
+    } finally {
+      client.release();
+    }
+  }
+  async close() {
+    await this.pool.end();
+  }
+  queryClient() {
+    return this.transactionClient.getStore() ?? this.pool;
+  }
+};
+function createPostgresJuniorSqlExecutor(args) {
+  return new PostgresExecutor(
+    new Pool2({
+      application_name: args.applicationName,
+      connectionString: args.connectionString,
+      max: 3
+    })
+  );
+}
+
+// src/chat/sql/executor.ts
+function createJuniorSqlExecutor(args) {
+  if (args.driver === "postgres") {
+    return createPostgresJuniorSqlExecutor(args);
+  }
+  return createNeonJuniorSqlExecutor(args);
+}
+
+// src/chat/plugins/db.ts
+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();
+var configuredPluginDb;
+function checksumSql(sql2) {
+  return createHash("sha256").update(sql2).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
+)
+`;
+}
+function createPluginDb(executor) {
+  const db = executor.db();
+  const pluginDb = {
+    delete: db.delete.bind(db),
+    execute: (statement, params) => executor.execute(statement, params),
+    insert: db.insert.bind(db),
+    query: (statement, params) => executor.query(statement, params),
+    select: db.select.bind(db),
+    transaction: async (callback) => await executor.transaction(
+      async () => await callback(createPluginDb(executor))
+    ),
+    update: db.update.bind(db)
+  };
+  return pluginDb;
+}
+function getConfiguredPluginDb() {
+  const databaseUrl = getChatConfig().sql.databaseUrl;
+  const driver = getChatConfig().sql.driver;
+  if (!databaseUrl) {
+    return void 0;
+  }
+  if (configuredPluginDb?.databaseUrl !== databaseUrl || configuredPluginDb.driver !== driver) {
+    void configuredPluginDb?.executor.close().catch(() => void 0);
+    const executor = createJuniorSqlExecutor({
+      connectionString: databaseUrl,
+      driver
+    });
+    configuredPluginDb = {
+      databaseUrl,
+      driver,
+      executor,
+      db: createPluginDb(executor)
+    };
+  }
+  return configuredPluginDb.db;
+}
+async function closeConfiguredPluginDb() {
+  const current = configuredPluginDb;
+  configuredPluginDb = void 0;
+  await current?.executor.close();
+}
+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 createPluginDbForExecutor(executor) {
+  return createPluginDb(executor);
+}
+function getPluginDbForRegistration(registration) {
+  if (!registration.database) {
+    return void 0;
+  }
+  return getConfiguredPluginDb();
+}
+function validatePluginDatabaseRequirements(registrations) {
+  if (getChatConfig().sql.databaseUrl) {
+    return;
+  }
+  const databasePlugins = registrations.filter((registration) => registration.database).map((registration) => registration.manifest.name);
+  if (databasePlugins.length > 0) {
+    throw new Error(
+      `Plugin database access requires JUNIOR_DATABASE_URL or DATABASE_URL for: ${databasePlugins.join(", ")}`
+    );
+  }
+}
+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 sql2 = readFileSync(path.join(migrationsDir, filename), "utf8");
+    if (!sql2.trim()) {
+      throw new Error(
+        `Plugin "${root.pluginName}" migration "${filename}" is empty`
+      );
+    }
+    return {
+      checksum: checksumSql(sql2),
+      filename,
+      id: migrationId(root.pluginName, filename),
+      pluginName: root.pluginName,
+      sql: sql2
+    };
+  });
+}
+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;
+}
+
+export {
+  juniorDestinations,
+  juniorIdentities,
+  juniorConversations,
+  createJuniorSqlExecutor,
+  closeConfiguredPluginDb,
+  createPluginDbForExecutor,
+  getPluginDbForRegistration,
+  validatePluginDatabaseRequirements,
+  readPluginMigrations,
+  migratePluginSchemas
+};

package/dist/chunk-EE6PJWY4.js

@@ -0,0 +1,130 @@
+// src/plugins.ts
+function cloneManifests(manifests) {
+  return manifests ? structuredClone(manifests) : void 0;
+}
+function cloneInlineManifests(registrations) {
+  const inlineManifests = registrations.flatMap(
+    (plugin) => plugin.manifest ? [
+      {
+        manifest: {
+          ...structuredClone(plugin.manifest),
+          capabilities: plugin.manifest.capabilities?.map(
+            (capability) => capability.includes(".") ? capability : `${plugin.manifest.name}.${capability}`
+          ) ?? [],
+          configKeys: plugin.manifest.configKeys?.map(
+            (key) => key.includes(".") ? key : `${plugin.manifest.name}.${key}`
+          ) ?? [],
+          ...plugin.manifest.target ? {
+            target: {
+              ...plugin.manifest.target,
+              configKey: plugin.manifest.target.configKey.includes(".") ? plugin.manifest.target.configKey : `${plugin.manifest.name}.${plugin.manifest.target.configKey}`
+            }
+          } : {}
+        },
+        ...plugin.packageName ? { packageName: plugin.packageName } : {}
+      }
+    ] : []
+  );
+  return inlineManifests.length > 0 ? inlineManifests : void 0;
+}
+function assertUniquePluginNames(registrations) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const plugin of registrations) {
+    const name = plugin.manifest.name;
+    if (seen.has(name)) {
+      throw new Error(`Duplicate plugin registration name "${name}"`);
+    }
+    seen.add(name);
+  }
+}
+function assertUniquePackageNames(packageNames) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const packageName of packageNames) {
+    if (seen.has(packageName)) {
+      throw new Error(`Duplicate plugin package name "${packageName}"`);
+    }
+    seen.add(packageName);
+  }
+}
+function normalizePluginInput(input) {
+  if (typeof input === "string") {
+    return { packageName: input };
+  }
+  return { registration: input };
+}
+function defineJuniorPlugins(inputs, options = {}) {
+  const normalized = inputs.map(normalizePluginInput);
+  const packageNames = normalized.flatMap(
+    (input) => input.packageName ? [input.packageName] : []
+  );
+  const registrations = normalized.flatMap(
+    (input) => input.registration ? [input.registration] : []
+  );
+  assertUniquePackageNames(packageNames);
+  assertUniquePluginNames(registrations);
+  const manifests = cloneManifests(options.manifests);
+  return {
+    packageNames,
+    registrations: registrations.map((plugin) => ({ ...plugin })),
+    ...manifests ? { manifests } : {}
+  };
+}
+function pluginCatalogConfigFromPluginSet(pluginSet) {
+  if (!pluginSet) {
+    return void 0;
+  }
+  const packages = [
+    .../* @__PURE__ */ new Set([
+      ...pluginSet.packageNames,
+      ...pluginSet.registrations.flatMap(
+        (plugin) => plugin.packageName ? [plugin.packageName] : []
+      )
+    ])
+  ];
+  const manifests = cloneManifests(pluginSet.manifests);
+  const inlineManifests = cloneInlineManifests(pluginSet.registrations);
+  if (packages.length === 0 && !manifests && !inlineManifests) {
+    return void 0;
+  }
+  return {
+    ...inlineManifests ? { inlineManifests } : {},
+    ...packages.length > 0 ? { packages } : {},
+    ...manifests ? { manifests } : {}
+  };
+}
+function readEnvPluginPackages(env = process.env) {
+  const value = env.JUNIOR_PLUGIN_PACKAGES;
+  if (!value) {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch (error) {
+    throw new Error("JUNIOR_PLUGIN_PACKAGES must be valid JSON", {
+      cause: error
+    });
+  }
+  if (!Array.isArray(parsed) || parsed.some((item) => typeof item !== "string" || !item.trim())) {
+    throw new Error(
+      "JUNIOR_PLUGIN_PACKAGES must be a JSON array of package names"
+    );
+  }
+  return parsed;
+}
+function pluginCatalogConfigFromEnv(env = process.env) {
+  const packages = readEnvPluginPackages(env);
+  return packages ? { packages } : void 0;
+}
+function pluginHookRegistrationsFromPluginSet(pluginSet) {
+  return pluginSet?.registrations.filter(
+    (plugin) => plugin.database || plugin.hooks
+  ) ?? [];
+}
+
+export {
+  defineJuniorPlugins,
+  pluginCatalogConfigFromPluginSet,
+  pluginCatalogConfigFromEnv,
+  pluginHookRegistrationsFromPluginSet
+};

package/dist/{chunk-CYUI7JU5.js → chunk-EIYL7I4S.js}

@@ -1,6 +1,6 @@
 import {
   isSlackTeamId
-} from "./chunk-3BYAPS6B.js";
+} from "./chunk-MCMROINU.js";
 
 // src/chat/requester.ts
 import { z } from "zod";