deepline 0.1.212 → 0.1.214

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

@@ -1,5 +1,99 @@
 import type { DaytonaSandbox } from './daytona-lifecycle';
 
+export type DetachedDaytonaStartupDiagnostic = {
+  commandFound: boolean;
+  exitCode: number | null;
+  sessionFound: boolean;
+  sessionCommandCount: number | null;
+  exitCodeFile: number | null;
+  processSummary: {
+    total: number;
+    node: number;
+    states: Record<string, number>;
+  } | null;
+  errors: string[];
+};
+
+function summarizeProcesses(value: unknown): {
+  total: number;
+  node: number;
+  states: Record<string, number>;
+} | null {
+  if (typeof value !== 'string' || !value.trim()) return null;
+  const rows = value
+    .split('\n')
+    .map((line) => line.trim().split(/\s+/, 2))
+    .filter(([state, command]) => Boolean(state && command));
+  const states: Record<string, number> = {};
+  let node = 0;
+  for (const [state, command] of rows) {
+    const normalizedState = state![0]?.toUpperCase() || '?';
+    states[normalizedState] = (states[normalizedState] ?? 0) + 1;
+    if (/^node(?:-|$)/i.test(command!)) node += 1;
+  }
+  return { total: rows.length, node, states };
+}
+
+/**
+ * Inspect an accepted detached command without exposing its command line or
+ * environment. Daytona's command model has no queued/running state, so the
+ * combination of session membership, a numeric exit marker, and a
+ * aggregate process counts are the narrowest useful startup diagnostic.
+ * Process names are reduced to a Node count before logging; runner logs,
+ * output, and arbitrary process names are deliberately excluded because no
+ * heuristic redactor can guarantee removal of arbitrary customer secrets.
+ */
+export async function inspectDetachedDaytonaStartup(input: {
+  sandbox: DaytonaSandbox;
+  sessionId: string;
+  cmdId: string;
+  exitCodePath: string;
+}): Promise<DetachedDaytonaStartupDiagnostic> {
+  const errors: string[] = [];
+  const diagnostic: DetachedDaytonaStartupDiagnostic = {
+    commandFound: false,
+    exitCode: null,
+    sessionFound: false,
+    sessionCommandCount: null,
+    exitCodeFile: null,
+    processSummary: null,
+    errors,
+  };
+
+  await Promise.all([
+    input.sandbox.process
+      .getSessionCommand(input.sessionId, input.cmdId)
+      .then((command) => {
+        diagnostic.commandFound = true;
+        diagnostic.exitCode =
+          typeof command.exitCode === 'number' ? command.exitCode : null;
+      })
+      .catch(() => errors.push('get_session_command_failed')),
+    input.sandbox.process
+      .getSession(input.sessionId)
+      .then((session) => {
+        diagnostic.sessionFound = true;
+        diagnostic.sessionCommandCount = session.commands.length;
+      })
+      .catch(() => errors.push('get_session_failed')),
+    input.sandbox.fs
+      .downloadFile(input.exitCodePath, 5)
+      .then((file) => {
+        const value = Number.parseInt(file.toString('utf-8').trim(), 10);
+        diagnostic.exitCodeFile = Number.isFinite(value) ? value : null;
+      })
+      .catch(() => errors.push('exit_code_file_unavailable')),
+    input.sandbox.process
+      .executeCommand('ps -eo stat=,comm=', undefined, {}, 5)
+      .then((result) => {
+        diagnostic.processSummary = summarizeProcesses(result.result);
+      })
+      .catch(() => errors.push('process_snapshot_failed')),
+  ]);
+
+  return diagnostic;
+}
+
 /**
  * Detached Daytona command start (push-execution B2-final).
  *

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: {