deepline 0.2.34 → 0.2.35

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

@@ -160,7 +160,7 @@ export const SDK_RELEASE = {
   // 0.2.0 makes Dataset Handles uniformly async-only after 0.1.320 briefly
   // exposed storage-dependent synchronous access. This deliberate minor
   // release keeps lazy paging semantics independent of row residency.
-  version: '0.2.34',
+  version: '0.2.35',
   contracts: {
     api: {
       name: 'sdk-http-api',

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

@@ -43,6 +43,9 @@ const DAYTONA_COMMAND_RECOVERY_POLL_MS = 2_000;
 const DAYTONA_INFRASTRUCTURE_MAX_ATTEMPTS = 2;
 const DAYTONA_UPLOAD_MAX_ATTEMPTS = 2;
 const DAYTONA_UPLOAD_ATTEMPT_DEADLINE_MS = 90_000;
+const DAYTONA_CRASH_DIAGNOSTIC_TAIL_MAX_BYTES = 64 * 1_024;
+const DAYTONA_CRASH_DIAGNOSTIC_MAX_LINES = 40;
+const DAYTONA_CRASH_DIAGNOSTIC_MAX_TEXT_BYTES = 12 * 1_024;
 
 const RUNTIME_POSTGRES_CONNECT_RETRY_PATTERN =
   /\bRuntime Postgres\b.*\b(connection timed out|connect timeout|ETIMEDOUT|ECONNRESET|ECONNREFUSED|Connection terminated|Connection ended unexpectedly)\b/i;
@@ -54,13 +57,25 @@ const DAYTONA_INFRASTRUCTURE_RETRY_PATTERN =
   /\b(?:Request failed with status code (?:408|429|500|502|503|504)|ECONNRESET|ECONNREFUSED|ETIMEDOUT|UND_ERR_CONNECT_TIMEOUT|fetch failed|socket hang up|Daytona sandbox create failed across|Daytona sandbox create did not complete|Daytona readiness baseline)\b/i;
 
 type DaytonaExecution = { exitCode: number | null; result: string };
-type DaytonaLookupFailure = {
+export type DaytonaLookupFailure = {
   errorName: string;
   errorCode: string | null;
   httpStatus: number | null;
   requestId: string | null;
   detail: string;
 };
+export type DaytonaCrashDiagnostic = {
+  schemaVersion: 1;
+  collectionStatus: 'collected' | 'unavailable' | 'wrong_routing_domain';
+  exitCodeFile: number | null;
+  sessionExitCode: number | null;
+  outputBytes: number | null;
+  tailBytes: number;
+  tailTruncated: boolean;
+  signals: string[];
+  unclassifiedLineCount: number;
+  collectionFailure: DaytonaLookupFailure | null;
+};
 type DaytonaUploadAttemptTiming = {
   attempt: number;
   sandboxId: string;
@@ -165,6 +180,194 @@ export function describeDaytonaLookupFailure(
   };
 }
 
+function shellQuoteDaytonaDiagnostic(value: string): string {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+const DAYTONA_CRASH_DIAGNOSTIC_LINE_PATTERN =
+  /(?:\b(?:Type|Range|Reference|Syntax|Aggregate|Eval|URI)?Error(?:\s*\[[^\]]+\])?:|\bERR_[A-Z0-9_]+\b|\b(?:uncaught|unhandled(?:promiserejection)?)\b|\bFATAL ERROR\b|heap out of memory|\b(?:ENOMEM|EPIPE|ECONNRESET|ETIMEDOUT)\b|\bSIG(?:ABRT|BUS|FPE|ILL|KILL|SEGV|TERM)\b|^node:|^\s*at\s+(?:async\s+)?)/i;
+
+function daytonaCrashDiagnosticSignature(line: string): string | null {
+  const signals = new Set<string>();
+  const errorName = line.match(
+    /\b((?:Type|Range|Reference|Syntax|Aggregate|Eval|URI)?Error)\b/i,
+  )?.[1];
+  if (errorName) signals.add(`error:${errorName}`);
+
+  if (/\buncaught\b/i.test(line)) signals.add('exception:uncaught');
+  if (/\bunhandled(?:promiserejection)?\b/i.test(line))
+    signals.add('exception:unhandled_rejection');
+  if (/\bFATAL ERROR\b/i.test(line)) signals.add('runtime:fatal_error');
+  if (/heap out of memory/i.test(line)) signals.add('runtime:heap_out_of_memory');
+
+  for (const code of line.matchAll(/\b(ENOMEM|EPIPE|ECONNRESET|ETIMEDOUT)\b/gi))
+    signals.add(`transport:${code[1]!.toUpperCase()}`);
+  for (const signal of line.matchAll(
+    /\b(SIG(?:ABRT|BUS|FPE|ILL|KILL|SEGV|TERM))\b/gi,
+  ))
+    signals.add(`signal:${signal[1]!.toUpperCase()}`);
+
+  const nodeErrorCode = line.match(/\bERR_[A-Z0-9_]+\b/i)?.[0];
+  if (nodeErrorCode) signals.add('runtime:node_error_code');
+  if (/^node:/i.test(line)) signals.add('runtime:node_error');
+  if (/^\s*at\s+(?:async\s+)?/i.test(line)) signals.add('stack:frame');
+
+  return signals.size > 0 ? [...signals].join(' ') : null;
+}
+
+/**
+ * Reduce a captured runner-output tail to error and stack signals only.
+ * Compact Daytona stdout contains JSON result envelopes which can contain
+ * customer rows, so every JSON-looking line is excluded even when truncated.
+ */
+export function extractDaytonaCrashDiagnosticSignals(outputTail: string): {
+  signals: string[];
+  unclassifiedLineCount: number;
+} {
+  const candidates: string[] = [];
+  let unclassifiedLineCount = 0;
+  for (const rawLine of outputTail.split(/\r?\n/)) {
+    const line = rawLine.trimEnd();
+    if (!line.trim()) continue;
+    if (/^\s*[\[{]/.test(line)) {
+      unclassifiedLineCount += 1;
+      continue;
+    }
+    if (!DAYTONA_CRASH_DIAGNOSTIC_LINE_PATTERN.test(line)) {
+      unclassifiedLineCount += 1;
+      continue;
+    }
+    const signature = daytonaCrashDiagnosticSignature(line);
+    if (signature) candidates.push(signature);
+  }
+
+  const selected = candidates.slice(-DAYTONA_CRASH_DIAGNOSTIC_MAX_LINES);
+  const signals: string[] = [];
+  let retainedBytes = 0;
+  for (const line of selected) {
+    const lineBytes = Buffer.byteLength(line, 'utf8');
+    if (
+      retainedBytes + lineBytes + (signals.length > 0 ? 1 : 0) >
+      DAYTONA_CRASH_DIAGNOSTIC_MAX_TEXT_BYTES
+    ) {
+      break;
+    }
+    signals.push(line);
+    retainedBytes += lineBytes + (signals.length > 1 ? 1 : 0);
+  }
+  return { signals, unclassifiedLineCount };
+}
+
+/**
+ * Read bounded crash evidence while the failed sandbox still exists. This is
+ * operator telemetry only: it never becomes a run result or customer log.
+ */
+export async function readDetachedDaytonaCrashDiagnostic(input: {
+  sandboxId: string;
+  sessionId: string;
+  cmdId: string;
+  outputPath: string;
+  exitCodePath: string;
+  expectedOrganizationId?: string | null;
+}): Promise<DaytonaCrashDiagnostic> {
+  const unavailable = (
+    collectionFailure: DaytonaLookupFailure,
+  ): DaytonaCrashDiagnostic => ({
+    schemaVersion: 1,
+    collectionStatus: 'unavailable',
+    exitCodeFile: null,
+    sessionExitCode: null,
+    outputBytes: null,
+    tailBytes: 0,
+    tailTruncated: false,
+    signals: [],
+    unclassifiedLineCount: 0,
+    collectionFailure,
+  });
+  try {
+    const { clientOptions } = loadDaytonaRequiredConfig();
+    const sandbox = (await daytonaSdkClientFactory
+      .createFull(clientOptions)
+      .get(input.sandboxId)) as DaytonaSandbox;
+    const expectedOrganizationId = input.expectedOrganizationId?.trim() || null;
+    const observedOrganizationId = sandbox.organizationId?.trim() || null;
+    if (
+      expectedOrganizationId &&
+      observedOrganizationId !== expectedOrganizationId
+    ) {
+      return {
+        ...unavailable({
+          errorName: 'DaytonaRoutingDomainMismatch',
+          errorCode: 'wrong_routing_domain',
+          httpStatus: null,
+          requestId: null,
+          detail: 'Sandbox belongs to a different Daytona organization.',
+        }),
+        collectionStatus: 'wrong_routing_domain',
+      };
+    }
+
+    const script = `const fs=require('node:fs');const output=process.argv[1];const exit=process.argv[2];const max=Number(process.argv[3]);const stat=fs.statSync(output);const start=Math.max(0,stat.size-max);const fd=fs.openSync(output,'r');const tail=Buffer.alloc(stat.size-start);fs.readSync(fd,tail,0,tail.length,start);fs.closeSync(fd);let exitCode=null;try{const value=Number.parseInt(fs.readFileSync(exit,'utf8').trim(),10);if(Number.isFinite(value))exitCode=value}catch{}process.stdout.write(JSON.stringify({outputBytes:stat.size,tail:tail.toString('base64'),exitCode}));`;
+    const [snapshotResult, sessionResult] = await Promise.allSettled([
+      sandbox.process.executeCommand(
+        `node -e ${shellQuoteDaytonaDiagnostic(script)} ${shellQuoteDaytonaDiagnostic(input.outputPath)} ${shellQuoteDaytonaDiagnostic(input.exitCodePath)} ${DAYTONA_CRASH_DIAGNOSTIC_TAIL_MAX_BYTES}`,
+        undefined,
+        {},
+        8,
+      ),
+      sandbox.process.getSessionCommand(input.sessionId, input.cmdId),
+    ]);
+    if (snapshotResult.status !== 'fulfilled') {
+      return unavailable(describeDaytonaLookupFailure(snapshotResult.reason));
+    }
+    const snapshot = JSON.parse(snapshotResult.value.result) as {
+      outputBytes?: unknown;
+      tail?: unknown;
+      exitCode?: unknown;
+    };
+    const tailBuffer =
+      typeof snapshot.tail === 'string'
+        ? Buffer.from(snapshot.tail, 'base64')
+        : Buffer.alloc(0);
+    const tail = tailBuffer.toString('utf8');
+    const outputBytes =
+      typeof snapshot.outputBytes === 'number' &&
+      Number.isFinite(snapshot.outputBytes)
+        ? snapshot.outputBytes
+        : null;
+    const { signals, unclassifiedLineCount } =
+      extractDaytonaCrashDiagnosticSignals(tail);
+    const sessionExitCode =
+      sessionResult.status === 'fulfilled' &&
+      typeof sessionResult.value?.exitCode === 'number'
+        ? sessionResult.value.exitCode
+        : null;
+    return {
+      schemaVersion: 1,
+      collectionStatus: 'collected',
+      exitCodeFile:
+        typeof snapshot.exitCode === 'number' &&
+        Number.isFinite(snapshot.exitCode)
+          ? snapshot.exitCode
+          : null,
+      sessionExitCode,
+      outputBytes,
+      tailBytes: tailBuffer.byteLength,
+      tailTruncated:
+        outputBytes !== null &&
+        outputBytes > DAYTONA_CRASH_DIAGNOSTIC_TAIL_MAX_BYTES,
+      signals,
+      unclassifiedLineCount,
+      collectionFailure:
+        sessionResult.status === 'rejected'
+          ? describeDaytonaLookupFailure(sessionResult.reason)
+          : null,
+    };
+  } catch (error) {
+    return unavailable(describeDaytonaLookupFailure(error));
+  }
+}
+
 /**
  * Best-effort deletion of an orphaned Daytona sandbox by id (push-execution B4).
  *

package/dist/cli/index.js

@@ -1044,7 +1044,7 @@ var SDK_RELEASE = {
   // 0.2.0 makes Dataset Handles uniformly async-only after 0.1.320 briefly
   // exposed storage-dependent synchronous access. This deliberate minor
   // release keeps lazy paging semantics independent of row residency.
-  version: "0.2.34",
+  version: "0.2.35",
   contracts: {
     api: {
       name: "sdk-http-api",

package/dist/cli/index.mjs

@@ -1030,7 +1030,7 @@ var SDK_RELEASE = {
   // 0.2.0 makes Dataset Handles uniformly async-only after 0.1.320 briefly
   // exposed storage-dependent synchronous access. This deliberate minor
   // release keeps lazy paging semantics independent of row residency.
-  version: "0.2.34",
+  version: "0.2.35",
   contracts: {
     api: {
       name: "sdk-http-api",

package/dist/index.js

@@ -763,7 +763,7 @@ var SDK_RELEASE = {
   // 0.2.0 makes Dataset Handles uniformly async-only after 0.1.320 briefly
   // exposed storage-dependent synchronous access. This deliberate minor
   // release keeps lazy paging semantics independent of row residency.
-  version: "0.2.34",
+  version: "0.2.35",
   contracts: {
     api: {
       name: "sdk-http-api",

package/dist/index.mjs

@@ -689,7 +689,7 @@ var SDK_RELEASE = {
   // 0.2.0 makes Dataset Handles uniformly async-only after 0.1.320 briefly
   // exposed storage-dependent synchronous access. This deliberate minor
   // release keeps lazy paging semantics independent of row residency.
-  version: "0.2.34",
+  version: "0.2.35",
   contracts: {
     api: {
       name: "sdk-http-api",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepline",
-  "version": "0.2.34",
+  "version": "0.2.35",
   "description": "Deepline SDK + CLI — B2B data enrichment powered by durable cloud execution",
   "license": "MIT",
   "repository": {