@sentry/junior 0.145.0 → 0.147.0

package/dist/chunk-AZ7EAOBE.js

@@ -0,0 +1,566 @@
+import {
+  persistConversationMessages
+} from "./chunk-AIOK6LAG.js";
+import {
+  JUNIOR_THREAD_STATE_TTL_MS
+} from "./chunk-3Y47VMHV.js";
+import {
+  getDb
+} from "./chunk-YSB2N563.js";
+import {
+  juniorLocationConfigurations
+} from "./chunk-DU74WPIC.js";
+import {
+  getStateAdapter
+} from "./chunk-ORO3PWKQ.js";
+import {
+  juniorDestinations
+} from "./chunk-VFUK3X5B.js";
+import {
+  isRecord,
+  toOptionalNumber,
+  toOptionalString
+} from "./chunk-4LJO56OJ.js";
+
+// src/chat/conversations/turn-lifecycle.ts
+var ConversationTurnLifecycleService = class {
+  constructor(events) {
+    this.events = events;
+  }
+  events;
+  /** Record the turn start once after every input message is durable. */
+  async start(input) {
+    await this.events.append(input.conversationId, [
+      {
+        idempotencyKey: `turn:${input.turnId}:started`,
+        createdAtMs: input.createdAtMs,
+        data: {
+          type: "turn_started",
+          turnId: input.turnId,
+          inputMessageIds: input.inputMessageIds,
+          surface: input.surface
+        }
+      }
+    ]);
+  }
+  /** Record successful or intentional-silence completion once. */
+  async complete(input) {
+    await this.events.append(input.conversationId, [
+      {
+        idempotencyKey: `turn:${input.turnId}:terminal`,
+        createdAtMs: input.createdAtMs,
+        data: {
+          type: "turn_completed",
+          turnId: input.turnId,
+          outcome: input.outcome
+        }
+      }
+    ]);
+  }
+  /** Record a classified failure once without accepting raw error details. */
+  async fail(input) {
+    await this.events.append(input.conversationId, [
+      {
+        idempotencyKey: `turn:${input.turnId}:terminal`,
+        createdAtMs: input.createdAtMs,
+        data: {
+          type: "turn_failed",
+          turnId: input.turnId,
+          failureCode: input.failureCode,
+          ...input.eventId ? { eventId: input.eventId } : {}
+        }
+      }
+    ]);
+  }
+};
+
+// src/chat/state/conversation.ts
+function defaultConversationState() {
+  return {
+    schemaVersion: 1,
+    messages: [],
+    compactions: [],
+    processing: {},
+    vision: {
+      byFileId: {}
+    }
+  };
+}
+function coercePendingAuthState(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const kind = value.kind;
+  const provider = toOptionalString(value.provider);
+  const actorId = toOptionalString(value.actorId);
+  const authSessionId = toOptionalString(value.authSessionId);
+  const scope = toOptionalString(value.scope);
+  const sessionId = toOptionalString(value.sessionId);
+  const linkSentAtMs = toOptionalNumber(value.linkSentAtMs);
+  if (kind !== "mcp" && kind !== "plugin" || !provider || !actorId || kind === "mcp" && !authSessionId || !sessionId || typeof linkSentAtMs !== "number") {
+    return void 0;
+  }
+  const base = {
+    provider,
+    actorId,
+    ...scope ? { scope } : {},
+    sessionId,
+    linkSentAtMs
+  };
+  return kind === "mcp" ? { ...base, authSessionId, kind } : { ...base, kind };
+}
+function coerceThreadConversationState(value) {
+  if (!isRecord(value)) {
+    return defaultConversationState();
+  }
+  const root = value;
+  const rawConversation = isRecord(root.conversation) ? root.conversation : {};
+  const messages = [];
+  const compactions = [];
+  const rawProcessing = isRecord(rawConversation.processing) ? rawConversation.processing : {};
+  const processing = {
+    activeTurnId: toOptionalString(rawProcessing.activeTurnId),
+    lastCompletedAtMs: toOptionalNumber(rawProcessing.lastCompletedAtMs),
+    pendingAuth: coercePendingAuthState(rawProcessing.pendingAuth)
+  };
+  const rawVision = isRecord(rawConversation.vision) ? rawConversation.vision : {};
+  const rawVisionByFileId = isRecord(rawVision.byFileId) ? rawVision.byFileId : {};
+  const byFileId = {};
+  for (const [fileId, value2] of Object.entries(rawVisionByFileId)) {
+    if (typeof fileId !== "string" || fileId.trim().length === 0) continue;
+    if (!isRecord(value2)) continue;
+    const summary = toOptionalString(value2.summary);
+    const analyzedAtMs = toOptionalNumber(value2.analyzedAtMs);
+    if (!summary || !analyzedAtMs) continue;
+    byFileId[fileId] = {
+      summary,
+      analyzedAtMs
+    };
+  }
+  return {
+    schemaVersion: 1,
+    messages,
+    compactions,
+    processing,
+    vision: {
+      backfillCompletedAtMs: toOptionalNumber(rawVision.backfillCompletedAtMs),
+      byFileId
+    }
+  };
+}
+function buildConversationStatePatch(conversation) {
+  return {
+    conversation: {
+      schemaVersion: 1,
+      processing: { ...conversation.processing }
+    }
+  };
+}
+
+// src/chat/configuration/sql.ts
+import { randomUUID } from "crypto";
+import { and, eq, sql } from "drizzle-orm";
+
+// src/chat/configuration/types.ts
+import { z } from "zod";
+var configValueSchema = z.json();
+
+// src/chat/configuration/validation.ts
+var CONFIG_KEY_RE = /^[a-z0-9]+(?:\.[a-z0-9-]+)+$/;
+var SECRET_KEY_RE = /(?:^|[_.-])(token|secret|password|passphrase|api[-_]?key|private[-_]?key|credential|auth)(?:$|[_.-])/i;
+var SECRET_VALUE_PATTERNS = [
+  /\bBearer\s+[A-Za-z0-9._-]{16,}\b/i,
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----/,
+  /\b(?:ghp|ghs|github_pat)_[A-Za-z0-9_]{20,}\b/,
+  /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/i,
+  /\bsk-[A-Za-z0-9]{20,}\b/,
+  /\bAIza[0-9A-Za-z\-_]{30,}\b/,
+  /\bAKIA[0-9A-Z]{16}\b/,
+  /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/
+];
+function validateConfigKey(key) {
+  const trimmed = key.trim();
+  if (!trimmed) {
+    return "Configuration key must not be empty";
+  }
+  if (!CONFIG_KEY_RE.test(trimmed)) {
+    return `Invalid configuration key "${key}"; expected dotted lowercase namespace (for example "provider.repo")`;
+  }
+  if (SECRET_KEY_RE.test(trimmed)) {
+    return `Configuration key "${key}" appears to be secret-related and is not allowed`;
+  }
+  return void 0;
+}
+function collectStringValues(value, output, depth = 0) {
+  if (depth > 5) {
+    return;
+  }
+  if (typeof value === "string") {
+    output.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectStringValues(item, output, depth + 1);
+    }
+    return;
+  }
+  if (value && typeof value === "object") {
+    for (const [key, nested] of Object.entries(
+      value
+    )) {
+      output.push(key);
+      collectStringValues(nested, output, depth + 1);
+    }
+  }
+}
+function validateConfigValue(value) {
+  const stringValues = [];
+  collectStringValues(value, stringValues);
+  for (const text of stringValues) {
+    for (const pattern of SECRET_VALUE_PATTERNS) {
+      if (pattern.test(text)) {
+        return "Configuration value appears to contain secret material and is not allowed";
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/chat/configuration/service.ts
+function sanitizeEntry(value) {
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  const key = toOptionalString(value.key);
+  if (!key || validateConfigKey(key)) {
+    return void 0;
+  }
+  const updatedAt = toOptionalString(value.updatedAt);
+  if (!updatedAt) {
+    return void 0;
+  }
+  if (value.scope !== "channel" && value.scope !== "conversation" && value.scope !== "location") {
+    return void 0;
+  }
+  const parsedValue = configValueSchema.safeParse(value.value);
+  if (!parsedValue.success) {
+    return void 0;
+  }
+  return {
+    key,
+    value: parsedValue.data,
+    scope: "location",
+    updatedAt,
+    updatedBy: toOptionalString(value.updatedBy),
+    source: toOptionalString(value.source),
+    expiresAt: toOptionalString(value.expiresAt)
+  };
+}
+function coerceLegacyLocationConfig(raw) {
+  const rawConfig = isRecord(raw) && isRecord(raw.configuration) ? raw.configuration : {};
+  const rawEntries = isRecord(rawConfig.entries) ? rawConfig.entries : {};
+  return Object.values(rawEntries).flatMap((value) => {
+    const entry = sanitizeEntry(value);
+    return entry ? [entry] : [];
+  });
+}
+function createLocationConfigurationService(storage) {
+  const get = async (key) => await storage.get(key.trim());
+  const set = async (input) => {
+    const normalizedKey = input.key.trim();
+    const keyError = validateConfigKey(normalizedKey);
+    if (keyError) {
+      throw new Error(keyError);
+    }
+    const value = configValueSchema.parse(input.value);
+    const valueError = validateConfigValue(value);
+    if (valueError) {
+      throw new Error(valueError);
+    }
+    const entry = {
+      key: normalizedKey,
+      value,
+      scope: "location",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedBy: toOptionalString(input.updatedBy),
+      source: toOptionalString(input.source),
+      expiresAt: toOptionalString(input.expiresAt)
+    };
+    await storage.set(entry);
+    return entry;
+  };
+  const unset = async (key) => await storage.unset(key.trim());
+  const list = async (options = {}) => {
+    const prefix = options.prefix?.trim();
+    return (await storage.list()).filter((entry) => prefix ? entry.key.startsWith(prefix) : true).sort((a, b) => a.key.localeCompare(b.key));
+  };
+  const resolve = async (key) => (await get(key))?.value;
+  const resolveValues = async (options = {}) => {
+    const keys = options.keys?.map((key) => key.trim()).filter(Boolean);
+    const entries = await list(options.prefix ? { prefix: options.prefix } : {});
+    return Object.fromEntries(
+      entries.filter((entry) => !keys || keys.includes(entry.key)).map((entry) => [entry.key, entry.value])
+    );
+  };
+  return { get, set, unset, list, resolve, resolveValues };
+}
+
+// src/chat/configuration/sql.ts
+async function resolveLocationId(db, destination) {
+  const channelId = destination.channelId;
+  const now = /* @__PURE__ */ new Date();
+  const rows = await db.insert(juniorDestinations).values({
+    id: randomUUID(),
+    provider: "slack",
+    providerTenantId: destination.teamId,
+    providerDestinationId: channelId,
+    kind: channelId.startsWith("D") ? "dm" : channelId.startsWith("G") ? "group" : "channel",
+    parentDestinationId: null,
+    displayName: null,
+    visibility: "unknown",
+    metadata: { platform: "slack" },
+    createdAt: now,
+    updatedAt: now
+  }).onConflictDoUpdate({
+    target: [
+      juniorDestinations.provider,
+      juniorDestinations.providerTenantId,
+      juniorDestinations.providerDestinationId
+    ],
+    set: { id: sql`${juniorDestinations.id}` }
+  }).returning({ id: juniorDestinations.id });
+  const location = rows[0];
+  if (!location) {
+    throw new Error("Location upsert returned no row");
+  }
+  return location.id;
+}
+function createSqlLocationConfigurationStorage(db, destination) {
+  const locationWhere = and(
+    eq(juniorDestinations.provider, "slack"),
+    eq(juniorDestinations.providerTenantId, destination.teamId),
+    eq(juniorDestinations.providerDestinationId, destination.channelId)
+  );
+  const selectEntries = () => db.select({
+    key: juniorLocationConfigurations.key,
+    value: juniorLocationConfigurations.value,
+    updatedAt: juniorLocationConfigurations.updatedAt,
+    updatedBy: juniorLocationConfigurations.updatedBy,
+    source: juniorLocationConfigurations.source,
+    expiresAt: juniorLocationConfigurations.expiresAt
+  }).from(juniorLocationConfigurations).innerJoin(
+    juniorDestinations,
+    eq(juniorDestinations.id, juniorLocationConfigurations.locationId)
+  );
+  const entryFromRow = (row) => ({
+    key: row.key,
+    value: configValueSchema.parse(JSON.parse(row.value)),
+    scope: "location",
+    updatedAt: row.updatedAt.toISOString(),
+    updatedBy: row.updatedBy ?? void 0,
+    source: row.source ?? void 0,
+    expiresAt: row.expiresAt ?? void 0
+  });
+  const list = async () => (await selectEntries().where(locationWhere)).map(entryFromRow);
+  const set = async (entry) => {
+    const locationId = await resolveLocationId(db, destination);
+    await db.insert(juniorLocationConfigurations).values({
+      locationId,
+      key: entry.key,
+      value: JSON.stringify(entry.value),
+      updatedAt: new Date(entry.updatedAt),
+      updatedBy: entry.updatedBy,
+      source: entry.source,
+      expiresAt: entry.expiresAt
+    }).onConflictDoUpdate({
+      target: [
+        juniorLocationConfigurations.locationId,
+        juniorLocationConfigurations.key
+      ],
+      set: {
+        value: JSON.stringify(entry.value),
+        updatedAt: new Date(entry.updatedAt),
+        updatedBy: entry.updatedBy,
+        source: entry.source,
+        expiresAt: entry.expiresAt
+      }
+    });
+  };
+  return {
+    get: async (key) => {
+      const rows = await selectEntries().where(and(locationWhere, eq(juniorLocationConfigurations.key, key))).limit(1);
+      return rows[0] ? entryFromRow(rows[0]) : void 0;
+    },
+    list,
+    set,
+    unset: async (key) => {
+      const locationId = await resolveLocationId(db, destination);
+      const rows = await db.delete(juniorLocationConfigurations).where(
+        and(
+          eq(juniorLocationConfigurations.locationId, locationId),
+          eq(juniorLocationConfigurations.key, key)
+        )
+      ).returning({ key: juniorLocationConfigurations.key });
+      return rows.length > 0;
+    },
+    insertLegacy: async (entries) => {
+      if (entries.length === 0) {
+        return;
+      }
+      const locationId = await resolveLocationId(db, destination);
+      await db.insert(juniorLocationConfigurations).values(
+        entries.map((entry) => ({
+          locationId,
+          key: entry.key,
+          value: JSON.stringify(entry.value),
+          updatedAt: new Date(entry.updatedAt),
+          updatedBy: entry.updatedBy,
+          source: entry.source,
+          expiresAt: entry.expiresAt
+        }))
+      ).onConflictDoNothing();
+    }
+  };
+}
+function createDurableLocationConfigurationService(args) {
+  const storage = createSqlLocationConfigurationStorage(args.db, args.destination);
+  let cutover;
+  const ensureCutover = () => cutover ??= (async () => {
+    if ((await storage.list()).length > 0) {
+      return;
+    }
+    const legacy = coerceLegacyLocationConfig(await args.loadLegacy());
+    await storage.insertLegacy(legacy);
+  })();
+  return createLocationConfigurationService({
+    get: async (key) => {
+      await ensureCutover();
+      return await storage.get(key);
+    },
+    list: async () => {
+      await ensureCutover();
+      return await storage.list();
+    },
+    set: async (entry) => {
+      await ensureCutover();
+      await storage.set(entry);
+    },
+    unset: async (key) => {
+      await ensureCutover();
+      return await storage.unset(key);
+    }
+  });
+}
+
+// src/chat/runtime/thread-state.ts
+function threadStateKey(threadId) {
+  return `thread-state:${threadId}`;
+}
+function channelStateKey(channelId) {
+  return `channel-state:${channelId}`;
+}
+function buildThreadStatePayload(patch) {
+  const payload = {};
+  if (patch.conversation) {
+    Object.assign(payload, buildConversationStatePatch(patch.conversation));
+  }
+  if (patch.sandboxRef !== void 0) {
+    payload.app_sandbox_id = patch.sandboxRef?.id ?? "";
+    payload.app_sandbox_dependency_profile_hash = patch.sandboxRef?.profileHash ?? "";
+  }
+  return payload;
+}
+async function mergePersistedState(key, payload) {
+  if (Object.keys(payload).length === 0) {
+    return;
+  }
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  const existing = await stateAdapter.get(key) ?? {};
+  await stateAdapter.set(
+    key,
+    { ...existing, ...payload },
+    JUNIOR_THREAD_STATE_TTL_MS
+  );
+}
+function getPersistedSandboxState(state) {
+  const id = toOptionalString(state.app_sandbox_id);
+  if (!id) {
+    return void 0;
+  }
+  const profileHash = toOptionalString(
+    state.app_sandbox_dependency_profile_hash
+  );
+  return {
+    id,
+    ...profileHash ? { profileHash } : {}
+  };
+}
+async function persistThreadState(thread, patch) {
+  if (patch.conversation) {
+    await persistConversationMessages({
+      conversation: patch.conversation,
+      conversationId: toOptionalString(thread.id) ?? toOptionalString(thread.runId)
+    });
+  }
+  await persistThreadRuntimeState(thread, patch);
+}
+async function persistThreadRuntimeState(thread, patch) {
+  const threadId = toOptionalString(thread.id) ?? toOptionalString(thread.runId);
+  if (!threadId) {
+    throw new Error("thread id is required to persist runtime scratch");
+  }
+  await mergePersistedState(
+    threadStateKey(threadId),
+    buildThreadStatePayload(patch)
+  );
+}
+async function getPersistedThreadState(threadId) {
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  return await stateAdapter.get(
+    threadStateKey(threadId)
+  ) ?? {};
+}
+async function persistThreadStateById(threadId, patch) {
+  if (patch.conversation) {
+    await persistConversationMessages({
+      conversation: patch.conversation,
+      conversationId: threadId
+    });
+  }
+  await mergePersistedState(
+    threadStateKey(threadId),
+    buildThreadStatePayload(patch)
+  );
+}
+async function getLegacyChannelState(channelId) {
+  const stateAdapter = getStateAdapter();
+  await stateAdapter.connect();
+  return await stateAdapter.get(
+    channelStateKey(channelId)
+  ) ?? {};
+}
+function getLocationConfigurationService(destination) {
+  if (destination.platform !== "slack") {
+    throw new Error("Location configuration requires a Slack Location");
+  }
+  return createDurableLocationConfigurationService({
+    destination,
+    db: getDb(),
+    loadLegacy: async () => await getLegacyChannelState(destination.channelId)
+  });
+}
+
+export {
+  ConversationTurnLifecycleService,
+  configValueSchema,
+  coerceThreadConversationState,
+  getPersistedSandboxState,
+  persistThreadState,
+  persistThreadRuntimeState,
+  getPersistedThreadState,
+  persistThreadStateById,
+  getLocationConfigurationService
+};

package/dist/{chunk-DXEQAIUV.js → chunk-CSZINQJ2.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-F3B2YJ76.js";
 import {
   toOptionalString
-} from "./chunk-2LWPFSB4.js";
+} from "./chunk-4LJO56OJ.js";
 
 // src/chat/slack/context.ts
 import { z } from "zod";

package/dist/{chunk-HLOUZC5C.js → chunk-CWP5RHVX.js}

@@ -8,14 +8,14 @@ import {
   getConversationStore,
   parseDestination,
   sameDestination
-} from "./chunk-2UH3JI64.js";
+} from "./chunk-YSB2N563.js";
 import {
   getDefaultRedisStateAdapterFor,
   getStateAdapter
-} from "./chunk-QUG4JSZK.js";
+} from "./chunk-ORO3PWKQ.js";
 import {
   getChatConfig
-} from "./chunk-XFKIRN3Q.js";
+} from "./chunk-7NVJVJID.js";
 import {
   parseStoredSlackActor
 } from "./chunk-HZF5P5UN.js";
@@ -23,7 +23,7 @@ import {
   isRecord,
   toOptionalNumber,
   toOptionalString
-} from "./chunk-2LWPFSB4.js";
+} from "./chunk-4LJO56OJ.js";
 
 // src/chat/task-execution/state.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-DS3J6WGY.js → chunk-DLDRQHG5.js}

@@ -1,6 +1,6 @@
 import {
   JUNIOR_VERSION
-} from "./chunk-GDV5LXRA.js";
+} from "./chunk-IIOOO4FQ.js";
 
 // src/deployment.ts
 var JUNIOR_HEARTBEAT_ROUTE = "/api/internal/heartbeat";