@sentry/junior 0.107.1 → 0.109.0

package/dist/chunk-TMBRFULF.js

@@ -0,0 +1,471 @@
+import {
+  juniorDestinations,
+  timestamptz
+} from "./chunk-VFUK3X5B.js";
+
+// src/db/neon.ts
+import { AsyncLocalStorage } from "async_hooks";
+import {
+  Pool
+} from "@neondatabase/serverless";
+import { drizzle } from "drizzle-orm/neon-serverless";
+import { migrate } from "drizzle-orm/neon-serverless/migrator";
+
+// src/db/schema/conversation-events.ts
+import {
+  foreignKey,
+  index as index3,
+  integer as integer2,
+  jsonb as jsonb3,
+  pgTable as pgTable4,
+  primaryKey,
+  text as text4,
+  uniqueIndex as uniqueIndex3
+} from "drizzle-orm/pg-core";
+import { sql as sql3 } from "drizzle-orm";
+
+// src/db/schema/conversations.ts
+import { sql as sql2 } from "drizzle-orm";
+import {
+  index as index2,
+  integer,
+  jsonb as jsonb2,
+  pgTable as pgTable3,
+  text as text3
+} from "drizzle-orm/pg-core";
+
+// src/db/schema/identities.ts
+import { sql } from "drizzle-orm";
+import {
+  boolean,
+  index,
+  jsonb,
+  pgTable as pgTable2,
+  text as text2,
+  uniqueIndex as uniqueIndex2
+} from "drizzle-orm/pg-core";
+
+// src/db/schema/users.ts
+import { text, pgTable, uniqueIndex } from "drizzle-orm/pg-core";
+var juniorUsers = pgTable(
+  "junior_users",
+  {
+    id: text("id").primaryKey(),
+    primaryEmail: text("primary_email").notNull(),
+    primaryEmailNormalized: text("primary_email_normalized").notNull(),
+    displayName: text("display_name"),
+    createdAt: timestamptz("created_at").notNull(),
+    updatedAt: timestamptz("updated_at").notNull()
+  },
+  (table) => [
+    uniqueIndex("junior_users_primary_email_normalized_uidx").on(
+      table.primaryEmailNormalized
+    )
+  ]
+);
+
+// src/db/schema/identities.ts
+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: jsonb("metadata_json"),
+    createdAt: timestamptz("created_at").notNull(),
+    updatedAt: timestamptz("updated_at").notNull(),
+    userId: text2("user_id").references(() => juniorUsers.id),
+    emailNormalized: text2("email_normalized"),
+    emailVerified: boolean("email_verified").notNull().default(false)
+  },
+  (table) => [
+    uniqueIndex2("junior_identities_provider_subject_uidx").on(
+      table.provider,
+      table.providerTenantId,
+      table.providerSubjectId
+    ),
+    index("junior_identities_user_idx").on(table.userId),
+    index("junior_identities_verified_email_idx").on(table.emailNormalized).where(
+      sql`${table.emailVerified} = true AND ${table.emailNormalized} IS NOT NULL`
+    ),
+    index("junior_identities_kind_provider_idx").on(table.kind, table.provider)
+  ]
+);
+
+// src/db/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: jsonb2("destination_json").$type(),
+    actorIdentityId: text3("actor_identity_id").references(
+      () => juniorIdentities.id
+    ),
+    creatorIdentityId: text3("creator_identity_id").references(
+      () => juniorIdentities.id
+    ),
+    credentialSubjectIdentityId: text3(
+      "credential_subject_identity_id"
+    ).references(() => juniorIdentities.id),
+    actor: jsonb2("actor_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"),
+    // Subagent runs are child conversations; top-level listings filter
+    // parent_conversation_id IS NULL. Historical advisor children use this too.
+    parentConversationId: text3("parent_conversation_id").references(
+      () => juniorConversations.conversationId
+    ),
+    transcriptPurgedAt: timestamptz("transcript_purged_at"),
+    durationMs: integer("duration_ms").notNull().default(0),
+    usage: jsonb2("usage_json").$type(),
+    executionDurationMs: integer("execution_duration_ms").notNull().default(0),
+    executionUsage: jsonb2("execution_usage_json").$type(),
+    metricRunId: text3("metric_run_id"),
+    archivedAt: timestamptz("archived_at")
+  },
+  (table) => [
+    index2("junior_conversations_last_activity_idx").on(
+      table.lastActivityAt.desc(),
+      table.conversationId
+    ),
+    index2("junior_conversations_active_idx").using(
+      "btree",
+      sql2`coalesce(${table.executionUpdatedAt}, ${table.updatedAt})`,
+      table.conversationId
+    ).where(sql2`${table.executionStatus} <> 'idle'`),
+    index2("junior_conversations_destination_activity_idx").on(
+      table.destinationId,
+      table.lastActivityAt.desc()
+    ),
+    index2("junior_conversations_actor_activity_idx").on(
+      table.actorIdentityId,
+      table.lastActivityAt.desc()
+    ),
+    index2("junior_conversations_origin_idx").on(
+      table.originType,
+      table.originId,
+      table.lastActivityAt.desc()
+    ),
+    index2("junior_conversations_parent_idx").on(table.parentConversationId)
+  ]
+);
+
+// src/db/schema/conversation-events.ts
+var juniorConversationEvents = pgTable4(
+  "junior_conversation_events",
+  {
+    conversationId: text4("conversation_id").notNull(),
+    seq: integer2("seq").notNull(),
+    historyVersion: integer2("history_version").notNull(),
+    schemaVersion: integer2("schema_version").default(1).notNull(),
+    idempotencyKey: text4("idempotency_key"),
+    type: text4("type").notNull(),
+    payload: jsonb3("payload").$type().notNull(),
+    createdAt: timestamptz("created_at").notNull()
+  },
+  (table) => [
+    primaryKey({
+      name: "junior_conversation_events_conversation_id_seq_pk",
+      columns: [table.conversationId, table.seq]
+    }),
+    foreignKey({
+      name: "junior_conversation_events_conversation_id_junior_conversations_conversation_id_fk",
+      columns: [table.conversationId],
+      foreignColumns: [juniorConversations.conversationId]
+    }),
+    index3("junior_conversation_events_history_version_idx").on(
+      table.conversationId,
+      table.historyVersion,
+      table.seq
+    ),
+    index3("junior_conversation_events_type_idx").on(
+      table.conversationId,
+      table.type,
+      table.seq
+    ),
+    index3("junior_conversation_events_message_search_idx").using("gin", sql3`to_tsvector('english', ${table.payload}->>'text')`).where(sql3`${table.type} = 'message'`),
+    uniqueIndex3("junior_conversation_events_idempotency_idx").on(
+      table.conversationId,
+      table.idempotencyKey
+    )
+  ]
+);
+
+// src/db/schema.ts
+var juniorSqlSchema = {
+  juniorConversationEvents,
+  juniorConversations,
+  juniorDestinations,
+  juniorIdentities,
+  juniorUsers
+};
+
+// src/db/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 migrate(config) {
+    await migrate(
+      drizzle(this.queryClient(), { schema: juniorSqlSchema }),
+      config
+    );
+  }
+  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 withMigrationLock(migrationTable, callback) {
+    const client = await this.pool.connect();
+    const lockName = `junior:migrate:${migrationTable}`;
+    try {
+      await client.query("SELECT pg_advisory_lock(hashtext($1))", [lockName]);
+      return await callback();
+    } finally {
+      client.release(true);
+    }
+  }
+  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/db/postgres.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+import pg from "pg";
+import { drizzle as drizzle2 } from "drizzle-orm/node-postgres";
+import { migrate as migrate2 } from "drizzle-orm/node-postgres/migrator";
+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 migrate(config) {
+    await migrate2(
+      drizzle2(this.queryClient(), { schema: juniorSqlSchema }),
+      config
+    );
+  }
+  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 withMigrationLock(migrationTable, callback) {
+    const client = await this.pool.connect();
+    const lockName = `junior:migrate:${migrationTable}`;
+    try {
+      await client.query("SELECT pg_advisory_lock(hashtext($1))", [lockName]);
+      return await callback();
+    } finally {
+      client.release(true);
+    }
+  }
+  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/db/executor.ts
+function createJuniorSqlExecutor(args) {
+  if (args.driver === "postgres") {
+    return createPostgresJuniorSqlExecutor(args);
+  }
+  return createNeonJuniorSqlExecutor(args);
+}
+
+export {
+  juniorUsers,
+  juniorIdentities,
+  juniorConversations,
+  juniorConversationEvents,
+  createJuniorSqlExecutor
+};

package/dist/{chunk-YIPD3L6L.js → chunk-TT6GMXNA.js}

@@ -1,11 +1,11 @@
 import {
   parseActorUserId
-} from "./chunk-VIXFG2VC.js";
+} from "./chunk-PLB7MRCQ.js";
 import {
   logInfo,
   logWarn,
   setSpanAttributes
-} from "./chunk-O24R4DCK.js";
+} from "./chunk-ISMWX44P.js";
 import {
   discoverInstalledPluginPackageContent,
   normalizePluginPackageNames
@@ -14,10 +14,6 @@ import {
   pluginRoots
 } from "./chunk-3V7OFJZC.js";
 
-// src/chat/plugins/registry.ts
-import { readFileSync, readdirSync, statSync } from "fs";
-import path from "path";
-
 // src/chat/plugins/manifest.ts
 import { z } from "zod";
 import { parse as parseYaml } from "yaml";
@@ -1070,6 +1066,10 @@ function parseInlinePluginManifest(manifest, dir, config) {
   });
 }
 
+// src/chat/plugins/registry.ts
+import { readFileSync, readdirSync, statSync } from "fs";
+import path from "path";
+
 // src/chat/plugins/auth/oauth-bearer-broker.ts
 import { randomUUID as randomUUID2 } from "crypto";
 
@@ -2066,19 +2066,17 @@ function createPluginCatalogRuntime() {
   };
 }
 
-// src/chat/plugins/catalog-runtime.ts
-var pluginCatalogRuntime = createPluginCatalogRuntime();
-
 export {
   parsePluginManifest,
   parseInlinePluginManifest,
   CredentialUnavailableError,
   credentialSubjectSchema,
   credentialContextSchema,
+  credentialUserSubjectId,
   hasRequiredOAuthScope,
   resolvePluginCommandEnv,
   resolveAuthTokenPlaceholder,
   buildOAuthTokenRequest,
   parseOAuthTokenResponse,
-  pluginCatalogRuntime
+  createPluginCatalogRuntime
 };

package/dist/{chunk-YT72TOEK.js → chunk-WHMOBKT7.js}

@@ -1,9 +1,9 @@
 import {
   pluginCatalogRuntime
-} from "./chunk-YIPD3L6L.js";
+} from "./chunk-3SXUV423.js";
 import {
   logWarn
-} from "./chunk-O24R4DCK.js";
+} from "./chunk-ISMWX44P.js";
 import {
   skillRoots
 } from "./chunk-3V7OFJZC.js";

package/dist/cli/chat.js

@@ -1,36 +1,36 @@
 import {
   createAgentRunner,
   executeAgentRun
-} from "../chunk-EDLNHZH3.js";
-import "../chunk-YFQ7CQDE.js";
-import "../chunk-4YF7Z6IA.js";
-import "../chunk-SPUAJVVH.js";
+} from "../chunk-IXKSQGIO.js";
+import "../chunk-72OMGPDS.js";
+import "../chunk-HO5NT6OE.js";
 import "../chunk-MU6HHZEN.js";
 import "../chunk-PDO5BLNM.js";
 import "../chunk-UIE3R5XU.js";
 import {
   loadAppPluginSet
 } from "../chunk-Y2CM7HXH.js";
-import "../chunk-RMVOAJRL.js";
-import "../chunk-AUUOHQAT.js";
-import "../chunk-G3E7SCME.js";
-import "../chunk-B2Z2H66D.js";
-import "../chunk-VH6KWKG2.js";
-import "../chunk-NVOTGWYX.js";
+import "../chunk-QY636HZU.js";
+import "../chunk-OUHNWH46.js";
+import "../chunk-RGX4V75M.js";
+import "../chunk-FENLIFJD.js";
+import "../chunk-TMBRFULF.js";
 import "../chunk-4ZNGQH7C.js";
-import "../chunk-SS67LUOK.js";
+import "../chunk-JNAVF45E.js";
 import "../chunk-VFUK3X5B.js";
-import "../chunk-RT5BUHR5.js";
-import "../chunk-B7PUBQQM.js";
-import "../chunk-YT72TOEK.js";
-import "../chunk-YIPD3L6L.js";
-import "../chunk-VIXFG2VC.js";
-import "../chunk-O24R4DCK.js";
+import "../chunk-O3JMSZLI.js";
+import "../chunk-SYAQIR5Z.js";
+import "../chunk-WHMOBKT7.js";
+import "../chunk-3SXUV423.js";
+import "../chunk-TT6GMXNA.js";
+import "../chunk-PLB7MRCQ.js";
+import "../chunk-ISMWX44P.js";
 import "../chunk-OB42YVAE.js";
 import "../chunk-6GWA276C.js";
 import "../chunk-B3IT5END.js";
-import "../chunk-7FBGKXPE.js";
 import "../chunk-3V7OFJZC.js";
+import "../chunk-IVVGFRQQ.js";
+import "../chunk-OCD3OZRK.js";
 import "../chunk-MLKGABMK.js";
 
 // src/cli/chat.ts
@@ -153,10 +153,10 @@ async function configureLocalChatPlugins(pluginSet) {
     databaseModule
   ] = await Promise.all([
     import("../plugins-PZMDS7AT.js"),
-    import("../agent-hooks-ICPIJAFY.js"),
-    import("../catalog-runtime-FOFNPR3P.js"),
-    import("../validation-AGQ46ZGV.js"),
-    import("../db-DIGO4TGW.js")
+    import("../agent-hooks-FHHVLNPA.js"),
+    import("../catalog-runtime-DMGJSLV2.js"),
+    import("../validation-72N3JVRU.js"),
+    import("../db-V3NU72O2.js")
   ]);
   const resolvedPluginSet = pluginSet === void 0 ? await loadLocalPluginSet() : pluginSet ?? void 0;
   const plugins = pluginsModule.pluginRuntimeRegistrationsFromPluginSet(resolvedPluginSet);
@@ -217,7 +217,7 @@ function newRunConversationId() {
 async function prepareLocalChatRun(io, pluginSet) {
   defaultStateAdapterForLocalChat();
   await configureLocalChatPlugins(pluginSet);
-  const { runLocalAgentTurn } = await import("../runner-ACR2HAIC.js");
+  const { runLocalAgentTurn } = await import("../runner-JYBCQBLK.js");
   const deps = {
     agentRunner: createAgentRunner(executeAgentRun),
     deliverReply: async (reply) => {

package/dist/cli/check.js

@@ -1,21 +1,23 @@
 import {
   parseSkillFile
-} from "../chunk-YT72TOEK.js";
+} from "../chunk-WHMOBKT7.js";
+import "../chunk-3SXUV423.js";
 import {
   parseInlinePluginManifest,
   parsePluginManifest
-} from "../chunk-YIPD3L6L.js";
-import "../chunk-VIXFG2VC.js";
-import "../chunk-O24R4DCK.js";
+} from "../chunk-TT6GMXNA.js";
+import "../chunk-PLB7MRCQ.js";
+import "../chunk-ISMWX44P.js";
 import "../chunk-OB42YVAE.js";
 import "../chunk-6GWA276C.js";
 import "../chunk-B3IT5END.js";
+import "../chunk-3V7OFJZC.js";
 import {
   JUNIOR_CONVERSATION_WORK_CALLBACK_ROUTE,
   JUNIOR_HEARTBEAT_ROUTE,
   LEGACY_JUNIOR_CONVERSATION_WORK_FUNCTION
-} from "../chunk-7FBGKXPE.js";
-import "../chunk-3V7OFJZC.js";
+} from "../chunk-IVVGFRQQ.js";
+import "../chunk-OCD3OZRK.js";
 import "../chunk-MLKGABMK.js";
 
 // src/cli/check.ts