deepline 0.1.212 → 0.1.213

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

@@ -32,7 +32,10 @@ import {
   validateDaytonaExecutionContext,
 } from './daytona-lifecycle';
 import { stageDaytonaRunnerPayload } from './daytona-payload-transport';
-import { startDetachedDaytonaCommand } from './daytona-session-execution';
+import {
+  inspectDetachedDaytonaStartup,
+  startDetachedDaytonaCommand,
+} from './daytona-session-execution';
 
 const DAYTONA_EXECUTE_TIMEOUT_SECONDS = STANDARD_PLAY_RUNTIME_LIMIT_SECONDS;
 const STANDARD_WORKFLOW_RUNTIME_LIMIT_ERROR = `Based on this plan, max runtime is ${STANDARD_PLAY_RUNTIME_LIMIT_LABEL}. Use smaller batches; ask for runtime.`;
@@ -42,6 +45,8 @@ const DAYTONA_RUNTIME_INITIALIZATION_MAX_ATTEMPTS = 2;
 const DAYTONA_INFRASTRUCTURE_MAX_ATTEMPTS = 2;
 const DAYTONA_UPLOAD_MAX_ATTEMPTS = 2;
 const DAYTONA_UPLOAD_ATTEMPT_DEADLINE_MS = 90_000;
+const DAYTONA_STARTUP_DIAGNOSTIC_DELAY_MS = 15_000;
+const DAYTONA_STARTUP_TRACE_ENV = 'DEEPLINE_DAYTONA_STARTUP_TRACE';
 
 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;
@@ -749,8 +754,56 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
             cmdId: start.cmdId,
             runnerAttempt,
             ceilingSeconds: DAYTONA_EXECUTE_TIMEOUT_SECONDS,
+            outputPath: stagedPayload.outputPath,
+            exitCodePath: stagedPayload.exitCodePath,
             elapsedMs: Date.now() - startedAt,
           });
+          // Daytona acknowledges an async command with only a cmdId. It does
+          // not expose a queued/running state, and the backend parks before the
+          // runner contacts the runtime sheet. During startup investigations,
+          // retain a bounded snapshot while the sandbox is still alive; the
+          // normal cancellation path otherwise deletes the only evidence.
+          // This is opt-in because it adds Daytona control-plane calls to every
+          // run. The diagnostic excludes command lines and environment values.
+          if (process.env[DAYTONA_STARTUP_TRACE_ENV] === '1') {
+            const diagnosticTimer = setTimeout(() => {
+              void inspectDetachedDaytonaStartup({
+                sandbox,
+                sessionId: start.sessionId,
+                cmdId: start.cmdId,
+                exitCodePath: stagedPayload.exitCodePath,
+              }).then(
+                (diagnostic) =>
+                  emitDaytonaStage(
+                    callbacks,
+                    config.context,
+                    'execute:startup_diagnostic',
+                    {
+                      sandboxId: sandbox.id,
+                      sessionId: start.sessionId,
+                      cmdId: start.cmdId,
+                      diagnostic,
+                      elapsedMs: Date.now() - startedAt,
+                    },
+                  ),
+                (error: unknown) =>
+                  emitDaytonaStage(
+                    callbacks,
+                    config.context,
+                    'execute:startup_diagnostic_failed',
+                    {
+                      sandboxId: sandbox.id,
+                      sessionId: start.sessionId,
+                      cmdId: start.cmdId,
+                      errorType:
+                        error instanceof Error ? error.name : 'unknown',
+                      elapsedMs: Date.now() - startedAt,
+                    },
+                  ),
+              );
+            }, DAYTONA_STARTUP_DIAGNOSTIC_DELAY_MS);
+            diagnosticTimer.unref?.();
+          }
           return {
             status: 'suspended',
             suspension: {