deepline 0.3.313 → 0.3.315

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

@@ -654,6 +654,8 @@ function searchParams(options: ToolSearchOptions): URLSearchParams {
 export type RunsListOptions = {
   play?: string;
   status?: string;
+  /** Mermaid node id; returns that node's latest settled input/output per run. Requires play. */
+  node?: string;
   limit?: number;
   /** Zero-based page offset. Requires `play` because status-only inventory is not paginated. */
   offset?: number;
@@ -4599,6 +4601,16 @@ export class DeeplineClient {
     if (status) {
       params.set('status', status);
     }
+    const node = options.node?.trim();
+    if (node) {
+      if (!playName)
+        throw new Error('runs.list options.node requires options.play.');
+      if (node.length > 300)
+        throw new Error(
+          'runs.list options.node must be at most 300 characters.',
+        );
+      params.set('node', node);
+    }
     if (typeof options.limit === 'number' && Number.isFinite(options.limit)) {
       params.set('limit', String(Math.max(1, Math.floor(options.limit))));
     }

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.313',
+  version: '0.3.315',
   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/sdk/src/types.ts

@@ -1314,6 +1314,16 @@ export interface PlayRunListItem {
   billingTotalCredits?: number;
   /** Configured per-run Deepline credit cap, when available. */
   billingMaxCreditsPerRun?: number | null;
+  /** Latest settled Mermaid-node invocation when `runs.list` is filtered by `node`. */
+  nodeObservation?: {
+    attempt: number;
+    status: 'completed' | 'failed';
+    inputs: Record<string, unknown> | null;
+    outputs: Record<string, unknown> | null;
+    error: string | null;
+    inputsTruncated: boolean;
+    outputsTruncated: boolean;
+  } | null;
   /** Metadata attached to the workflow. */
   memo: {
     /** Organization that owns this run. */

package/dist/bundling-sources/shared_libs/play-runtime/play-run-recovery-policy.ts

@@ -95,6 +95,56 @@ export function isPlayRunRecoveryError(
   );
 }
 
+const RECOVERY_LOG_DETAIL_MAX_KEYS = 24;
+const RECOVERY_LOG_DETAIL_MAX_KEY_CHARS = 64;
+const RECOVERY_LOG_DETAIL_MAX_STRING_CHARS = 200;
+
+export type PlayRunRecoveryLogDetail = Readonly<
+  Record<string, string | number | boolean | null>
+>;
+
+/**
+ * Provider facts an adapter attached to the cause of a recovery error, for the
+ * scheduler's defer log only. The decision's `reason` stays the single durable
+ * recovery fact: this detail is never persisted, never returned to a caller,
+ * and never read to choose a recovery action. It is bounded here, at the edge
+ * that logs it, whatever the adapter supplied. Total by construction, because
+ * a failure to describe a deferral must not alter the deferral.
+ */
+export function playRunRecoveryLogDetail(
+  error: unknown,
+): PlayRunRecoveryLogDetail | null {
+  try {
+    if (!isPlayRunRecoveryError(error)) return null;
+    const cause: unknown = error.cause;
+    if (!cause || typeof cause !== 'object') return null;
+    const supplied = (cause as { recoveryLogDetail?: unknown })
+      .recoveryLogDetail;
+    if (!supplied || typeof supplied !== 'object' || Array.isArray(supplied)) {
+      return null;
+    }
+    const detail: Record<string, string | number | boolean | null> = {};
+    for (const [key, value] of Object.entries(supplied).slice(
+      0,
+      RECOVERY_LOG_DETAIL_MAX_KEYS,
+    )) {
+      const name = key.slice(0, RECOVERY_LOG_DETAIL_MAX_KEY_CHARS);
+      if (typeof value === 'string') {
+        detail[name] = value.slice(0, RECOVERY_LOG_DETAIL_MAX_STRING_CHARS);
+      } else if (
+        value === null ||
+        typeof value === 'boolean' ||
+        (typeof value === 'number' && Number.isFinite(value))
+      ) {
+        detail[name] = value;
+      }
+    }
+    return Object.keys(detail).length > 0 ? detail : null;
+  } catch {
+    return null;
+  }
+}
+
 function errorCode(error: unknown): string | number | null {
   if (!error || typeof error !== 'object') return null;
   const code = (error as { code?: unknown }).code;

package/dist/bundling-sources/shared_libs/play-runtime/run-event-query.ts

@@ -535,8 +535,21 @@ function parseDsl(input: string): RunEventPredicate {
       /^(==|!=|>=|<=|>|<|\b(?:eq|ne|gte|gt|lte|lt|in|exists)\b)/.exec(
         input.slice(position),
       );
-    if (!operation)
-      fail('Run event DSL requires a supported comparison operator.');
+    if (!operation) {
+      const token =
+        /^(?:[=!<>~]+|[A-Za-z_]+)/.exec(input.slice(position))?.[0] ??
+        input[position] ??
+        '<end>';
+      if (token === '=') {
+        const corrected = `${input.slice(0, position)}==${input.slice(position + 1)}`;
+        fail(
+          `Run event DSL does not support "=" at character ${position + 1}. For equality, replace this "=" with "==": ${JSON.stringify(corrected)}.`,
+        );
+      }
+      fail(
+        `Run event DSL does not support ${JSON.stringify(token)} after ${JSON.stringify(match[0])} at character ${position + 1}. Use ==, !=, >, >=, <, <=, in or exists.`,
+      );
+    }
     position += operation[0].length;
     const symbols: Record<string, string> = {
       '==': 'eq',

package/dist/bundling-sources/shared_libs/play-runtime/runner-backends/backends/daytona-launch-transport.ts

@@ -22,14 +22,216 @@ import {
   DaytonaControlTimeoutError,
 } from './daytona-control-transport';
 
+// Diagnostics below are log-only. They never select an error, a retry, or a
+// recovery decision, and they stay out of every persisted run document.
+const DAYTONA_LOGGED_SANDBOX_STATES: ReadonlySet<string> = new Set([
+  'creating',
+  'restoring',
+  'destroyed',
+  'destroying',
+  'started',
+  'stopped',
+  'starting',
+  'stopping',
+  'error',
+  'build_failed',
+  'pending_build',
+  'building_snapshot',
+  'unknown',
+  'pulling_snapshot',
+  'archived',
+  'archiving',
+  'resizing',
+  'snapshotting',
+  'forking',
+]);
+const DAYTONA_LOGGED_ERROR_NAMES: ReadonlySet<string> = new Set([
+  'DaytonaError',
+  'DaytonaNotFoundError',
+  'DaytonaRateLimitError',
+  'DaytonaAuthenticationError',
+  'DaytonaAuthorizationError',
+  'DaytonaConflictError',
+  'DaytonaValidationError',
+  'DaytonaTimeoutError',
+  'DaytonaConnectionError',
+  'DaytonaControlTimeoutError',
+  'AbortError',
+  'TimeoutError',
+  'TypeError',
+  'Error',
+]);
+const DAYTONA_LOGGED_PROVIDER_TEXT_MAX_CHARS = 160;
+
+/** A provider state from Daytona's published enum, or `unrecognized`. */
+export function daytonaSandboxStateForLog(state: unknown): string | null {
+  if (state === undefined || state === null) return null;
+  return typeof state === 'string' && DAYTONA_LOGGED_SANDBOX_STATES.has(state)
+    ? state
+    : 'unrecognized';
+}
+
+/** A known error class name, or `other`; never a provider-authored string. */
+export function daytonaErrorClassForLog(error: unknown): string {
+  const name = error instanceof Error ? error.name : null;
+  return name !== null && DAYTONA_LOGGED_ERROR_NAMES.has(name) ? name : 'other';
+}
+
+/** The HTTP status carried by a Daytona error, when it has a plausible one. */
+export function daytonaErrorStatusForLog(error: unknown): number | null {
+  if (!error || typeof error !== 'object') return null;
+  const status = (error as { statusCode?: unknown }).statusCode;
+  return typeof status === 'number' &&
+    Number.isInteger(status) &&
+    status >= 100 &&
+    status <= 599
+    ? status
+    : null;
+}
+
+/**
+ * The machine-readable code on a Daytona or transport error (`ERR_CANCELED`,
+ * `ECONNRESET`, ...). Only the conventional constant shape is logged, so a
+ * provider-authored sentence in that field is dropped rather than copied.
+ */
+export function daytonaErrorCodeForLog(error: unknown): string | null {
+  if (!error || typeof error !== 'object') return null;
+  const record = error as { errorCode?: unknown; code?: unknown };
+  const code = record.errorCode ?? record.code;
+  return typeof code === 'string' && /^[A-Z][A-Z0-9_]{1,39}$/.test(code)
+    ? code
+    : null;
+}
+
+/**
+ * Credential redaction for a Daytona control-plane error message. Shared by
+ * the backend's lookup-failure description and the provider text below.
+ */
+export function redactDaytonaErrorDetail(value: string): string {
+  return value
+    .replace(
+      /authorization\s*[=:]\s*bearer\s+[^\s,;]+/gi,
+      'Authorization=Bearer [redacted]',
+    )
+    .replace(
+      /(authorization\s*[=:]\s*)(?!bearer\s+\[redacted\])[^\s,;]+/gi,
+      '$1[redacted]',
+    )
+    .replace(/(bearer\s+)[^\s,;]+/gi, '$1[redacted]')
+    .replace(/((?:api[_-]?key|token)\s*[=:]\s*)[^\s,;]+/gi, '$1[redacted]')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, 1_000);
+}
+
+/**
+ * Provider free text (for example a sandbox `errorReason`) for logs. This
+ * field is written by the provider, so it is redacted more strictly than the
+ * shared function alone: URL userinfo, any authorization scheme, password,
+ * secret, token, signature, credential and key pairs in query, header or JSON
+ * form, email addresses, and opaque identifiers such as organization ids. It
+ * is then cut to one short fixed bound so an upstream response is never
+ * copied wholesale.
+ */
+export function boundedDaytonaProviderTextForLog(
+  value: unknown,
+): string | null {
+  if (typeof value !== 'string') return null;
+  const strict = value
+    .replace(/(\b[a-z][a-z0-9+.-]*:\/\/)[^\s/@]+@/gi, '$1[redacted]@')
+    .replace(
+      /(authorization\s*[=:]\s*["']?)(?:[a-z]+\s+)?[^\s,;"']+/gi,
+      '$1[redacted]',
+    )
+    .replace(/\b(basic|bearer)\s+[A-Za-z0-9+/=._~-]{8,}/gi, '$1 [redacted]')
+    .replace(
+      /(["']?[\w.-]*(?:password|passwd|secret|token|signature|credential|api[_-]?key|access[_-]?key)[\w.-]*["']?\s*[=:]\s*)(?:"[^"]*"|'[^']*'|[^\s&,;"'}\]]+)/gi,
+      '$1[redacted]',
+    )
+    .replace(
+      /[A-Za-z0-9._%+-]+@[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)+/g,
+      '[redacted-email]',
+    )
+    .replace(
+      /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi,
+      '[redacted-id]',
+    )
+    .replace(
+      /\b(?=[A-Za-z0-9_-]*\d)(?=[A-Za-z0-9_-]*[A-Za-z])[A-Za-z0-9_-]{24,}\b/g,
+      '[redacted-id]',
+    );
+  const bounded = redactDaytonaErrorDetail(strict).slice(
+    0,
+    DAYTONA_LOGGED_PROVIDER_TEXT_MAX_CHARS,
+  );
+  return bounded || null;
+}
+
+/** What this client knew when a sent create ended without a verdict. */
+export type DaytonaLaunchOutcomeDiagnostic = {
+  /** Whether the create request returned a response before the deadline. */
+  createResponseReceived: boolean;
+  /**
+   * Provider sandbox id from the create response, when one was returned. It
+   * is not named `sandboxId`: lifecycle tooling reads that key on a stage
+   * event as an acquired sandbox, and this one never started.
+   */
+  createResponseSandboxId: string | null;
+  /** Last provider state this client saw while waiting for `started`. */
+  lastObservedState: string | null;
+  providerErrorReason: string | null;
+  causeClass: string;
+  /** The cause's machine code, such as `ERR_CANCELED` or `ECONNRESET`. */
+  causeErrno: string | null;
+  causeStatus: number | null;
+};
+
+/**
+ * Describe an unknown create outcome for logs. Total by construction: if the
+ * description cannot be built, the caller still throws the same error without
+ * one, because a different error here would release the reservation and send
+ * a second create.
+ */
+function describeUnknownLaunchOutcome(input: {
+  data: SandboxData | undefined;
+  waiting: Sandbox | undefined;
+  error: unknown;
+}): DaytonaLaunchOutcomeDiagnostic | null {
+  try {
+    const { data, waiting, error } = input;
+    return {
+      createResponseReceived: data !== undefined,
+      createResponseSandboxId: data?.id ? String(data.id).slice(0, 64) : null,
+      lastObservedState: daytonaSandboxStateForLog(
+        waiting?.state ?? data?.state,
+      ),
+      providerErrorReason: boundedDaytonaProviderTextForLog(
+        waiting?.errorReason ?? data?.errorReason,
+      ),
+      causeClass: daytonaErrorClassForLog(error),
+      causeErrno: daytonaErrorCodeForLog(error),
+      causeStatus: daytonaErrorStatusForLog(error),
+    };
+  } catch {
+    return null;
+  }
+}
+
 /** A sent create may have committed even when no response reached the worker. */
 export class DaytonaLaunchOutcomeUnknownError extends Error {
-  constructor(cause: unknown) {
+  /** Log-only; absent when the error was not raised by the launch client. */
+  readonly diagnostic: DaytonaLaunchOutcomeDiagnostic | null;
+
+  constructor(
+    cause: unknown,
+    diagnostic: DaytonaLaunchOutcomeDiagnostic | null = null,
+  ) {
     super(
       'Daytona named create outcome is unknown; reconcile the same operation before another launch.',
       { cause },
     );
     this.name = 'DaytonaLaunchOutcomeUnknownError';
+    this.diagnostic = diagnostic;
   }
 }
 
@@ -208,6 +410,8 @@ export function createDaytonaLaunchClient(
       const phase = deadline(timeoutMs, cancellation);
       let sent = false;
       let data: SandboxData | undefined;
+      // Read only to describe an unknown outcome in logs.
+      let waiting: Sandbox | undefined;
       try {
         phase.signal.throwIfAborted();
         const api = new SandboxApi(
@@ -244,6 +448,7 @@ export function createDaytonaLaunchClient(
         );
         data = response.data;
         const sandbox = makeSandbox(data, () => phase.signal);
+        waiting = sandbox;
         await sandbox.waitUntilStarted(options.timeout ?? 60);
         // Future phases own fresh deadlines; none inherits this create scope.
         return makeSandbox(
@@ -270,7 +475,10 @@ export function createDaytonaLaunchClient(
           error instanceof DaytonaError &&
           [400, 401, 403, 429].includes(error.statusCode ?? 0);
         if (sent && !confirmedRejection)
-          throw new DaytonaLaunchOutcomeUnknownError(error);
+          throw new DaytonaLaunchOutcomeUnknownError(
+            error,
+            describeUnknownLaunchOutcome({ data, waiting, error }),
+          );
         throw error;
       } finally {
         phase.dispose();