@sentry/junior 0.108.0 → 0.109.0

package/dist/{chunk-UD6THJ2I.js → chunk-QY636HZU.js}

@@ -1,38 +1,36 @@
 import {
-  createPluginLogger,
-  createPluginState
-} from "./chunk-AHJR2IFF.js";
-import {
-  SANDBOX_WORKSPACE_ROOT
-} from "./chunk-G3E7SCME.js";
+  SANDBOX_WORKSPACE_ROOT,
+  getStateAdapter
+} from "./chunk-OUHNWH46.js";
 import {
   isConversationChannel,
   isConversationScopedChannel,
   isDmChannel,
   normalizeSlackConversationId
-} from "./chunk-VH6KWKG2.js";
+} from "./chunk-RGX4V75M.js";
 import {
   getDb
-} from "./chunk-TE4QHJH4.js";
+} from "./chunk-FENLIFJD.js";
 import {
   botConfig,
   completeObject,
   embedTexts,
   standardModelId
-} from "./chunk-SS67LUOK.js";
+} from "./chunk-JNAVF45E.js";
 import {
   isActorUserId,
   parseActorUserId
-} from "./chunk-VIXFG2VC.js";
+} from "./chunk-PLB7MRCQ.js";
 import {
+  logException,
   logInfo,
   logWarn
-} from "./chunk-O24R4DCK.js";
+} from "./chunk-ISMWX44P.js";
 import {
   parseSlackChannelReferenceId,
   parseSlackMessageTs,
   parseSlackTeamId
-} from "./chunk-7FBGKXPE.js";
+} from "./chunk-IVVGFRQQ.js";
 
 // src/chat/plugins/agent-hooks.ts
 import {
@@ -40,6 +38,37 @@ import {
   resourceEventSchema
 } from "@sentry/junior-plugin-api";
 
+// src/chat/plugins/logging.ts
+function createPluginLogger(plugin) {
+  return {
+    info(message, metadata) {
+      logInfo(
+        "agent_plugin_log_info",
+        {},
+        { "app.plugin.name": plugin, ...metadata },
+        message
+      );
+    },
+    warn(message, metadata) {
+      logWarn(
+        "agent_plugin_log_warn",
+        {},
+        { "app.plugin.name": plugin, ...metadata },
+        message
+      );
+    },
+    error(message, metadata) {
+      logException(
+        new Error(message),
+        "agent_plugin_log_error",
+        {},
+        { "app.plugin.name": plugin, ...metadata },
+        message
+      );
+    }
+  };
+}
+
 // src/chat/plugins/model.ts
 function createPluginModel(pluginName, options = {}, runtime = {}) {
   return {
@@ -77,6 +106,77 @@ function createPluginEmbedder(pluginName, runtime = {}) {
   };
 }
 
+// src/chat/plugins/state.ts
+import { createHash } from "crypto";
+var MAX_PLUGIN_STATE_KEY_LENGTH = 512;
+function hashKeyPart(value) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 32);
+}
+function pluginStateKey(plugin, key) {
+  const pluginPrefix = `junior:${plugin}`;
+  if (key === pluginPrefix || key.startsWith(`${pluginPrefix}:`)) {
+    return key;
+  }
+  return `junior:plugin_state:${hashKeyPart(plugin)}:${hashKeyPart(key)}`;
+}
+function validatePluginStateKey(key) {
+  if (!key.trim()) {
+    throw new Error("Plugin state key is required");
+  }
+  if (key.length > MAX_PLUGIN_STATE_KEY_LENGTH) {
+    throw new Error("Plugin state key exceeds the maximum length");
+  }
+}
+function createPluginState(plugin, adapter) {
+  const getAdapter = () => adapter ?? getStateAdapter();
+  return {
+    async delete(key) {
+      validatePluginStateKey(key);
+      const state = getAdapter();
+      await state.connect();
+      await state.delete(pluginStateKey(plugin, key));
+    },
+    async get(key) {
+      validatePluginStateKey(key);
+      const state = getAdapter();
+      await state.connect();
+      const value = await state.get(pluginStateKey(plugin, key));
+      return value ?? void 0;
+    },
+    async set(key, value, ttlMs) {
+      validatePluginStateKey(key);
+      const state = getAdapter();
+      await state.connect();
+      await state.set(pluginStateKey(plugin, key), value, ttlMs);
+    },
+    async setIfNotExists(key, value, ttlMs) {
+      validatePluginStateKey(key);
+      const state = getAdapter();
+      await state.connect();
+      return await state.setIfNotExists(
+        pluginStateKey(plugin, key),
+        value,
+        ttlMs
+      );
+    },
+    async withLock(key, ttlMs, callback) {
+      validatePluginStateKey(key);
+      const state = getAdapter();
+      await state.connect();
+      const lockKey = pluginStateKey(plugin, key);
+      const lock = await state.acquireLock(lockKey, ttlMs);
+      if (!lock) {
+        throw new Error(`Could not acquire plugin state lock for ${key}`);
+      }
+      try {
+        return await callback();
+      } finally {
+        await state.releaseLock(lock);
+      }
+    }
+  };
+}
+
 // src/chat/slack/dashboard-link.ts
 var dashboardConversationLinkOptions;
 function withHttps(host) {
@@ -1105,8 +1205,10 @@ function createPluginHookRunner(input = {}) {
 }
 
 export {
+  createPluginLogger,
   createPluginModel,
   createPluginEmbedder,
+  createPluginState,
   setDashboardConversationLinkOptions,
   getDashboardConversationLink,
   getSlackToolContext,

package/dist/{chunk-VH6KWKG2.js → chunk-RGX4V75M.js}

@@ -3,16 +3,16 @@ import {
 } from "./chunk-4ZNGQH7C.js";
 import {
   getSlackBotToken
-} from "./chunk-SS67LUOK.js";
+} from "./chunk-JNAVF45E.js";
 import {
   logWarn,
   setSpanAttributes,
   setSpanStatus,
   withSpan
-} from "./chunk-O24R4DCK.js";
+} from "./chunk-ISMWX44P.js";
 import {
   parseSlackChannelReferenceId
-} from "./chunk-7FBGKXPE.js";
+} from "./chunk-IVVGFRQQ.js";
 
 // src/chat/slack/client.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";

package/dist/{chunk-B7PUBQQM.js → chunk-SYAQIR5Z.js}

@@ -1,7 +1,7 @@
 import {
   parseSlackChannelReferenceId,
   parseSlackTeamId
-} from "./chunk-7FBGKXPE.js";
+} from "./chunk-IVVGFRQQ.js";
 
 // src/chat/destination.ts
 import {

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
+};