deepline 0.3.124 → 0.3.126

package/dist/bundling-sources/sdk/src/client.ts

@@ -1086,8 +1086,12 @@ export type MonitorJobReconciliationState =
 
 export type MonitorJobProjection = {
   id: string;
+  /** Durable provider operation identity used to trace Fleet/deploy work. */
+  operation_id?: string;
   kind: 'batch_deploy' | 'fleet_deploy';
   state: MonitorJobState;
+  /** Terminal semantic result; `blocked` is a deterministic Fleet/input refusal, not a provider outage. */
+  outcome?: 'blocked' | 'failed';
   phase: MonitorJobPhase;
   target: {
     monitor_key?: string;
@@ -1135,6 +1139,8 @@ export type MonitorJobResult = {
   ok?: boolean;
   job?: MonitorJobProjection;
   batch?: MonitorNamedBatchProjection;
+  /** Same durable operation identity as `job.operation_id`, for log reads. */
+  operation_id?: string;
   logs?: Array<{
     level: string;
     phase: string;
@@ -1754,6 +1760,10 @@ export type TargetBillingStatusResult = {
   recharge_state: string;
   next_action: string | null;
   pending_plan_sku: string | null;
+  /** Saved transition boundary; optional for older servers. */
+  pending_plan_starts_at?: string | null;
+  /** Next cycle boundary from the current Contract’s retained cadence. */
+  current_period_end?: string | null;
   as_of: string | null;
 };
 

package/dist/bundling-sources/sdk/src/compat.ts

@@ -395,18 +395,33 @@ export async function checkSdkCompatibility(
   }
 }
 
+/**
+ * A CI job (`CI` or `GITHUB_ACTIONS`): nobody is at the keyboard to act on an
+ * advisory, and the pinned version is deliberate. Agent sessions are also
+ * non-TTY but are not CI, and they rely on these advisories, so this keys on
+ * the CI environment rather than on a missing terminal.
+ */
+export function isCiEnvironment(): boolean {
+  return ['CI', 'GITHUB_ACTIONS'].some((name) => {
+    const value = process.env[name]?.trim().toLowerCase();
+    return value === '1' || value === 'true' || value === 'yes';
+  });
+}
+
 export function enforceSdkCompatibilityResponse(
   response: SdkCompatibilityResponse | null,
 ): void {
   if (!response) {
     return;
   }
+  // A version the server no longer supports fails everywhere, CI included.
   if (response.update_required) {
     throw new Error(response.message);
   }
   if (
-    response.status === 'deprecated' ||
-    response.status === 'update_available'
+    (response.status === 'deprecated' ||
+      response.status === 'update_available') &&
+    !isCiEnvironment()
   ) {
     process.stderr.write(`${response.message}\n`);
   }

package/dist/bundling-sources/sdk/src/play.ts

@@ -195,7 +195,9 @@ export type PlayFetchResponse = PlayAuthoringFetchResponse;
  * `runtime: { timeout: '90m', size: 'standard' }`; duration values are whole minutes or hours, up to `4h`.
  * It differs from `ctx.tools.execute({ timeoutMs })`, which limits one provider call.
  *
- * @example Webhook with HMAC verification
+ * @example Webhook with HMAC verification. `secretEnv` is the Deepline Secret
+ * name configured with `deepline secrets set`, retained as the legacy field
+ * name for SDK compatibility.
  * ```typescript
  * definePlay('webhook-handler', handler, {
  *   webhook: {

package/dist/bundling-sources/sdk/src/release.ts

@@ -200,7 +200,7 @@ export const SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: '0.3.124',
+  version: '0.3.126',
   updateSummary:
     'Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.',
   packageCapabilities: {

package/dist/bundling-sources/shared_libs/monitors/provider-monitor-batch-operation.ts

@@ -21,9 +21,10 @@ export const PROVIDER_MONITOR_BATCH_OPERATION_KINDS = [
   // operation is the durable, observable hand-off to the fenced Fleet
   // executor; it is not a second lifecycle verb or a raw provider create.
   'converge',
-  // A named Batch owns a bounded mixed plan (sync/start/stop) under one
-  // durable operation. It is intentionally distinct from manifest deploy:
-  // omission/removal semantics belong to the Batch desired-set owner.
+  // A named Batch coordinates a bounded mixed plan (sync/start/stop) under
+  // one durable operation. It is intentionally distinct from manifest
+  // deploy: omission/removal semantics belong to the Batch desired set, not
+  // to monitor lifecycle ownership.
   'named_batch',
 ] as const;
 
@@ -127,7 +128,60 @@ export const PROVIDER_MONITOR_BATCH_RESULT_STATES = [
 export type ProviderMonitorBatchResultState =
   (typeof PROVIDER_MONITOR_BATCH_RESULT_STATES)[number];
 
-const IDEMPOTENCY_KEY = /^[A-Za-z0-9][A-Za-z0-9._-]{0,95}$/;
+export const PROVIDER_MONITOR_BATCH_IDEMPOTENCY_KEY_MAX_LENGTH = 96;
+const IDEMPOTENCY_KEY = new RegExp(
+  `^[A-Za-z0-9][A-Za-z0-9._-]{0,${PROVIDER_MONITOR_BATCH_IDEMPOTENCY_KEY_MAX_LENGTH - 1}}$`,
+);
+
+export function validateProviderMonitorBatchIdempotencyKey(
+  value: string,
+): string {
+  const idempotencyKey = value.trim();
+  if (!IDEMPOTENCY_KEY.test(idempotencyKey)) {
+    throw new Error(
+      `idempotencyKey must be 1-${PROVIDER_MONITOR_BATCH_IDEMPOTENCY_KEY_MAX_LENGTH} characters of letters, numbers, dot, underscore, or hyphen.`,
+    );
+  }
+  return idempotencyKey;
+}
+
+/**
+ * Fleet control is the only durable monitor ownership boundary. A Batch is a
+ * deploy mechanism, so it never becomes a customer-facing owner or conflict.
+ * Keep this classifier in the provider-agnostic package so Fleet refusals use
+ * one durable result vocabulary without importing integration-layer errors.
+ */
+export type ProviderMonitorOwnershipConflict = {
+  code: 'monitor_owned_by_fleet';
+  message: string;
+};
+
+export function providerMonitorOwnershipConflict(
+  error: unknown,
+): ProviderMonitorOwnershipConflict | null {
+  const value =
+    error && typeof error === 'object'
+      ? (error as { code?: unknown; message?: unknown })
+      : undefined;
+  const code = typeof value?.code === 'string' ? value.code : '';
+  const message =
+    typeof value?.message === 'string' ? value.message : String(error);
+  const text = `${code} ${message}`.toUpperCase();
+
+  if (
+    text.includes('MONITOR_MANAGED_BY_FLEET') ||
+    text.includes('MONITOR_FLEET_MONITOR_OWNED_BY_OTHER_FLEET') ||
+    text.includes('FLEET_SCOPE_REQUIRED') ||
+    /MANAGED BY (?:MONITOR )?FLEET/.test(text)
+  ) {
+    return {
+      code: 'monitor_owned_by_fleet',
+      message:
+        'This monitor is managed by a Fleet. Change the Fleet definition instead.',
+    };
+  }
+  return null;
+}
 
 function canonicalJson(value: unknown): string {
   if (Array.isArray(value)) return `[${value.map(canonicalJson).join(',')}]`;
@@ -173,14 +227,11 @@ export function providerMonitorBatchOperationId(input: {
   idempotencyKey: string;
 }): string {
   const orgId = input.orgId.trim();
-  const idempotencyKey = input.idempotencyKey.trim();
   if (!orgId)
     throw new Error('A monitor batch operation requires an organization.');
-  if (!IDEMPOTENCY_KEY.test(idempotencyKey)) {
-    throw new Error(
-      'idempotencyKey must be 1-96 characters of letters, numbers, dot, underscore, or hyphen.',
-    );
-  }
+  const idempotencyKey = validateProviderMonitorBatchIdempotencyKey(
+    input.idempotencyKey,
+  );
   return `monitor-batch:${orgId}:${idempotencyKey}`;
 }
 

package/dist/bundling-sources/shared_libs/observability/redaction.ts

@@ -23,6 +23,8 @@ const INLINE_SECRET_PATTERN = new RegExp(
   `\\b(${INLINE_SECRET_FIELD_NAME})(\\s*[:=]\\s*)([^\\s,;]+)`,
   'gi',
 );
+const POSTGRES_CREDENTIAL_PATTERN =
+  /\b(postgres(?:ql)?:\/\/[^:\s/@]+:)[^@\s]+@/gi;
 
 /** Whether a structured telemetry field name must never retain its value. */
 export function isSensitiveTelemetryFieldName(value: string): boolean {
@@ -59,6 +61,7 @@ function redactStructuredValue(
 function redactPlainTelemetryText(value: string): string {
   return value
     .replace(PRIVATE_KEY_PATTERN, '[REDACTED]')
+    .replace(POSTGRES_CREDENTIAL_PATTERN, '$1[REDACTED]@')
     .replace(AUTHORIZATION_CREDENTIAL_PATTERN, '$1$2$3 [REDACTED]')
     .replace(BEARER_CREDENTIAL_PATTERN, 'Bearer [REDACTED]')
     .replace(BASIC_CREDENTIAL_PATTERN, 'Basic [REDACTED]')

package/dist/bundling-sources/shared_libs/observability/runtime-console.ts

@@ -0,0 +1,174 @@
+export type RuntimeConsoleLevel = 'debug' | 'info' | 'warn' | 'error';
+
+type RuntimeConsoleMethod = (...args: unknown[]) => void;
+type RuntimeConsoleTarget = Console;
+
+const RUNTIME_CONSOLE_PATCHED = Symbol.for(
+  'deepline.runtime-console-logging.v1',
+);
+const MAX_VALUE_DEPTH = 5;
+const MAX_STRING_LENGTH = 8_000;
+
+function trim(value: string): string {
+  return value.length <= MAX_STRING_LENGTH
+    ? value
+    : `${value.slice(0, MAX_STRING_LENGTH)}…`;
+}
+
+function safeValue(
+  value: unknown,
+  seen = new WeakSet<object>(),
+  depth = 0,
+): unknown {
+  if (
+    value === null ||
+    typeof value === 'boolean' ||
+    typeof value === 'number'
+  ) {
+    return value;
+  }
+  if (typeof value === 'string') return trim(value);
+  if (typeof value === 'bigint') return String(value);
+  if (value instanceof Error) {
+    return {
+      name: value.name || 'Error',
+      message: trim(value.message),
+      ...(value.stack ? { stack: trim(value.stack) } : {}),
+    };
+  }
+  if (typeof value !== 'object') return String(value);
+  if (depth >= MAX_VALUE_DEPTH) return '[max-depth]';
+  if (seen.has(value)) return '[circular]';
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const result = value
+      .slice(0, 100)
+      .map((item) => safeValue(item, seen, depth + 1));
+    if (value.length > 100) result.push('[truncated]');
+    seen.delete(value);
+    return result;
+  }
+  const result: Record<string, unknown> = {};
+  for (const [key, child] of Object.entries(value).slice(0, 100)) {
+    result[key] = safeValue(child, seen, depth + 1);
+  }
+  if (Object.keys(value).length > 100) result.__truncated__ = true;
+  seen.delete(value);
+  return result;
+}
+
+function parsedObject(value: unknown): Record<string, unknown> | null {
+  if (typeof value !== 'string') return null;
+  try {
+    const parsed: unknown = JSON.parse(value);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+      ? (parsed as Record<string, unknown>)
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function consolePayload(
+  level: RuntimeConsoleLevel,
+  args: readonly unknown[],
+): Record<string, unknown> {
+  const parsed = args.length === 1 ? parsedObject(args[0]) : null;
+  if (parsed) {
+    return {
+      ...(safeValue(parsed) as Record<string, unknown>),
+      level,
+    };
+  }
+
+  const payload: Record<string, unknown> = { level };
+  const text: string[] = [];
+  for (const arg of args) {
+    if (typeof arg === 'string') {
+      text.push(arg);
+      continue;
+    }
+    if (arg instanceof Error) {
+      payload.error = safeValue(arg);
+      continue;
+    }
+    const value = safeValue(arg);
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+      for (const [key, child] of Object.entries(value)) {
+        if (key === 'level') {
+          payload.consoleLevel = child;
+        } else if (key === 'message' && text.length === 0) {
+          payload.message ??= child;
+        } else if (key === 'message') {
+          payload.contextMessage = child;
+        } else {
+          payload[key] = child;
+        }
+      }
+      continue;
+    }
+    text.push(String(value));
+  }
+  if (text.length > 0 && payload.message === undefined) {
+    payload.message = trim(text.join(' '));
+  }
+  return payload;
+}
+
+/**
+ * Preserve the native console API while making Fly log records one-line and
+ * explicitly severity-bearing. Fly's log stream labels stdout and stderr as
+ * info, so the level has to travel in the application payload.
+ */
+export function installRuntimeConsoleLogging(
+  target: RuntimeConsoleTarget = console,
+): void {
+  const metadata = target as Console & { [key: symbol]: unknown };
+  if (metadata[RUNTIME_CONSOLE_PATCHED] === true) return;
+  Object.defineProperty(metadata, RUNTIME_CONSOLE_PATCHED, {
+    configurable: false,
+    enumerable: false,
+    value: true,
+    writable: false,
+  });
+
+  const methods: Array<
+    readonly ['debug' | 'info' | 'warn' | 'error' | 'log', RuntimeConsoleLevel]
+  > = [
+    ['debug', 'debug'],
+    ['info', 'info'],
+    ['warn', 'warn'],
+    ['error', 'error'],
+    ['log', 'info'],
+  ];
+  for (const [method, level] of methods) {
+    const original = target[method] as RuntimeConsoleMethod;
+    target[method] = ((...args: unknown[]) => {
+      original(JSON.stringify(consolePayload(level, args)));
+    }) as Console[typeof method];
+  }
+}
+
+export function createRateLimitedRuntimeLogger(input: {
+  log: RuntimeConsoleMethod;
+  intervalMs?: number;
+  now?: () => number;
+}): RuntimeConsoleMethod {
+  const intervalMs = input.intervalMs ?? 60_000;
+  const now = input.now ?? Date.now;
+  let lastLoggedAt = Number.NEGATIVE_INFINITY;
+  let suppressed = 0;
+
+  return (...args: unknown[]) => {
+    const current = now();
+    if (current - lastLoggedAt < intervalMs) {
+      suppressed += 1;
+      return;
+    }
+    const extra =
+      suppressed > 0 ? { suppressedSinceLastLog: suppressed } : null;
+    suppressed = 0;
+    lastLoggedAt = current;
+    input.log(...args, ...(extra ? [extra] : []));
+  };
+}

package/dist/bundling-sources/shared_libs/observability/telemetry.ts

@@ -64,8 +64,10 @@ type TelemetryEventBase = {
 export type TelemetryLogEvent = TelemetryEventBase & {
   telemetryKind: 'log';
   telemetryLevel: TelemetryLevel;
+  errorCode?: string;
   errorType?: string;
   errorMessage?: string;
+  errorStack?: string;
 };
 
 export type TelemetryMetricEvent = TelemetryEventBase & {
@@ -80,8 +82,10 @@ export type TelemetrySpanEvent = TelemetryEventBase & {
   telemetryLevel: 'info' | 'warn' | 'error';
   spanDurationMs: number;
   spanOutcome: TelemetrySpanOutcome;
+  errorCode?: string;
   errorType?: string;
   errorMessage?: string;
+  errorStack?: string;
 };
 
 export type TelemetryEvent =
@@ -293,12 +297,30 @@ function normalizeContext(context: TelemetryContext | undefined) {
 
 function errorFields(
   error: unknown,
-): Partial<Pick<TelemetrySpanEvent, 'errorType' | 'errorMessage'>> {
+  options: { includeStack?: boolean } = {},
+): Partial<
+  Pick<
+    TelemetrySpanEvent,
+    'errorCode' | 'errorType' | 'errorMessage' | 'errorStack'
+  >
+> {
   if (error === undefined || error === null) return {};
   if (error instanceof Error) {
+    const code =
+      typeof (error as Error & { code?: unknown }).code === 'string'
+        ? (error as Error & { code: string }).code.trim()
+        : '';
     return {
+      ...(code ? { errorCode: code } : {}),
       errorType: error.name || 'Error',
       errorMessage: redactTelemetryString(error.message),
+      ...(options.includeStack !== false && error.stack
+        ? {
+            errorStack: String(
+              normalizeFieldValue('errorStack', error.stack) ?? error.stack,
+            ),
+          }
+        : {}),
     };
   }
   return {
@@ -420,7 +442,9 @@ export function createTelemetry(input: CreateTelemetryInput): Telemetry {
         triage: errorTriage(fields),
         telemetryKind: 'log',
         telemetryLevel: 'error',
-        ...errorFields(error),
+        ...errorFields(error, {
+          includeStack: fields?.errorStack === undefined,
+        }),
       });
     },
     counter: (name, value = 1, fields) =>

package/dist/bundling-sources/shared_libs/play-runtime/play-admission-outcome.ts

@@ -77,7 +77,9 @@ function blocked(code: PlayAdmissionBlockedCode): PlayAdmissionFailure {
     message:
       code === PLAY_SECRET_UNAVAILABLE
         ? 'The Play configuration is unavailable. Repair it, then retry this delivery.'
-        : 'This delivery needs attention before it can be retried.',
+        : code === PLAY_RUN_LAUNCH_CONFLICT
+          ? 'This run identity is already bound to a different launch. Repair the trigger identity before retrying this delivery.'
+          : 'This delivery needs attention before it can be retried.',
   };
 }
 

package/dist/bundling-sources/shared_libs/play-runtime/play-runs/admission/contracts.ts

@@ -55,6 +55,26 @@ export class PlayRunLaunchConflictError extends Error {
   }
 }
 
+/**
+ * Recognize the conflict across the mixed-version admission boundary.
+ *
+ * The Postgres adapter normally converts the database message into the typed
+ * error above. During a rolling deploy an older scheduler may still return the
+ * original message, so callers must recognize both forms before wrapping it as
+ * a generic scheduler failure.
+ */
+export function isPlayRunLaunchConflictError(error: unknown): boolean {
+  if (!(error instanceof Error)) return false;
+  if (
+    error instanceof PlayRunLaunchConflictError ||
+    (error as Error & { code?: unknown }).code === 'PLAY_RUN_LAUNCH_CONFLICT' ||
+    error.name === 'PlayRunLaunchConflictError'
+  ) {
+    return true;
+  }
+  return /already exists with a different launch/i.test(error.message);
+}
+
 /** A fenced replay named a Run that was never durably admitted. */
 export class PlayRunAdmissionReplayMissingError extends Error {
   readonly code = 'PLAY_RUN_ADMISSION_REPLAY_MISSING';

package/dist/bundling-sources/shared_libs/play-runtime/play-runs/admission/index.ts

@@ -3,6 +3,7 @@ export { createPostgresPlayRunAdmissionPorts } from '../../play-runs/admission/p
 export {
   PlayRunAdmissionReplayMissingError,
   PlayRunLaunchConflictError,
+  isPlayRunLaunchConflictError,
 } from '../../play-runs/admission/contracts';
 export type {
   PlayRunAdmissionInput,

package/dist/bundling-sources/shared_libs/play-runtime/play-runs/admission/postgres-adapter.ts

@@ -5,10 +5,12 @@ import {
 import {
   PlayRunAdmissionReplayMissingError,
   PlayRunLaunchConflictError,
+  isPlayRunLaunchConflictError,
   type PlayRunAdmissionInput,
   type PlayRunAdmissionReceipt,
 } from '../../play-runs/admission/contracts';
 import type { PlayRunAdmissionPorts } from '../../play-runs/admission/ports';
+import { emitPlayRunLaunchConflictTelemetry } from '../../runtime-telemetry';
 
 /**
  * PostgreSQL/Absurd implementation of the admission seam.  The delegated
@@ -36,14 +38,33 @@ export function createPostgresPlayRunAdmissionPorts(input: {
           );
         } catch (error) {
           if (isLaunchConflict(error)) {
-            throw new PlayRunLaunchConflictError(admission.launch.runId, {
-              cause: error,
+            const conflict =
+              error instanceof PlayRunLaunchConflictError
+                ? error
+                : new PlayRunLaunchConflictError(admission.launch.runId, {
+                    cause: error,
+                  });
+            emitPlayRunLaunchConflictTelemetry({
+              orgId: admission.launch.orgId,
+              runId: admission.launch.runId,
+              playName: admission.launch.playName,
+              triggerSource: admission.launch.triggerSource,
+              workflowFamilyKey: admission.launch.workflowFamilyKey,
+              revisionId: admission.launch.revisionId,
+              artifactHash: admission.launch.artifactHash,
+              graphHash: admission.launch.graphHash,
+              inputSha256: admission.launch.inputSha256,
+              error: conflict,
             });
+            throw conflict;
           }
           if (isExistingOnlyReplayMissing(error)) {
-            throw new PlayRunAdmissionReplayMissingError(admission.launch.runId, {
-              cause: error,
-            });
+            throw new PlayRunAdmissionReplayMissingError(
+              admission.launch.runId,
+              {
+                cause: error,
+              },
+            );
           }
           throw error;
         }
@@ -54,14 +75,10 @@ export function createPostgresPlayRunAdmissionPorts(input: {
 
 function isExistingOnlyReplayMissing(error: unknown): boolean {
   return (
-    error instanceof Error &&
-    /existing-only admission/i.test(error.message)
+    error instanceof Error && /existing-only admission/i.test(error.message)
   );
 }
 
 function isLaunchConflict(error: unknown): boolean {
-  return (
-    error instanceof Error &&
-    /already exists with a different launch/i.test(error.message)
-  );
+  return isPlayRunLaunchConflictError(error);
 }