@sentry/junior 0.108.0 → 0.110.0

package/dist/chunk-JQFJO5WH.js

@@ -0,0 +1,477 @@
+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
+    ),
+    // Roots reference themselves; descendants reference the root whose actor
+    // and destination own their privacy boundary.
+    rootConversationId: text3("root_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),
+    index2("junior_conversations_root_idx").on(table.rootConversationId)
+  ]
+);
+
+// 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-VH6KWKG2.js → chunk-L5XQPJ7T.js}

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

package/dist/{chunk-2XXEKR44.js → chunk-MIAKQNYX.js}

@@ -1,16 +1,39 @@
 import {
   createVercelQueueClient
 } from "./chunk-KNFROR7R.js";
-import {
-  destinationKey,
-  parseDestination
-} from "./chunk-B7PUBQQM.js";
 
 // src/chat/task-execution/queue-signing.ts
 import { createHmac, timingSafeEqual } from "crypto";
-var CONVERSATION_WORK_QUEUE_SIGNATURE_CONTEXT = "junior.conversation_work_queue.v1";
-var CONVERSATION_WORK_QUEUE_SIGNATURE_VERSION = "v1";
+import { z as z2 } from "zod";
+
+// src/chat/task-execution/queue.ts
+import { z } from "zod";
+var conversationQueueMessageSchema = z.object({
+  conversationId: z.string().trim().min(1)
+}).strict();
+var ConversationQueueMessageRejectedError = class extends Error {
+  conversationId;
+  reason;
+  constructor(reason, message, options = {}) {
+    super(message);
+    this.name = "ConversationQueueMessageRejectedError";
+    this.reason = reason;
+    this.conversationId = options.conversationId;
+  }
+};
+function isConversationQueueMessageRejectedError(error) {
+  return error instanceof ConversationQueueMessageRejectedError;
+}
+
+// src/chat/task-execution/queue-signing.ts
+var CONVERSATION_WORK_QUEUE_SIGNATURE_CONTEXT = "junior.conversation_work_queue.v2";
+var CONVERSATION_WORK_QUEUE_SIGNATURE_VERSION = "v2";
 var CONVERSATION_WORK_QUEUE_SIGNATURE_MAX_SKEW_MS = 60 * 60 * 1e3;
+var signedConversationQueueMessageSchema = conversationQueueMessageSchema.extend({
+  signature: z2.string().trim().min(1),
+  signatureVersion: z2.literal(CONVERSATION_WORK_QUEUE_SIGNATURE_VERSION),
+  signedAtMs: z2.number().finite()
+}).strict();
 function getConversationWorkQueueSecret() {
   return process.env.JUNIOR_SECRET?.trim() || void 0;
 }
@@ -18,12 +41,11 @@ function buildSignedPayload(message, signedAtMs) {
   return [
     CONVERSATION_WORK_QUEUE_SIGNATURE_CONTEXT,
     signedAtMs,
-    message.conversationId,
-    destinationKey(message.destination)
+    message.conversationId
   ].join(":");
 }
-function signPayload(message, signedAtMs, secret) {
-  return createHmac("sha256", secret).update(buildSignedPayload(message, signedAtMs)).digest("hex");
+function signPayload(payload, secret) {
+  return createHmac("sha256", secret).update(payload).digest("hex");
 }
 function timingSafeMatch(expected, actual) {
   const expectedBuffer = Buffer.from(expected);
@@ -34,21 +56,8 @@ function timingSafeMatch(expected, actual) {
   return timingSafeEqual(expectedBuffer, actualBuffer);
 }
 function parseSignedConversationQueueMessage(value) {
-  if (!value || typeof value !== "object") {
-    return void 0;
-  }
-  const record = value;
-  const destination = parseDestination(record.destination);
-  if (typeof record.conversationId !== "string" || !record.conversationId.trim() || !destination || record.signatureVersion !== CONVERSATION_WORK_QUEUE_SIGNATURE_VERSION || typeof record.signedAtMs !== "number" || !Number.isFinite(record.signedAtMs) || typeof record.signature !== "string" || !record.signature.trim()) {
-    return void 0;
-  }
-  return {
-    conversationId: record.conversationId,
-    destination,
-    signature: record.signature,
-    signatureVersion: CONVERSATION_WORK_QUEUE_SIGNATURE_VERSION,
-    signedAtMs: record.signedAtMs
-  };
+  const parsed = signedConversationQueueMessageSchema.safeParse(value);
+  return parsed.success ? parsed.data : void 0;
 }
 function signConversationQueueMessage(message, nowMs = Date.now()) {
   const secret = getConversationWorkQueueSecret();
@@ -61,7 +70,7 @@ function signConversationQueueMessage(message, nowMs = Date.now()) {
     ...message,
     signedAtMs: nowMs,
     signatureVersion: CONVERSATION_WORK_QUEUE_SIGNATURE_VERSION,
-    signature: signPayload(message, nowMs, secret)
+    signature: signPayload(buildSignedPayload(message, nowMs), secret)
   };
 }
 function verifyConversationQueueMessage(value, nowMs = Date.now()) {
@@ -79,16 +88,16 @@ function verifyConversationQueueMessage(value, nowMs = Date.now()) {
   if (Math.abs(nowMs - message.signedAtMs) > CONVERSATION_WORK_QUEUE_SIGNATURE_MAX_SKEW_MS) {
     return { status: "rejected", reason: "expired" };
   }
-  const expected = signPayload(message, message.signedAtMs, secret);
+  const expected = signPayload(
+    buildSignedPayload(message, message.signedAtMs),
+    secret
+  );
   if (!timingSafeMatch(expected, message.signature)) {
     return { status: "rejected", reason: "signature_mismatch" };
   }
   return {
     status: "verified",
-    message: {
-      conversationId: message.conversationId,
-      destination: message.destination
-    }
+    message: { conversationId: message.conversationId }
   };
 }
 
@@ -130,6 +139,9 @@ function getVercelConversationWorkQueue() {
 }
 
 export {
+  conversationQueueMessageSchema,
+  ConversationQueueMessageRejectedError,
+  isConversationQueueMessageRejectedError,
   verifyConversationQueueMessage,
   resolveConversationWorkQueueTopic,
   getVercelConversationWorkQueue