deepline 0.3.88 → 0.3.90

package/dist/bundling-sources/shared_libs/product-notifications/slack-payload.ts

@@ -0,0 +1,140 @@
+export type SlackPayload = {
+  text: string;
+  data?: string;
+  source: string;
+  requestedAt?: string;
+  blocks?: Array<Record<string, unknown>>;
+  unfurl_links?: boolean;
+  unfurl_media?: boolean;
+  bypassInternalActorBlock?: boolean;
+} & Record<string, unknown>;
+
+export type SlackField = {
+  label: string;
+  value: string | number | null | undefined;
+};
+
+export type SlackActivityPayloadInput = {
+  source: string;
+  activityTitle: string;
+  activityPrimary: string;
+  fields: SlackField[];
+  fallbackText?: string;
+  footerText?: string;
+  requestedAt?: string;
+  extra?: Record<string, unknown>;
+  showHeader?: boolean;
+};
+
+export function buildSlackActivityPayload(
+  input: SlackActivityPayloadInput,
+): SlackPayload {
+  const title =
+    normalizeText(input.activityTitle) || 'You have a new activity:';
+  const primary = normalizeText(input.activityPrimary) || 'Activity update';
+  const detailsTableBlock = buildSlackTableBlock(input.fields);
+  const text =
+    normalizeText(input.fallbackText) ||
+    [
+      title,
+      primary,
+      ...input.fields.map((field) => {
+        const label = normalizeText(field.label);
+        const value = normalizeText(field.value);
+        return label && value ? `${label}: ${value}` : '';
+      }),
+    ]
+      .filter(Boolean)
+      .join('\n');
+  const compactDetails = normalizeText(input.fallbackText);
+  const compactDetailsBlock =
+    !detailsTableBlock && compactDetails
+      ? {
+          type: 'section',
+          text: {
+            type: 'mrkdwn',
+            text: compactDetails,
+          },
+        }
+      : null;
+  const showHeader = input.showHeader ?? true;
+  const footerText = normalizeText(input.footerText);
+  const headerBlock = {
+    type: 'section',
+    text: {
+      type: 'mrkdwn',
+      text: `${title}\n*${primary}*`,
+    },
+  };
+
+  return {
+    text,
+    data: text,
+    source: input.source,
+    requestedAt: input.requestedAt ?? new Date().toISOString(),
+    ...(input.extra ?? {}),
+    blocks: [
+      { type: 'divider' },
+      ...(showHeader ? [headerBlock] : []),
+      ...(compactDetailsBlock ? [compactDetailsBlock] : []),
+      ...(detailsTableBlock ? [detailsTableBlock] : []),
+      ...(footerText
+        ? [
+            {
+              type: 'context',
+              elements: [
+                {
+                  type: 'mrkdwn',
+                  text: footerText,
+                },
+              ],
+            },
+          ]
+        : []),
+    ],
+  };
+}
+
+function buildSlackTableBlock(fields: SlackField[]) {
+  const rows = fields
+    .map((field) => ({
+      label: normalizeText(field.label),
+      value: normalizeText(field.value),
+    }))
+    .filter((field) => Boolean(field.label) && Boolean(field.value))
+    .slice(0, 20);
+
+  if (rows.length === 0) return null;
+
+  return {
+    type: 'table',
+    rows: [
+      [buildSlackTableCell('Field', true), buildSlackTableCell('Value', true)],
+      ...rows.map((row) => [
+        buildSlackTableCell(row.label, false),
+        buildSlackTableCell(row.value, false),
+      ]),
+    ],
+  };
+}
+
+function buildSlackTableCell(text: string, bold: boolean) {
+  return {
+    type: 'rich_text',
+    elements: [
+      {
+        type: 'rich_text_section',
+        elements: [
+          bold
+            ? { type: 'text', text, style: { bold: true } }
+            : { type: 'text', text },
+        ],
+      },
+    ],
+  };
+}
+
+function normalizeText(value: unknown): string {
+  if (value === null || value === undefined) return '';
+  return String(value).trim();
+}

package/dist/bundling-sources/shared_libs/product-notifications/slack-transport.ts

@@ -0,0 +1,75 @@
+import { removeHttpHeadersFromSlackPayload } from '../security/slack-sanitize';
+
+type SlackChatResponse = {
+  ok: boolean;
+  error?: string;
+  channel?: string;
+  ts?: string;
+};
+
+export type SlackMessageOptions = {
+  threadTs?: string;
+  blocks?: Array<Record<string, unknown>>;
+  unfurlLinks?: boolean;
+  unfurlMedia?: boolean;
+  username?: string;
+};
+
+async function postSlackMessage(
+  token: string,
+  channelId: string,
+  text: string,
+  options?: SlackMessageOptions,
+): Promise<SlackChatResponse> {
+  const sanitizedText = removeHttpHeadersFromSlackPayload(text);
+  const sanitizedBlocks = options?.blocks
+    ? (removeHttpHeadersFromSlackPayload(options.blocks) as Array<
+        Record<string, unknown>
+      >)
+    : undefined;
+  const res = await fetch('https://slack.com/api/chat.postMessage', {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      channel: channelId,
+      text: typeof sanitizedText === 'string' ? sanitizedText : text,
+      unfurl_links: options?.unfurlLinks ?? false,
+      unfurl_media: options?.unfurlMedia ?? false,
+      ...(options?.threadTs ? { thread_ts: options.threadTs } : {}),
+      ...(options?.username ? { username: options.username } : {}),
+      ...(sanitizedBlocks ? { blocks: sanitizedBlocks } : {}),
+    }),
+  });
+  const data = (await res.json()) as SlackChatResponse;
+  if (!data.ok) {
+    throw new Error(
+      `Slack chat.postMessage failed: ${data.error ?? 'unknown'}`,
+    );
+  }
+  return data;
+}
+
+export async function postMessageToSlack(
+  token: string,
+  channelId: string,
+  text: string,
+  options?: SlackMessageOptions,
+): Promise<void> {
+  await postSlackMessage(token, channelId, text, options);
+}
+
+export async function postMessageToSlackWithResult(
+  token: string,
+  channelId: string,
+  text: string,
+  options?: SlackMessageOptions,
+): Promise<{ channelId: string; ts: string }> {
+  const data = await postSlackMessage(token, channelId, text, options);
+  if (!data.channel || !data.ts) {
+    throw new Error('Slack chat.postMessage returned no message timestamp.');
+  }
+  return { channelId: data.channel, ts: data.ts };
+}

package/dist/bundling-sources/shared_libs/product-notifications/workspace.ts

@@ -0,0 +1,38 @@
+export type NotificationWorkspace = {
+  workspaceId: string;
+  workspaceName?: string;
+  appUrl: string;
+};
+
+export function workspaceAppUrl(
+  baseUrl: string,
+  workspaceId: string,
+  path: string,
+): string {
+  const target = new URL(path, baseUrl);
+  if (
+    target.origin !== new URL(baseUrl).origin ||
+    path.startsWith('//') ||
+    path.includes('\\')
+  ) {
+    throw new Error('Notification target must be a safe internal path.');
+  }
+  const url = new URL('/notifications/open', baseUrl);
+  url.searchParams.set('workspace', workspaceId);
+  url.searchParams.set(
+    'next',
+    `${target.pathname}${target.search}${target.hash}`,
+  );
+  return url.toString();
+}
+
+export function notificationSettingsUrl(
+  workspace: NotificationWorkspace,
+  groupKey: string,
+): string {
+  return workspaceAppUrl(
+    workspace.appUrl,
+    workspace.workspaceId,
+    `/dashboard/settings/notifications?group=${encodeURIComponent(groupKey)}`,
+  );
+}

package/dist/bundling-sources/shared_libs/runtime-env.ts

@@ -53,3 +53,15 @@ export function getRuntimeEnvInfo() {
     node_env: process.env.NODE_ENV ?? null,
   };
 }
+
+/** Test seams must never be reachable from a Vercel production deployment. */
+export function isTestOnlyRuntime(): boolean {
+  if (process.env.VERCEL_ENV === 'production') return false;
+  return process.env.VERCEL_ENV === 'preview' || getRuntimeEnv() !== 'prod';
+}
+
+export function shouldEnableMarketingIntegrations(): boolean {
+  return getRuntimeEnv() === 'prod';
+}
+
+export { isBuildContext } from './observability/build-context';

package/dist/bundling-sources/shared_libs/security/email-blacklist.ts

@@ -0,0 +1,42 @@
+const HARDCODED_BLACKLISTED_EMAILS = [] as const;
+const EMAIL_BLACKLIST_ENV_VAR = 'DEEPLINE_EMAIL_BLACKLIST';
+
+export function normalizeEmailAddress(email?: string | null): string | null {
+  const normalized = String(email ?? '')
+    .trim()
+    .toLowerCase();
+  return normalized.length > 0 ? normalized : null;
+}
+
+export function getBlacklistedEmails(): Set<string> {
+  const emails = new Set<string>();
+
+  for (const email of HARDCODED_BLACKLISTED_EMAILS) {
+    const normalized = normalizeEmailAddress(email);
+    if (normalized) {
+      emails.add(normalized);
+    }
+  }
+
+  const rawEnvValue = process.env[EMAIL_BLACKLIST_ENV_VAR];
+  if (!rawEnvValue) {
+    return emails;
+  }
+
+  for (const part of rawEnvValue.split(/[,\n]/)) {
+    const normalized = normalizeEmailAddress(part);
+    if (normalized) {
+      emails.add(normalized);
+    }
+  }
+
+  return emails;
+}
+
+export function isBlacklistedEmail(email?: string | null): boolean {
+  const normalized = normalizeEmailAddress(email);
+  if (!normalized) {
+    return false;
+  }
+  return getBlacklistedEmails().has(normalized);
+}

package/dist/bundling-sources/shared_libs/security/header-safe-env.ts

@@ -0,0 +1,35 @@
+/**
+ * Guards for env-derived secrets that are sent as HTTP header values.
+ *
+ * fetch() validates header values and throws an error that can echo the raw
+ * value when it contains a forbidden byte. Validate at the env-read site so
+ * secrets never leak into error envelopes or logs.
+ */
+
+// The set fetch() accepts for header values: HTAB, printable ASCII, and
+// obs-text (0x80-0xFF). NUL/CR/LF and other C0 controls are rejected by the
+// runtime, and characters above U+00FF fail ByteString conversion outright.
+const HEADER_UNSAFE_CHAR_PATTERN = /[^\t\u0020-\u007e\u0080-\u00ff]/;
+
+export function isHeaderSafeValue(value: string): boolean {
+  return !HEADER_UNSAFE_CHAR_PATTERN.test(value);
+}
+
+/**
+ * Returns `value` unchanged when it is safe to send as an HTTP header value.
+ * Otherwise throws an error that names `envVar` and never echoes the value.
+ */
+export function assertHeaderSafeEnvValue(input: {
+  envVar: string;
+  value: string;
+}): string {
+  if (!isHeaderSafeValue(input.value)) {
+    throw new Error(
+      `Environment variable ${input.envVar} contains a character that is invalid in an HTTP header value ` +
+        `(typically an embedded newline from a multi-line paste). ` +
+        `Re-set ${input.envVar} as a single-line value. ` +
+        `The raw value is not echoed to avoid leaking a secret.`,
+    );
+  }
+  return input.value;
+}

package/dist/bundling-sources/shared_libs/security/internal-actor.ts

@@ -0,0 +1,50 @@
+export const INTERNAL_EMAIL_DOMAINS = ['getaero.io', 'deepline.com'] as const;
+const LOCAL_DEVELOPMENT_PLATFORM_ADMIN_EMAIL = 'local-dev@deepline.local';
+
+export function normalizeInternalEmail(email?: string | null): string | null {
+  const normalized = String(email ?? '')
+    .trim()
+    .toLowerCase();
+  return normalized || null;
+}
+
+export function isInternalEmail(email?: string | null): boolean {
+  const normalized = normalizeInternalEmail(email);
+  if (!normalized) return false;
+  if (
+    process.env.NODE_ENV === 'development' &&
+    normalized === LOCAL_DEVELOPMENT_PLATFORM_ADMIN_EMAIL
+  ) {
+    return true;
+  }
+  const atIndex = normalized.lastIndexOf('@');
+  if (atIndex === -1) return false;
+  const domain = normalized.slice(atIndex + 1);
+  return INTERNAL_EMAIL_DOMAINS.includes(
+    domain as (typeof INTERNAL_EMAIL_DOMAINS)[number],
+  );
+}
+
+/** Actors allowed to request provider fixtures against the production API. */
+export function isAuthorizedProductionFixtureActor(
+  email?: string | null,
+): boolean {
+  const normalized = normalizeInternalEmail(email);
+  return (
+    isInternalEmail(normalized) ||
+    /^bootstrap-[0-9a-f]{8}@deepline\.local$/i.test(normalized ?? '')
+  );
+}
+
+/** Whether an email belongs to a Deepline staff account. */
+export function isDeeplineUser(email?: string | null): boolean {
+  return isInternalEmail(email);
+}
+
+export function isDeeplineInternalEmail(email?: string | null): boolean {
+  const normalized = normalizeInternalEmail(email);
+  if (!normalized) return false;
+  const atIndex = normalized.lastIndexOf('@');
+  if (atIndex === -1) return false;
+  return normalized.slice(atIndex + 1) === 'deepline.com';
+}

package/dist/bundling-sources/shared_libs/security/secret-redaction.ts

@@ -0,0 +1,267 @@
+const REDACTED_VALUE = '[REDACTED]';
+
+type SecretRedactionOptions = {
+  redactHighEntropy?: boolean;
+};
+
+const SENSITIVE_KEY_PATTERNS = [
+  /^api[-_]?key$/i,
+  /^x[-_]?api[-_]?key$/i,
+  /secret/i,
+  /token/i,
+  /password/i,
+  /authorization/i,
+  /cookie/i,
+  /credential/i,
+  /private/i,
+];
+
+const SAFE_IDENTIFIER_KEYS = new Set([
+  'artifactHash',
+  'artifactHashes',
+  'artifact_hash',
+  'artifact_hashes',
+  'graphHash',
+  'graph_hash',
+  'hash',
+  'idempotencyKey',
+  'idempotency_key',
+  'key',
+  'session',
+  'sessionId',
+  'session_id',
+  'sessionIds',
+  'session_ids',
+  'promptId',
+  'prompt_id',
+  'requestId',
+  'request_id',
+  'upload_id',
+  // Durable-call runtime identity fields. These are non-secret
+  // `ctx:<org>:call:tool:<tool>:<hash>` receipt/idempotency keys (and their
+  // `:force:<lease>` / `:ordered:<hash>` variants) surfaced on tool-result
+  // `_metadata.execution` and echoed provider idempotency metadata.
+  // Explicit-secret patterns below still redact real secrets that ever appear
+  // under these keys.
+  'receiptKey',
+  'receipt_key',
+  'attachedToReceiptKey',
+  'attached_to_receipt_key',
+  'durableCallReceiptKey',
+  'durable_call_receipt_key',
+  'providerIdempotencyKey',
+  'provider_idempotency_key',
+  'cacheKey',
+  'cache_key',
+  // Non-secret run-output identifiers.
+  'targetTable',
+  'target_table',
+  'tableNamespace',
+  'table_namespace',
+  'queryId',
+  'query_id',
+  'queryIds',
+  'query_ids',
+  'snowflakeQueryId',
+  'snowflake_query_id',
+  'snowflakeQueryIds',
+  'snowflake_query_ids',
+]);
+
+const EXPLICIT_SECRET_VALUE_PATTERNS = [
+  /\bnapi_[a-z0-9]{20,}\b/i,
+  /\bgh[opsu]_[A-Za-z0-9_]{20,}\b/,
+  /\bwhsec_[a-z0-9]+\b/i,
+  /\bsk-proj-[A-Za-z0-9_-]{20,}\b/,
+  /\bxox[baprs]-[A-Za-z0-9-]{20,}\b/i,
+  /\b(sk|rk)_(live|test)_[a-z0-9]+\b/i,
+  /\bpostgres(?:ql)?:\/\/[^\s'"]+/i,
+  /\bhttps?:\/\/[^/\s'"]+:[^@\s'"]+@[^/\s'"]+/i,
+];
+
+const HIGH_ENTROPY_VALUE_PATTERN = /\b[A-Za-z0-9+/=_-]{32,}\b/g;
+// A public hostname can legitimately contain a generated label longer than the
+// high-entropy threshold (for example, a per-run probe hostname). Preserve the
+// complete hostname after known secret formats have already been checked.
+const PUBLIC_DNS_NAME_PATTERN =
+  /^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}\.?$/i;
+const SENSITIVE_URL_PARAM_KEY_PATTERN =
+  /(?:api[-_]?key|x[-_]?api[-_]?key|token|access[-_]?token|refresh[-_]?token|secret|password|authorization|credential|signature|sig)/i;
+const BEARER_SECRET_PATTERN = /\b(Bearer)\s+[A-Za-z0-9._~+/=-]{8,}/gi;
+const ASSIGNMENT_SECRET_PATTERN =
+  /\b(access[-_]?token|refresh[-_]?token|token|x[-_\s]?api[-_\s]?key|api[-_\s]?key|apikey|password|secret|session)\b(\s*[:=]\s*)[^\s'",;)}\]]+/gi;
+const AUTH_ASSIGNMENT_SECRET_PATTERN =
+  /\b(auth(?:orization)?)\b(\s*[:=]\s*)(?!Bearer\b)(?:[A-Za-z]+\s+)?[^\s'",;)}\]]+/gi;
+const SENSITIVE_URL_PARAM_VALUE_PATTERN =
+  /([?&#](?:api[-_]?key|x[-_]?api[-_]?key|token|access[-_]?token|refresh[-_]?token|secret|password|authorization|credential|signature|sig)=)[^&#\s'"]+/gi;
+
+function inspectStandalonePublicHttpUrl(
+  value: string,
+): 'safe' | 'sensitive' | null {
+  const trimmed = value.trim();
+  if (!trimmed || /\s/.test(trimmed)) {
+    return null;
+  }
+
+  let url: URL;
+  try {
+    url = new URL(trimmed);
+  } catch {
+    return null;
+  }
+
+  if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+    return null;
+  }
+  if (url.username || url.password) {
+    return 'sensitive';
+  }
+
+  for (const key of url.searchParams.keys()) {
+    if (SENSITIVE_URL_PARAM_KEY_PATTERN.test(key)) {
+      return 'sensitive';
+    }
+  }
+  if (url.hash && SENSITIVE_URL_PARAM_KEY_PATTERN.test(url.hash)) {
+    return 'sensitive';
+  }
+  return 'safe';
+}
+
+function shouldRedactKey(key: string) {
+  if (SAFE_IDENTIFIER_KEYS.has(key)) {
+    return false;
+  }
+  return SENSITIVE_KEY_PATTERNS.some((pattern) => pattern.test(key));
+}
+
+function maybeRedactString(value: string, options: SecretRedactionOptions) {
+  if (EXPLICIT_SECRET_VALUE_PATTERNS.some((pattern) => pattern.test(value))) {
+    return REDACTED_VALUE;
+  }
+  const publicHttpUrl = inspectStandalonePublicHttpUrl(value);
+  if (publicHttpUrl === 'sensitive') {
+    return REDACTED_VALUE;
+  }
+  if (publicHttpUrl === 'safe') {
+    return value;
+  }
+  if (PUBLIC_DNS_NAME_PATTERN.test(value.trim())) {
+    return value;
+  }
+  const redacted = value
+    .replace(BEARER_SECRET_PATTERN, `$1 ${REDACTED_VALUE}`)
+    .replace(AUTH_ASSIGNMENT_SECRET_PATTERN, `$1$2${REDACTED_VALUE}`)
+    .replace(ASSIGNMENT_SECRET_PATTERN, `$1$2${REDACTED_VALUE}`)
+    .replace(SENSITIVE_URL_PARAM_VALUE_PATTERN, `$1${REDACTED_VALUE}`);
+  return options.redactHighEntropy === false
+    ? redacted
+    : redacted.replace(HIGH_ENTROPY_VALUE_PATTERN, REDACTED_VALUE);
+}
+
+export function redactSecretsInValue<T>(
+  value: T,
+  parentKey?: string,
+  options: SecretRedactionOptions = {},
+): T {
+  if (typeof value === 'string') {
+    if (EXPLICIT_SECRET_VALUE_PATTERNS.some((pattern) => pattern.test(value))) {
+      return REDACTED_VALUE as T;
+    }
+    if (parentKey && SAFE_IDENTIFIER_KEYS.has(parentKey)) {
+      return value as T;
+    }
+    if (parentKey && shouldRedactKey(parentKey)) {
+      return REDACTED_VALUE as T;
+    }
+    return maybeRedactString(value, options) as T;
+  }
+
+  if (!value || typeof value !== 'object') return value;
+
+  type Container = unknown[] | Record<string, unknown>;
+  const root: Container = Array.isArray(value) ? [] : {};
+  const pending: Array<{
+    source: Container;
+    target: Container;
+    parentKey?: string;
+  }> = [{ source: value as Container, target: root, parentKey }];
+
+  const redactNestedValue = (
+    item: unknown,
+    itemParentKey: string | undefined,
+  ): unknown => {
+    if (typeof item !== 'string') return item;
+    if (EXPLICIT_SECRET_VALUE_PATTERNS.some((pattern) => pattern.test(item))) {
+      return REDACTED_VALUE;
+    }
+    if (itemParentKey && SAFE_IDENTIFIER_KEYS.has(itemParentKey)) return item;
+    if (itemParentKey && shouldRedactKey(itemParentKey)) return REDACTED_VALUE;
+    return maybeRedactString(item, options);
+  };
+
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (!current) break;
+    const sourceIsArray = Array.isArray(current.source);
+    for (const [key, item] of Object.entries(current.source)) {
+      const itemParentKey = sourceIsArray ? current.parentKey : key;
+      if (!sourceIsArray && shouldRedactKey(key)) {
+        (current.target as Record<string, unknown>)[key] = REDACTED_VALUE;
+        continue;
+      }
+      if (item && typeof item === 'object') {
+        const nestedTarget: Container = Array.isArray(item) ? [] : {};
+        (current.target as Record<string, unknown>)[key] = nestedTarget;
+        pending.push({
+          source: item as Container,
+          target: nestedTarget,
+          parentKey: itemParentKey,
+        });
+        continue;
+      }
+      (current.target as Record<string, unknown>)[key] = redactNestedValue(
+        item,
+        itemParentKey,
+      );
+    }
+  }
+
+  return root as T;
+}
+
+/**
+ * Redaction for customer-authored inputs and outputs. Preserve arbitrary
+ * identifiers while still removing explicit credential formats, sensitive
+ * keys, authorization values, and credential-bearing URLs.
+ */
+export function redactSecretsInCustomerValue<T>(
+  value: T,
+  parentKey?: string,
+): T {
+  return redactSecretsInValue(value, parentKey, { redactHighEntropy: false });
+}
+
+export function redactSecretsInJsonText(
+  text: string,
+  options: SecretRedactionOptions = {},
+) {
+  try {
+    const parsed = JSON.parse(text) as unknown;
+    return JSON.stringify(
+      redactSecretsInValue(parsed, undefined, options),
+      null,
+      2,
+    );
+  } catch {
+    let redacted = text;
+    for (const pattern of EXPLICIT_SECRET_VALUE_PATTERNS) {
+      redacted = redacted.replace(pattern, REDACTED_VALUE);
+    }
+    return maybeRedactString(redacted, options);
+  }
+}
+
+export function redactSecretsInCustomerJsonText(text: string) {
+  return redactSecretsInJsonText(text, { redactHighEntropy: false });
+}