deepline 0.3.45 → 0.3.47

package/dist/bundling-sources/shared_libs/plays/email-status.ts

@@ -0,0 +1,287 @@
+export type EmailStatusVerdict =
+  | 'send'
+  | 'send_with_caution'
+  | 'verify_next'
+  | 'hold'
+  | 'drop';
+
+export type EmailStatusValue =
+  | 'valid'
+  | 'invalid'
+  | 'catch_all'
+  | 'valid_catch_all'
+  | 'unknown'
+  | 'do_not_mail'
+  | 'spamtrap'
+  | 'abuse'
+  | 'disposable';
+
+export type EmailDeliverability = 'high' | 'medium' | 'low' | 'unknown';
+
+export type EmailMxClass =
+  | 'consumer_mailbox'
+  | 'workspace_mailbox'
+  | 'security_gateway'
+  | 'on_prem'
+  | 'unknown';
+
+export type EmailStatus = {
+  verdict: EmailStatusVerdict;
+  status: EmailStatusValue;
+  verified: boolean;
+  confidence: number | null;
+  reasons: string[];
+  signals: {
+    catch_all: boolean | null;
+    deliverability: EmailDeliverability;
+    mx_class: EmailMxClass;
+    mx_provider: string | null;
+    mx_record: string | null;
+    fraud_score: number | null;
+    disposable: boolean | null;
+    role_based: boolean | null;
+    free_email: boolean | null;
+    abuse: boolean | null;
+    spamtrap: boolean | null;
+    suspect: boolean | null;
+    valid: boolean | null;
+  };
+  provider: {
+    name: string;
+    raw_status: string | boolean | number | null;
+    raw_score: number | null;
+  };
+};
+
+export type EmailStatusMapEntry = {
+  status: EmailStatusValue;
+  verdict?: EmailStatusVerdict;
+  verified?: boolean;
+  reason?: string;
+};
+
+export type EmailStatusRule = EmailStatusMapEntry & {
+  when: Record<string, string | number | boolean | null>;
+};
+
+export type EmailStatusExtractorConfig = {
+  provider: string;
+  rawStatus?: string[];
+  rawScore?: string[];
+  valid?: string[];
+  deliverability?: string[];
+  catchAll?: string[];
+  mxProvider?: string[];
+  mxRecord?: string[];
+  fraudScore?: string[];
+  disposable?: string[];
+  roleBased?: string[];
+  freeEmail?: string[];
+  abuse?: string[];
+  spamtrap?: string[];
+  suspect?: string[];
+  statusMap?: Record<string, EmailStatusMapEntry>;
+  rules?: EmailStatusRule[];
+};
+
+export type EmailStatusBuildInput = {
+  config: EmailStatusExtractorConfig;
+  values: Record<string, unknown>;
+};
+
+// There is intentionally NO shared default status map. Each provider must
+// declare its own `statusMap` / `rules` for the raw status strings it emits
+// (see the provider registries under src/lib/integrations/**). A coarse global
+// map silently coerced provider-specific strings ("deliverable", "accept_all",
+// etc.) into canonical verdicts and let validators depend on guesses instead of
+// documented behavior. With it gone, an unmapped raw status falls through to
+// the typed signal inference below (and ultimately to `unknown`/`hold`) rather
+// than being normalized by a global lookup — loud and provider-declared over
+// silent and implicit.
+
+function normalizeKey(value: unknown): string | null {
+  if (value == null) return null;
+  if (typeof value === 'boolean') return String(value);
+  const normalized = String(value).trim().toLowerCase().replace(/\s+/g, '_');
+  return normalized || null;
+}
+
+function boolish(value: unknown): boolean | null {
+  if (typeof value === 'boolean') return value;
+  if (typeof value === 'number')
+    return value === 1 ? true : value === 0 ? false : null;
+  if (typeof value !== 'string') return null;
+  const normalized = value.trim().toLowerCase();
+  if (['true', 'yes', 'y', '1'].includes(normalized)) return true;
+  if (['false', 'no', 'n', '0'].includes(normalized)) return false;
+  return null;
+}
+
+function numberish(value: unknown): number | null {
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (typeof value !== 'string' || value.trim() === '') return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function stringish(value: unknown): string | null {
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function deliverability(value: unknown): EmailDeliverability {
+  const normalized = normalizeKey(value);
+  return normalized === 'high' ||
+    normalized === 'medium' ||
+    normalized === 'low'
+    ? normalized
+    : 'unknown';
+}
+
+function mxClass(mxProvider: unknown, mxRecord: unknown): EmailMxClass {
+  const haystack =
+    `${stringish(mxProvider) ?? ''} ${stringish(mxRecord) ?? ''}`.toLowerCase();
+  if (!haystack.trim()) return 'unknown';
+  if (
+    /proofpoint|pphosted|mimecast|barracuda|ess\.barracudanetworks|ironport|cisco|iphmx|messagelabs|symantec/.test(
+      haystack,
+    )
+  ) {
+    return 'security_gateway';
+  }
+  if (/aspmx\.l\.google|google|g-suite|google workspace/.test(haystack)) {
+    return 'workspace_mailbox';
+  }
+  if (
+    /protection\.outlook|office365|microsoft|outlook|exchange online/.test(
+      haystack,
+    )
+  ) {
+    return 'workspace_mailbox';
+  }
+  if (/gmail|yahoo|icloud|aol|hotmail/.test(haystack))
+    return 'consumer_mailbox';
+  if (/postfix|exim|sendmail|zimbra|plesk|cpanel|mail\./.test(haystack))
+    return 'on_prem';
+  return 'unknown';
+}
+
+function entryForStatus(
+  key: string | null,
+  map: Record<string, EmailStatusMapEntry> | undefined,
+): EmailStatusMapEntry | null {
+  if (!key) return null;
+  return map?.[key] ?? null;
+}
+
+function read(values: Record<string, unknown>, name: string): unknown {
+  return values[name];
+}
+
+function matchesRule(
+  rule: EmailStatusRule,
+  values: Record<string, unknown>,
+): boolean {
+  return Object.entries(rule.when).every(([key, expected]) => {
+    const actual = read(values, key);
+    if (key.endsWith('Lt')) {
+      const source = numberish(read(values, key.slice(0, -2)));
+      return (
+        typeof expected === 'number' && source != null && source < expected
+      );
+    }
+    if (typeof expected === 'boolean') return boolish(actual) === expected;
+    if (typeof expected === 'number') return numberish(actual) === expected;
+    return normalizeKey(actual) === normalizeKey(expected);
+  });
+}
+
+export function buildEmailStatus({
+  config,
+  values,
+}: EmailStatusBuildInput): EmailStatus {
+  const rawStatus = read(values, 'rawStatus');
+  const rawScore = numberish(read(values, 'rawScore'));
+  const valid = boolish(read(values, 'valid'));
+  const catchAll = boolish(read(values, 'catchAll'));
+  const disposable = boolish(read(values, 'disposable'));
+  const abuse = boolish(read(values, 'abuse'));
+  const spamtrap = boolish(read(values, 'spamtrap'));
+  const suspect = boolish(read(values, 'suspect'));
+  const rawKey = normalizeKey(rawStatus);
+  const mapped =
+    config.rules?.find((rule) => matchesRule(rule, values)) ??
+    entryForStatus(rawKey, config.statusMap) ??
+    entryForStatus(valid == null ? null : String(valid), config.statusMap);
+
+  const status =
+    mapped?.status ??
+    (disposable
+      ? 'disposable'
+      : abuse
+        ? 'abuse'
+        : spamtrap
+          ? 'spamtrap'
+          : catchAll
+            ? 'catch_all'
+            : valid === true
+              ? 'valid'
+              : valid === false
+                ? 'invalid'
+                : 'unknown');
+  const defaultVerdict: EmailStatusVerdict =
+    status === 'valid'
+      ? 'send'
+      : status === 'valid_catch_all'
+        ? 'send_with_caution'
+        : status === 'catch_all'
+          ? 'verify_next'
+          : status === 'unknown'
+            ? 'hold'
+            : 'drop';
+  const verdict = mapped?.verdict ?? defaultVerdict;
+  const verified =
+    mapped?.verified ??
+    (status === 'valid' || status === 'valid_catch_all' || verdict === 'send');
+  const reasons = [
+    mapped?.reason,
+    catchAll ? 'catch_all_domain' : null,
+    mxClass(read(values, 'mxProvider'), read(values, 'mxRecord')) ===
+    'security_gateway'
+      ? 'security_gateway_mx'
+      : null,
+    suspect ? 'provider_marked_suspect' : null,
+  ].filter((reason): reason is string => typeof reason === 'string');
+
+  return {
+    verdict,
+    status,
+    verified,
+    confidence: rawScore,
+    reasons,
+    signals: {
+      catch_all: catchAll,
+      deliverability: deliverability(read(values, 'deliverability')),
+      mx_class: mxClass(read(values, 'mxProvider'), read(values, 'mxRecord')),
+      mx_provider: stringish(read(values, 'mxProvider')),
+      mx_record: stringish(read(values, 'mxRecord')),
+      fraud_score: numberish(read(values, 'fraudScore')),
+      disposable,
+      role_based: boolish(read(values, 'roleBased')),
+      free_email: boolish(read(values, 'freeEmail')),
+      abuse,
+      spamtrap,
+      suspect,
+      valid,
+    },
+    provider: {
+      name: config.provider,
+      raw_status:
+        typeof rawStatus === 'string' ||
+        typeof rawStatus === 'boolean' ||
+        typeof rawStatus === 'number'
+          ? rawStatus
+          : null,
+      raw_score: rawScore,
+    },
+  };
+}

package/dist/bundling-sources/shared_libs/plays/extractor-targets.ts

@@ -0,0 +1,106 @@
+import type { EmailStatus } from './email-status';
+
+export const JOB_CHANGE_STATUS_VALUES = [
+  'moved',
+  'no_change',
+  'left_company',
+  'unknown',
+  'profile_unavailable',
+  'no_new_company',
+] as const;
+
+export type JobChangeStatus = (typeof JOB_CHANGE_STATUS_VALUES)[number];
+
+export type JobChangeGetterValue = {
+  status: JobChangeStatus;
+  date: string | null;
+  new_company: string | null;
+  new_title: string | null;
+};
+
+export const PHONE_STATUS_VALUES = ['valid', 'invalid', 'unknown'] as const;
+
+export type PhoneStatus = (typeof PHONE_STATUS_VALUES)[number];
+
+export const DEEPLINE_EXTRACTOR_TARGET_DEFINITIONS = {
+  id: { identity: true, valueKind: 'string' },
+  name: { identity: true, valueKind: 'string' },
+  email: { identity: true, valueKind: 'string' },
+  personal_email: { identity: true, valueKind: 'string' },
+  phone: { identity: true, valueKind: 'string' },
+  linkedin: { identity: true, valueKind: 'string' },
+  linkedin_url: { identity: true, valueKind: 'string' },
+  domain: { identity: true, valueKind: 'string' },
+  website: { identity: true, valueKind: 'string' },
+  first_name: { identity: true, valueKind: 'string' },
+  last_name: { identity: true, valueKind: 'string' },
+  full_name: { identity: true, valueKind: 'string' },
+  company: { identity: true, valueKind: 'string' },
+  company_name: { identity: true, valueKind: 'string' },
+  organization_name: { identity: true, valueKind: 'string' },
+  company_domain: { identity: true, valueKind: 'string' },
+  company_website: { identity: true, valueKind: 'string' },
+  company_linkedin_url: { identity: true, valueKind: 'string' },
+  title: { identity: false, valueKind: 'string' },
+  industry: { identity: false, valueKind: 'string' },
+  status: { identity: false, valueKind: 'string' },
+  job_change: { identity: false, valueKind: 'job_change' },
+  job_change_status: {
+    identity: false,
+    valueKind: 'job_change_status',
+    enum: JOB_CHANGE_STATUS_VALUES,
+  },
+  email_status: { identity: false, valueKind: 'email_status' },
+  phone_status: {
+    identity: false,
+    valueKind: 'phone_status',
+    enum: PHONE_STATUS_VALUES,
+  },
+} as const;
+
+export type DeeplineExtractorTarget =
+  keyof typeof DEEPLINE_EXTRACTOR_TARGET_DEFINITIONS;
+
+export const DEEPLINE_EXTRACTOR_TARGETS = Object.keys(
+  DEEPLINE_EXTRACTOR_TARGET_DEFINITIONS,
+) as DeeplineExtractorTarget[];
+
+export type DeeplineEmailStatusGetterValue = EmailStatus;
+
+export type DeeplineGetterValueMap = {
+  id: string;
+  name: string;
+  email: string;
+  personal_email: string;
+  phone: string;
+  linkedin: string;
+  linkedin_url: string;
+  domain: string;
+  website: string;
+  first_name: string;
+  last_name: string;
+  full_name: string;
+  company: string;
+  company_name: string;
+  organization_name: string;
+  company_domain: string;
+  company_website: string;
+  company_linkedin_url: string;
+  title: string;
+  industry: string;
+  status: string;
+  job_change: JobChangeGetterValue;
+  job_change_status: JobChangeStatus;
+  email_status: EmailStatus;
+  phone_status: PhoneStatus;
+};
+
+export type DeeplineGetterValue<
+  TTarget extends DeeplineExtractorTarget = DeeplineExtractorTarget,
+> = DeeplineGetterValueMap[TTarget];
+
+export function isDeeplineExtractorTarget(
+  value: string,
+): value is DeeplineExtractorTarget {
+  return value in DEEPLINE_EXTRACTOR_TARGET_DEFINITIONS;
+}

package/dist/bundling-sources/shared_libs/plays/row-identity.ts

@@ -157,9 +157,7 @@ function validateIdentifierPart(
 
 export function normalizePlayName(value: string): string {
   if (value.includes('/')) {
-    throw new Error(
-      'Play name cannot contain "/". Slash is reserved.',
-    );
+    throw new Error('Play name cannot contain "/". Slash is reserved.');
   }
   return validateIdentifierPart(value, 'Play name', PLAY_NAME_MAX_LENGTH);
 }

package/dist/bundling-sources/shared_libs/plays/runtime-constraints.ts

@@ -0,0 +1,2 @@
+export const DISALLOWED_RUN_JAVASCRIPT_TOOL_MESSAGE =
+  'No run_javascript tool in plays. Just write regular code.';

package/dist/bundling-sources/shared_libs/plays/runtime-validation.ts

@@ -7,7 +7,7 @@ import {
   MAP_KEY_NAMESPACE_MAX_LENGTH,
   normalizeTableNamespace,
 } from './row-identity';
-import { DISALLOWED_RUN_JAVASCRIPT_TOOL_MESSAGE } from '../play-runtime/runtime-constraints';
+import { DISALLOWED_RUN_JAVASCRIPT_TOOL_MESSAGE } from './runtime-constraints';
 
 export async function validatePlay(
   code: string | null | undefined,
@@ -311,7 +311,9 @@ function isCtxDatasetCall(node: acorn.Node): node is acorn.CallExpression {
   return callee.object.name === 'ctx' || callee.object.name.endsWith('Ctx');
 }
 
-function isDeprecatedCtxMapCall(node: acorn.Node): node is acorn.CallExpression {
+function isDeprecatedCtxMapCall(
+  node: acorn.Node,
+): node is acorn.CallExpression {
   if (node.type !== 'CallExpression') return false;
   const callee = (node as acorn.CallExpression).callee;
   return (

package/dist/bundling-sources/shared_libs/plays/sandbox-runtime-limits.ts

@@ -0,0 +1,109 @@
+export type PlaySandboxRuntimeLimits = {
+  timeoutSeconds: number;
+  memoryGiB: number;
+  cpu: number;
+  diskGiB: number;
+};
+
+export type PlaySandboxSize = 'standard';
+
+export const PLAY_SANDBOX_SIZE_LIMITS = {
+  standard: {
+    memoryGiB: 1,
+    cpu: 1,
+    diskGiB: 3,
+  },
+} as const satisfies Record<
+  PlaySandboxSize,
+  Omit<PlaySandboxRuntimeLimits, 'timeoutSeconds'>
+>;
+
+export const STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS: PlaySandboxRuntimeLimits = {
+  timeoutSeconds: 30 * 60,
+  ...PLAY_SANDBOX_SIZE_LIMITS.standard,
+};
+
+// Product-wide ceilings. Organisation entitlements may lower these, but a
+// customer-authored Play can never ask Daytona for an unbounded resource.
+export const MAX_PLAY_SANDBOX_RUNTIME_LIMITS: PlaySandboxRuntimeLimits = {
+  timeoutSeconds: 4 * 60 * 60,
+  memoryGiB: STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS.memoryGiB,
+  cpu: STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS.cpu,
+  diskGiB: STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS.diskGiB,
+};
+
+export type PlaySandboxRuntimeDeclaration = {
+  timeout?: string;
+  size?: PlaySandboxSize;
+};
+
+function parseTimeout(value: string): number | null {
+  const match = /^(\d+)\s*([mh])$/i.exec(value.trim());
+  if (!match) return null;
+  const amount = Number(match[1]);
+  if (!Number.isSafeInteger(amount) || amount <= 0) return null;
+  return amount * (match[2].toLowerCase() === 'h' ? 3600 : 60);
+}
+
+export function validatePlaySandboxRuntimeLimits(
+  value: PlaySandboxRuntimeLimits,
+): PlaySandboxRuntimeLimits {
+  const base = STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS;
+  for (const key of ['memoryGiB', 'cpu', 'diskGiB'] as const) {
+    if (value[key] !== base[key]) {
+      throw new Error(
+        `Unsupported runtime sandbox resources: ${key}=${value[key]}. ` +
+          `Use runtime.size with a Deepline prebuilt sandbox. Supported sizes: "standard" ` +
+          `(${base.cpu} CPU, ${base.memoryGiB}GiB memory, ${base.diskGiB}GiB disk).`,
+      );
+    }
+  }
+  if (
+    !Number.isSafeInteger(value.timeoutSeconds) ||
+    value.timeoutSeconds <= 0
+  ) {
+    throw new Error(
+      'Invalid runtime sandbox timeout. Use timeout like "90m" or "2h".',
+    );
+  }
+  if (value.timeoutSeconds > MAX_PLAY_SANDBOX_RUNTIME_LIMITS.timeoutSeconds) {
+    throw new Error(
+      `Requested runtime timeoutSeconds=${value.timeoutSeconds} exceeds this organisation's maximum ${MAX_PLAY_SANDBOX_RUNTIME_LIMITS.timeoutSeconds}.`,
+    );
+  }
+  return { ...value };
+}
+
+export function resolvePlaySandboxRuntimeLimits(
+  declaration: PlaySandboxRuntimeDeclaration | null | undefined,
+): PlaySandboxRuntimeLimits {
+  const base = STANDARD_PLAY_SANDBOX_RUNTIME_LIMITS;
+  if (!declaration) return { ...base };
+  const unsupportedProperties = Object.keys(declaration).filter(
+    (key) => key !== 'timeout' && key !== 'size',
+  );
+  if (unsupportedProperties.length > 0) {
+    throw new Error(
+      `Unsupported runtime sandbox option${unsupportedProperties.length === 1 ? '' : 's'}: ${unsupportedProperties.join(', ')}. ` +
+        'Use runtime.size with a Deepline prebuilt sandbox. Supported sizes: "standard".',
+    );
+  }
+  if (declaration.size !== undefined && declaration.size !== 'standard') {
+    throw new Error(
+      `Unsupported runtime sandbox size "${String(declaration.size)}". Supported sizes: "standard".`,
+    );
+  }
+  const timeoutSeconds = declaration.timeout
+    ? parseTimeout(declaration.timeout)
+    : base.timeoutSeconds;
+  if (timeoutSeconds === null) {
+    throw new Error(
+      'Invalid runtime sandbox timeout. Use timeout like "90m" or "2h".',
+    );
+  }
+  const size = declaration.size ?? 'standard';
+  return validatePlaySandboxRuntimeLimits({
+    timeoutSeconds,
+    ...PLAY_SANDBOX_SIZE_LIMITS[size],
+  });
+}