deepline 0.3.55 → 0.3.57

package/dist/bundling-sources/shared_libs/monitors/org-monitor-limits.ts

@@ -0,0 +1,102 @@
+/**
+ * What an organization may watch.
+ *
+ * Monitors are priced and reasoned about in accounts, not in rows: an
+ * organization watches five thousand companies, and watches up to five signals
+ * on each of them. A flat monitor ceiling could not express either half - it
+ * let one company consume the whole allowance, and it made "how many accounts
+ * can I watch" unanswerable without knowing how many signals each would use.
+ *
+ * The two numbers below are the whole policy. Maximum monitors is their
+ * product and is deliberately not a third number to reason about.
+ */
+import { ORG_LIMITS, OrgLimit } from '../org-limits/registry';
+
+export const DEFAULT_ORG_MONITOR_ENTITY_LIMIT =
+  ORG_LIMITS[OrgLimit.MonitorWatchedEntities].defaultValue;
+
+/** Signals one account may be watched with, e.g. jobs + funding + news. */
+export const DEFAULT_MONITORS_PER_ENTITY =
+  ORG_LIMITS[OrgLimit.MonitorsPerEntity].defaultValue;
+
+export type OrgMonitorLimitPolicy = {
+  /** Distinct accounts, contacts, campaigns, or connections. */
+  entityLimit: number;
+  /** Monitors admitted against any one of them. */
+  monitorsPerEntity: number;
+  overrideApplied: boolean;
+};
+
+/**
+ * What an organization gets before any per-organization override.
+ *
+ * Overrides used to be a source-controlled map keyed by organization id, so
+ * raising one customer's ceiling meant a deploy. They live in Convex now,
+ * against the ids declared in the limit registry, which is why this function
+ * no longer takes an organization: a caller that can read the override record
+ * resolves it there, and a caller that cannot is showing a default.
+ */
+export function defaultOrgMonitorLimitPolicy(): OrgMonitorLimitPolicy {
+  return {
+    entityLimit: DEFAULT_ORG_MONITOR_ENTITY_LIMIT,
+    monitorsPerEntity: DEFAULT_MONITORS_PER_ENTITY,
+    overrideApplied: false,
+  };
+}
+
+export type OrgMonitorCapacity = {
+  /** Accounts already watched. */
+  used: number;
+  /** Accounts held by an in-flight create. */
+  reserved: number;
+  limit: number;
+  remaining: number;
+  over_by: number;
+  can_create: boolean;
+  monitors_per_entity: number;
+};
+
+/**
+ * Capacity in accounts.
+ *
+ * `used` and `reserved` count DISTINCT entities, so adding a second signal to
+ * an account the organization already watches consumes nothing here - that is
+ * what the per-entity limit governs instead.
+ */
+export function orgMonitorCapacity(input: {
+  used: number;
+  reserved: number;
+  limit: number;
+  monitorsPerEntity?: number;
+}): OrgMonitorCapacity {
+  const occupied = input.used + input.reserved;
+  return {
+    used: input.used,
+    reserved: input.reserved,
+    limit: input.limit,
+    remaining: Math.max(0, input.limit - occupied),
+    over_by: Math.max(0, occupied - input.limit),
+    can_create: occupied < input.limit,
+    monitors_per_entity:
+      input.monitorsPerEntity ?? DEFAULT_MONITORS_PER_ENTITY,
+  };
+}
+
+/**
+ * Whether one more monitor may be admitted against a given account.
+ *
+ * Separate from capacity because the two refuse for different reasons and the
+ * customer needs to be told which: the organization is watching as many
+ * accounts as it may, or this account already carries as many signals as it
+ * may.
+ */
+export function entityMonitorAdmission(input: {
+  monitorsOnEntity: number;
+  monitorsPerEntity: number;
+}): { admitted: boolean; remaining: number } {
+  const remaining = Math.max(
+    0,
+    input.monitorsPerEntity - input.monitorsOnEntity,
+  );
+  return { admitted: remaining > 0, remaining };
+}

package/dist/bundling-sources/shared_libs/monitors/validation.ts

@@ -0,0 +1,244 @@
+export type MonitorSdkValidationIssueEntityType =
+  | 'monitor'
+  | 'action'
+  | 'trigger'
+  | 'bundle'
+  | 'play'
+  | 'listener'
+  | 'table'
+  | 'tool'
+  | 'workflow';
+
+export type MonitorSdkValidationIssue = {
+  severity: 'error' | 'warning';
+  code: string;
+  path: string;
+  message: string;
+  expected?: unknown;
+  received?: unknown;
+  suggestion?: string;
+  entity_type?: MonitorSdkValidationIssueEntityType;
+  entity_key?: string;
+  docs_ref?: string;
+};
+
+export type MonitorSdkValidationResult = {
+  valid: boolean;
+  issues: MonitorSdkValidationIssue[];
+};
+
+export const MONITOR_SDK_VALIDATION_ERROR_CODE = 'MONITOR_SDK_VALIDATION_ERROR';
+
+export const MONITOR_DEPLOY_VALIDATION_ERROR_CODE =
+  'monitor_deploy_validation_failed';
+
+export class MonitorSdkValidationError extends Error {
+  readonly code = MONITOR_SDK_VALIDATION_ERROR_CODE;
+  readonly issues: MonitorSdkValidationIssue[];
+
+  constructor(
+    issues: MonitorSdkValidationIssue[],
+    message = 'Monitor SDK validation failed.',
+    // Some of these wrap a provider failure whose RETRYABILITY is the only
+    // thing a caller can act on. A wrapper that drops it turns a rate limit
+    // into a permanent refusal, so the cause travels with the issue list.
+    options?: { cause?: unknown },
+  ) {
+    super(message);
+    this.name = 'MonitorSdkValidationError';
+    this.issues = normalizeMonitorSdkValidationIssues(issues);
+    // Assigned rather than passed to `super`: this module compiles under two
+    // tsconfigs and only one of them types the `ErrorOptions` overload.
+    if (options?.cause !== undefined) {
+      (this as { cause?: unknown }).cause = options.cause;
+    }
+  }
+}
+
+const SENSITIVE_MONITOR_VALIDATION_KEYS = new Set([
+  'access_token',
+  'accessToken',
+  'api_key',
+  'apiKey',
+  'authorization',
+  'binding_id',
+  'bindingId',
+  'callback_token',
+  'callbackToken',
+  'callback_url',
+  'callbackUrl',
+  'credential',
+  'credentials',
+  'password',
+  'provider_binding',
+  'providerBinding',
+  'provider_capability',
+  'providerCapability',
+  'provider_credentials',
+  'providerCredentials',
+  'provider_marker',
+  'providerMarker',
+  'refresh_token',
+  'refreshToken',
+  'runtime_action',
+  'runtimeAction',
+  'runtime_payload',
+  'runtimePayload',
+  'secret',
+  'source_capability',
+  'sourceCapability',
+  'upstream_monitor_id',
+  'upstreamMonitorId',
+  'upstream_resource_id',
+  'upstreamResourceId',
+  'upstream_response',
+  'upstreamResponse',
+]);
+
+function sanitizeMonitorPublicString(value: string) {
+  return value.replace(
+    /https?:\/\/\S*\/api\/v2\/monitors\/provider-callbacks\/\S+/g,
+    '[redacted-callback-url]',
+  );
+}
+
+export function sanitizeMonitorPublicValue(
+  value: unknown,
+  seen = new WeakSet<object>(),
+  allowSetupWebhookEndpoint = false,
+): unknown {
+  if (typeof value === 'string') {
+    return sanitizeMonitorPublicString(value);
+  }
+  if (!value || typeof value !== 'object') return value;
+  if (seen.has(value)) return '[redacted-circular-reference]';
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const sanitizedArray = value.map((entry) =>
+      sanitizeMonitorPublicValue(entry, seen, allowSetupWebhookEndpoint),
+    );
+    seen.delete(value);
+    return sanitizedArray;
+  }
+  const sanitized: Record<string, unknown> = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (SENSITIVE_MONITOR_VALIDATION_KEYS.has(key)) continue;
+    // A manual webhook endpoint is deliberately returned only as part of an
+    // authenticated deploy response, so the customer can paste it into the
+    // provider dashboard. Its token is otherwise redacted from monitor APIs.
+    if (
+      allowSetupWebhookEndpoint &&
+      key === 'webhook_endpoint' &&
+      typeof entry === 'string'
+    ) {
+      sanitized[key] = entry;
+      continue;
+    }
+    sanitized[key] = sanitizeMonitorPublicValue(entry, seen, key === 'setup');
+  }
+  seen.delete(value);
+  return sanitized;
+}
+
+function normalizeMonitorSdkIssueEntityType(
+  value: unknown,
+): MonitorSdkValidationIssueEntityType | null {
+  if (value === 'provider_capability') return 'tool';
+  return isMonitorSdkIssueEntityType(value) ? value : null;
+}
+
+export function monitorSdkIssue(
+  issue: Omit<MonitorSdkValidationIssue, 'severity'> & {
+    severity?: MonitorSdkValidationIssue['severity'];
+  },
+): MonitorSdkValidationIssue {
+  const entityType = normalizeMonitorSdkIssueEntityType(issue.entity_type);
+  return {
+    severity: issue.severity ?? 'error',
+    code: issue.code,
+    path: issue.path,
+    message: issue.message,
+    ...(Object.prototype.hasOwnProperty.call(issue, 'expected')
+      ? { expected: sanitizeMonitorPublicValue(issue.expected) }
+      : {}),
+    ...(Object.prototype.hasOwnProperty.call(issue, 'received')
+      ? { received: sanitizeMonitorPublicValue(issue.received) }
+      : {}),
+    ...(issue.suggestion ? { suggestion: issue.suggestion } : {}),
+    ...(entityType ? { entity_type: entityType } : {}),
+    ...(issue.entity_key ? { entity_key: issue.entity_key } : {}),
+    ...(issue.docs_ref ? { docs_ref: issue.docs_ref } : {}),
+  };
+}
+
+export function normalizeMonitorSdkValidationIssues(
+  issues: unknown,
+): MonitorSdkValidationIssue[] {
+  if (!Array.isArray(issues)) return [];
+  return issues
+    .filter((issue): issue is Record<string, unknown> =>
+      Boolean(issue && typeof issue === 'object' && !Array.isArray(issue)),
+    )
+    .map((issue) => {
+      const entityType = normalizeMonitorSdkIssueEntityType(issue.entity_type);
+      return monitorSdkIssue({
+        code:
+          typeof issue.code === 'string' && issue.code.trim()
+            ? issue.code.trim()
+            : 'monitor_validation_error',
+        path:
+          typeof issue.path === 'string' && issue.path.trim()
+            ? issue.path.trim()
+            : 'bundle',
+        message:
+          typeof issue.message === 'string' && issue.message.trim()
+            ? issue.message.trim()
+            : 'Monitor validation failed.',
+        severity:
+          issue.severity === 'warning' || issue.severity === 'error'
+            ? issue.severity
+            : 'error',
+        ...(Object.prototype.hasOwnProperty.call(issue, 'expected')
+          ? { expected: issue.expected }
+          : {}),
+        ...(Object.prototype.hasOwnProperty.call(issue, 'received')
+          ? { received: issue.received }
+          : {}),
+        ...(typeof issue.suggestion === 'string' && issue.suggestion.trim()
+          ? { suggestion: issue.suggestion.trim() }
+          : {}),
+        ...(entityType ? { entity_type: entityType } : {}),
+        ...(typeof issue.entity_key === 'string' && issue.entity_key.trim()
+          ? { entity_key: issue.entity_key.trim() }
+          : {}),
+        ...(typeof issue.docs_ref === 'string' && issue.docs_ref.trim()
+          ? { docs_ref: issue.docs_ref.trim() }
+          : {}),
+      });
+    });
+}
+
+export function hasMonitorSdkValidationIssues(value: unknown): value is {
+  issues: MonitorSdkValidationIssue[];
+} {
+  return (
+    Boolean(value && typeof value === 'object' && !Array.isArray(value)) &&
+    Array.isArray((value as { issues?: unknown }).issues)
+  );
+}
+
+function isMonitorSdkIssueEntityType(
+  value: unknown,
+): value is MonitorSdkValidationIssueEntityType {
+  return (
+    value === 'monitor' ||
+    value === 'action' ||
+    value === 'trigger' ||
+    value === 'bundle' ||
+    value === 'play' ||
+    value === 'listener' ||
+    value === 'table' ||
+    value === 'tool' ||
+    value === 'workflow'
+  );
+}

package/dist/bundling-sources/shared_libs/play-runtime/coordinator-headers.ts

@@ -52,7 +52,7 @@ export const PREFERRED_RECEIPT_GATEWAY_MACHINE_ID_HEADER =
 /**
  * CLI→app marker (NOT a coordinator header — it lives here only because both
  * the SDK HTTP client and the run route already import this module). Set by
- * automated test harnesses (e.g. `tests/v2-plays`) so their intentionally
+ * automated test harnesses (e.g. `tests/gauntlet-e2e-tests`) so their intentionally
  * failing plays — depth-guard probes, error-path scenarios — do not page the
  * SDK CLI error channel as if a real customer run had failed. The run route
  * honors it ONLY in non-prod (see run/route.ts); a forged header from a real