deepline 0.3.247 → 0.3.249

package/dist/bundling-sources/shared_libs/play-runtime/runner-app/runtime-terminal-push.ts

@@ -3,6 +3,7 @@ import {
   type PlayRunnerEvent,
   type PlayRunnerResult,
 } from '../protocol';
+import type { PlayLogContext } from '../log-context';
 import { parseCtxFetchHttpFailureDiagnostic } from '../log-provenance';
 import {
   RUNNER_TERMINAL_PUSH_MAX_BODY_BYTES,
@@ -170,6 +171,7 @@ function retainArrayWithinJsonByteLimit<T>(
  */
 function retainTerminalLogTailWithRuntimeDiagnostics(logs: readonly string[]): {
   values: string[];
+  indexes: number[];
   truncated: boolean;
 } {
   const retainedIndexes = new Set<number>();
@@ -204,6 +206,7 @@ function retainTerminalLogTailWithRuntimeDiagnostics(logs: readonly string[]): {
   const indexes = [...retainedIndexes].sort((left, right) => left - right);
   return {
     values: indexes.map((index) => logs[index]!),
+    indexes,
     truncated: indexes.length !== logs.length,
   };
 }
@@ -231,11 +234,13 @@ function retainRecordWithinJsonByteLimit(
 function appendTerminalDiagnosticsMarker(
   logs: string[],
   truncatedFields: string[],
-): string[] {
+  logContexts?: Array<PlayLogContext | null>,
+): { logs: string[]; logContexts?: Array<PlayLogContext | null> } {
   const marker =
     `[deepline] terminal diagnostic metadata was bounded (${truncatedFields.join(', ')}); ` +
     'the authored play output is complete.';
   const marked = [marker, ...logs];
+  const markedContexts = logContexts ? [null, ...logContexts] : undefined;
   while (
     marked.length > 1 &&
     !fitsJsonByteLimit(marked, TERMINAL_TRANSPORT_LOG_TAIL_MAX_BYTES)
@@ -247,11 +252,22 @@ function appendTerminalDiagnosticsMarker(
       (line, index) =>
         index > 0 && parseCtxFetchHttpFailureDiagnostic(line) === null,
     );
-    marked.splice(removableIndex === -1 ? 1 : removableIndex, 1);
+    const removeAt = removableIndex === -1 ? 1 : removableIndex;
+    marked.splice(removeAt, 1);
+    markedContexts?.splice(removeAt, 1);
   }
-  return fitsJsonByteLimit(marked, TERMINAL_TRANSPORT_LOG_TAIL_MAX_BYTES)
-    ? marked
-    : [marker];
+  const logsFit = fitsJsonByteLimit(
+    marked,
+    TERMINAL_TRANSPORT_LOG_TAIL_MAX_BYTES,
+  );
+  const retainedLogs = logsFit ? marked : [marker];
+  const retainedContexts = logsFit ? markedContexts : [null];
+  return {
+    logs: retainedLogs,
+    ...(retainedContexts?.some(Boolean)
+      ? { logContexts: retainedContexts }
+      : {}),
+  };
 }
 
 /**
@@ -266,6 +282,15 @@ function boundSettledTerminalTransportDiagnostics(
   const logProjection = retainTerminalLogTailWithRuntimeDiagnostics(
     result.logs,
   );
+  if (
+    result.logContexts !== undefined &&
+    result.logContexts.length !== result.logs.length
+  ) {
+    throw new TypeError('Terminal log contexts must align with result logs.');
+  }
+  const logContexts = result.logContexts?.length
+    ? logProjection.indexes.map((index) => result.logContexts![index] ?? null)
+    : undefined;
   const statsProjection = retainRecordWithinJsonByteLimit(
     result.stats,
     TERMINAL_TRANSPORT_STATS_MAX_BYTES,
@@ -303,15 +328,21 @@ function boundSettledTerminalTransportDiagnostics(
       'head',
     );
     if (warningsProjection.truncated) truncatedFields.push('outputWarnings');
+    const boundedLogs =
+      truncatedFields.length > 0
+        ? appendTerminalDiagnosticsMarker(
+            logProjection.values,
+            truncatedFields,
+            logContexts,
+          )
+        : {
+            logs: logProjection.values,
+            ...(logContexts?.some(Boolean) ? { logContexts } : {}),
+          };
     return {
       ...result,
-      logs:
-        truncatedFields.length > 0
-          ? appendTerminalDiagnosticsMarker(
-              logProjection.values,
-              truncatedFields,
-            )
-          : logProjection.values,
+      logs: boundedLogs.logs,
+      logContexts: boundedLogs.logContexts,
       stats: statsProjection.value,
       steps: stepsProjection.values,
       ...(result.outputWarnings
@@ -337,13 +368,22 @@ function boundSettledTerminalTransportDiagnostics(
   );
   if (error.truncated) truncatedFields.push('error');
   if (errorsProjection.truncated) truncatedFields.push('errors');
+  const boundedLogs =
+    truncatedFields.length > 0
+      ? appendTerminalDiagnosticsMarker(
+          logProjection.values,
+          truncatedFields,
+          logContexts,
+        )
+      : {
+          logs: logProjection.values,
+          ...(logContexts?.some(Boolean) ? { logContexts } : {}),
+        };
   return {
     ...result,
     error: error.value,
-    logs:
-      truncatedFields.length > 0
-        ? appendTerminalDiagnosticsMarker(logProjection.values, truncatedFields)
-        : logProjection.values,
+    logs: boundedLogs.logs,
+    logContexts: boundedLogs.logContexts,
     stats: statsProjection.value,
     steps: stepsProjection.values,
     ...(result.errors ? { errors: errorsProjection.values } : {}),

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

@@ -0,0 +1,184 @@
+import {
+  Configuration,
+  SandboxApi,
+  type SandboxListItem,
+  type Sandbox as SandboxData,
+} from '@daytona/api-client';
+import { Daytona, Sandbox } from '@daytonaio/sdk';
+import axios from 'axios';
+import type { DaytonaClientOptions } from '../../daytona-runtime-config';
+
+/** Control-plane recovery must not inherit the SDK's 24-hour HTTP timeout. */
+export const DAYTONA_CONTROL_TIMEOUT_MS = 10_000;
+
+export class DaytonaControlTimeoutError extends Error {
+  readonly code = 'ETIMEDOUT';
+
+  constructor() {
+    super('Daytona control request timed out');
+    this.name = 'DaytonaControlTimeoutError';
+  }
+}
+
+/**
+ * One lookup and its follow-up toolbox/delete requests share a native transport
+ * deadline. The caller must dispose the client in finally. This adapter never
+ * creates sandboxes or starts customer code; ambiguous starts retain their
+ * existing lifecycle owner.
+ */
+export function createDaytonaControlClient(
+  options: DaytonaClientOptions,
+  timeoutMs = DAYTONA_CONTROL_TIMEOUT_MS,
+) {
+  if (!options.apiKey?.trim()) {
+    throw new Error('Daytona control requests require the configured API key.');
+  }
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new Error('Daytona control timeout must be positive.');
+  }
+  const controller = new AbortController();
+  const deadlineAtMs = Date.now() + timeoutMs;
+  const timer = setTimeout(
+    () => controller.abort(new DaytonaControlTimeoutError()),
+    timeoutMs,
+  );
+  timer.unref();
+  const configuration = new Configuration({
+    basePath:
+      options.apiUrl || options.serverUrl || 'https://app.daytona.io/api',
+    baseOptions: {
+      signal: controller.signal,
+      timeout: timeoutMs,
+      headers: {
+        Authorization: `Bearer ${options.apiKey}`,
+        'X-Daytona-Source': 'deepline-runtime-control',
+      },
+    },
+  });
+  const createTransport = () => {
+    const transport = axios.create({
+      signal: controller.signal,
+      timeout: timeoutMs,
+    });
+    transport.interceptors.request.use((request) => {
+      if (Date.now() >= deadlineAtMs) {
+        controller.abort(new DaytonaControlTimeoutError());
+      }
+      controller.signal.throwIfAborted();
+      return request;
+    });
+    transport.interceptors.response.use(undefined, (error: unknown) => {
+      if (controller.signal.aborted) throw controller.signal.reason;
+      throw error;
+    });
+    return transport;
+  };
+  // The generated API is CommonJS and owns its Axios declaration/transport.
+  // Its public request options carry native cancellation without crossing the
+  // incompatible Axios ESM/CJS interceptor types into its constructor.
+  const api = new SandboxApi(configuration);
+  const sandboxData = new WeakMap<Sandbox, SandboxData>();
+  const call = async <T>(operation: () => Promise<T>): Promise<T> => {
+    if (Date.now() >= deadlineAtMs) {
+      controller.abort(new DaytonaControlTimeoutError());
+    }
+    controller.signal.throwIfAborted();
+    try {
+      return await operation();
+    } catch (error) {
+      if (controller.signal.aborted) throw controller.signal.reason;
+      throw error;
+    }
+  };
+  return {
+    deadlineAtMs,
+    async listPage(query: { labels: Record<string, string> }, cursor?: string) {
+      const { data } = await call(() =>
+        api.listSandboxes(
+          undefined,
+          cursor,
+          undefined,
+          undefined,
+          undefined,
+          JSON.stringify(query.labels),
+        ),
+      );
+      return data;
+    },
+    async get(sandboxId: string): Promise<Sandbox> {
+      const { data } = await call(() => api.getSandbox(sandboxId));
+      // Sandbox sets its configuration/base URL to the provider-returned
+      // toolbox endpoint. Keep that separate from the control API's authority.
+      const sandbox = new Sandbox(
+        data,
+        new Configuration({
+          basePath: configuration.basePath,
+          baseOptions: {
+            ...configuration.baseOptions,
+            headers: { ...configuration.baseOptions.headers },
+          },
+        }),
+        createTransport(),
+        api,
+      );
+      sandboxData.set(sandbox, data);
+      return sandbox;
+    },
+    /**
+     * Full captured stdout is a legacy data-plane artifact, not fixed-size
+     * metadata. Preserve its SDK file-download timeout independently of this
+     * control scope. This facade cannot perform another sandbox lookup.
+     */
+    legacyOutputRecovery(sandbox: Sandbox): Pick<Sandbox, 'fs'> {
+      const data = sandboxData.get(sandbox);
+      if (!data)
+        throw new Error(
+          "Output recovery requires this control client's sandbox.",
+        );
+      const recovery = new Sandbox(
+        data,
+        new Configuration({
+          basePath: configuration.basePath,
+          baseOptions: { headers: { ...configuration.baseOptions.headers } },
+        }),
+        Daytona.createAxiosInstance(),
+        api,
+      );
+      return { fs: recovery.fs };
+    },
+    async delete(sandbox: Pick<Sandbox, 'id'>): Promise<void> {
+      // SDK Sandbox.delete starts an unawaited refresh after success. The
+      // generated deletion endpoint preserves the same confirmed outcome
+      // without starting a new request after this scope finishes.
+      await call(() => api.deleteSandbox(sandbox.id));
+    },
+    dispose(): void {
+      clearTimeout(timer);
+      controller.abort(new Error('Daytona control request scope finished'));
+    },
+  };
+}
+
+/**
+ * Bound each external inventory request, not the sweep. Consume every provider
+ * cursor; a failed page throws instead of reporting a partially scanned fleet
+ * as success. Release the HTTP scope before the caller processes page items.
+ */
+export async function* listDaytonaControlSandboxes(
+  options: DaytonaClientOptions,
+  query: { labels: Record<string, string> },
+  pageTimeoutMs = DAYTONA_CONTROL_TIMEOUT_MS,
+): AsyncGenerator<SandboxListItem> {
+  let cursor: string | undefined;
+  do {
+    const control = createDaytonaControlClient(options, pageTimeoutMs);
+    let page;
+    try {
+      page = await control.listPage(query, cursor);
+    } finally {
+      control.dispose();
+    }
+    yield* page.items;
+    cursor = page.nextCursor ?? undefined;
+  } while (cursor);
+}

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

@@ -0,0 +1,327 @@
+import {
+  Configuration,
+  SandboxApi,
+  type Sandbox as SandboxData,
+} from '@daytona/api-client';
+import {
+  Sandbox,
+  DaytonaError,
+  DaytonaAuthenticationError,
+  DaytonaAuthorizationError,
+  DaytonaNotFoundError,
+  DaytonaConflictError,
+  DaytonaRateLimitError,
+  DaytonaValidationError,
+  type CreateSandboxFromSnapshotParams,
+} from '@daytonaio/sdk';
+import axios, { type InternalAxiosRequestConfig } from 'axios';
+import { Readable } from 'node:stream';
+import type { DaytonaClientOptions } from '../../daytona-runtime-config';
+import {
+  DAYTONA_CONTROL_TIMEOUT_MS,
+  DaytonaControlTimeoutError,
+} from './daytona-control-transport';
+
+/** A sent create may have committed even when no response reached the worker. */
+export class DaytonaLaunchOutcomeUnknownError extends Error {
+  constructor(cause: unknown) {
+    super(
+      'Daytona named create outcome is unknown; reconcile the same operation before another launch.',
+      { cause },
+    );
+    this.name = 'DaytonaLaunchOutcomeUnknownError';
+  }
+}
+
+function providerError(error: unknown): unknown {
+  if (!axios.isAxiosError(error)) return error;
+  const status = error.response?.status;
+  const data = error.response?.data;
+  const message =
+    typeof data === 'string'
+      ? data
+      : typeof data?.message === 'string'
+        ? data.message
+        : error.message;
+  const errorClasses: Record<number, typeof DaytonaError> = {
+    400: DaytonaValidationError,
+    401: DaytonaAuthenticationError,
+    403: DaytonaAuthorizationError,
+    404: DaytonaNotFoundError,
+    409: DaytonaConflictError,
+    429: DaytonaRateLimitError,
+  };
+  const ErrorClass = errorClasses[status ?? 0] ?? DaytonaError;
+  return new ErrorClass(
+    message,
+    status,
+    undefined,
+    typeof data?.code === 'string' ? data.code : error.code,
+  );
+}
+
+/** Every SDK request owns its socket deadline, including streamed response bodies. */
+function createTransport(signal: () => AbortSignal | undefined) {
+  const active = new WeakMap<
+    InternalAxiosRequestConfig,
+    { finish(): void; signal: AbortSignal }
+  >();
+  const transport = axios.create();
+  transport.interceptors.request.use((request) => {
+    const controller = new AbortController();
+    // Honor the SDK's shorter command/delete windows; upload gets at most the
+    // existing 90s staging budget even without an enclosing phase scope.
+    const timeoutMs = Math.min(
+      request.timeout || DAYTONA_CONTROL_TIMEOUT_MS,
+      90_000,
+    );
+    const timer = setTimeout(
+      () => controller.abort(new DaytonaControlTimeoutError()),
+      timeoutMs,
+    );
+    timer.unref();
+    const inherited = signal();
+    const combined = AbortSignal.any([
+      controller.signal,
+      ...(inherited ? [inherited] : []),
+      ...(request.signal instanceof AbortSignal ? [request.signal] : []),
+    ]);
+    const finish = () => clearTimeout(timer);
+    if (combined.aborted) {
+      finish();
+      combined.throwIfAborted();
+    }
+    request.signal = combined;
+    active.set(request, { finish, signal: combined });
+    return request;
+  });
+  transport.interceptors.response.use(
+    (response) => {
+      const scope = active.get(response.config);
+      if (scope && response.data instanceof Readable) {
+        const body = response.data;
+        const abort = () =>
+          body.destroy(
+            scope.signal.reason instanceof Error
+              ? scope.signal.reason
+              : new Error('Daytona request aborted'),
+          );
+        const finish = () => {
+          scope.finish();
+          scope.signal.removeEventListener('abort', abort);
+        };
+        scope.signal.addEventListener('abort', abort, { once: true });
+        body.once('end', finish).once('close', finish).once('error', finish);
+        if (scope.signal.aborted) abort();
+      } else scope?.finish();
+      return response;
+    },
+    (error: unknown) => {
+      const scope =
+        axios.isAxiosError(error) && error.config
+          ? active.get(error.config)
+          : undefined;
+      scope?.finish();
+      if (scope?.signal.aborted) throw scope.signal.reason;
+      throw providerError(error);
+    },
+  );
+  return transport;
+}
+
+function deadline(timeoutMs: number, signal?: AbortSignal) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
+    throw new Error('Daytona phase deadline must be positive.');
+  const controller = new AbortController();
+  const timer = setTimeout(
+    () => controller.abort(new DaytonaControlTimeoutError()),
+    timeoutMs,
+  );
+  timer.unref();
+  const combined = signal
+    ? AbortSignal.any([controller.signal, signal])
+    : controller.signal;
+  const deadlineAtMs = Date.now() + timeoutMs;
+  return {
+    get signal() {
+      if (Date.now() >= deadlineAtMs)
+        controller.abort(new DaytonaControlTimeoutError());
+      return combined;
+    },
+    dispose() {
+      clearTimeout(timer);
+      controller.abort(new Error('Daytona phase finished'));
+    },
+  };
+}
+
+/** Deepline's default-snapshot launch contract; image/build orchestration stays in the SDK. */
+export function createDaytonaLaunchClient(
+  options: DaytonaClientOptions,
+  cancellation?: AbortSignal,
+) {
+  if (!options.apiKey?.trim())
+    throw new Error('Daytona launch requires the configured API key.');
+  const configuration = new Configuration({
+    basePath:
+      options.apiUrl || options.serverUrl || 'https://app.daytona.io/api',
+    baseOptions: {
+      headers: {
+        Authorization: `Bearer ${options.apiKey}`,
+        'X-Daytona-Source': 'deepline-runtime-launch',
+      },
+    },
+  });
+  const dataBySandbox = new WeakMap<Sandbox, SandboxData>();
+  const makeSandbox = (
+    data: SandboxData,
+    signal: () => AbortSignal | undefined,
+  ): Sandbox => {
+    const scopedConfiguration = new Configuration({
+      basePath: configuration.basePath,
+      baseOptions: {
+        ...configuration.baseOptions,
+        signal: signal(),
+        timeout: DAYTONA_CONTROL_TIMEOUT_MS,
+      },
+    });
+    const api = new SandboxApi(scopedConfiguration);
+    const sandbox = new Sandbox(
+      data,
+      new Configuration({
+        basePath: configuration.basePath,
+        baseOptions: { ...configuration.baseOptions },
+      }),
+      createTransport(signal),
+      api,
+    );
+    dataBySandbox.set(sandbox, data);
+    return sandbox;
+  };
+  const optionsTarget = options.target;
+  return {
+    async create(
+      params: CreateSandboxFromSnapshotParams,
+      options: { timeout?: number } = {},
+    ) {
+      const timeoutMs = (options.timeout ?? 60) * 1_000;
+      const phase = deadline(timeoutMs, cancellation);
+      let sent = false;
+      let data: SandboxData | undefined;
+      try {
+        phase.signal.throwIfAborted();
+        const api = new SandboxApi(
+          new Configuration({
+            basePath: configuration.basePath,
+            baseOptions: { ...configuration.baseOptions, signal: phase.signal },
+          }),
+        );
+        sent = true;
+        const response = await api.createSandbox(
+          {
+            name: params.name,
+            snapshot: params.snapshot,
+            user: params.user,
+            env: params.envVars ?? {},
+            labels: {
+              ...params.labels,
+              'code-toolbox-language': params.language ?? 'python',
+            },
+            public: params.public,
+            target: optionsTarget,
+            autoStopInterval: params.autoStopInterval,
+            autoArchiveInterval: params.autoArchiveInterval,
+            autoDeleteInterval: params.ephemeral
+              ? 0
+              : params.autoDeleteInterval,
+            volumes: params.volumes,
+            networkBlockAll: params.networkBlockAll,
+            networkAllowList: params.networkAllowList,
+            linkedSandbox: params.linkedSandbox,
+          },
+          undefined,
+          { timeout: timeoutMs },
+        );
+        data = response.data;
+        const sandbox = makeSandbox(data, () => phase.signal);
+        await sandbox.waitUntilStarted(options.timeout ?? 60);
+        // Future phases own fresh deadlines; none inherits this create scope.
+        return makeSandbox(
+          {
+            ...data,
+            state: sandbox.state,
+            id: sandbox.id,
+            name: sandbox.name,
+            organizationId: sandbox.organizationId,
+            cpu: sandbox.cpu,
+            gpu: sandbox.gpu,
+            memory: sandbox.memory,
+            disk: sandbox.disk,
+            snapshot: sandbox.snapshot,
+            labels: sandbox.labels,
+            toolboxProxyUrl: sandbox.toolboxProxyUrl,
+          },
+          () => cancellation,
+        );
+      } catch (caught) {
+        const error = providerError(caught);
+        const confirmedRejection =
+          !data &&
+          error instanceof DaytonaError &&
+          [400, 401, 403, 429].includes(error.statusCode ?? 0);
+        if (sent && !confirmedRejection)
+          throw new DaytonaLaunchOutcomeUnknownError(error);
+        throw error;
+      } finally {
+        phase.dispose();
+      }
+    },
+    async get(id: string) {
+      const phase = deadline(DAYTONA_CONTROL_TIMEOUT_MS, cancellation);
+      try {
+        phase.signal.throwIfAborted();
+        const api = new SandboxApi(configuration);
+        const { data } = await api.getSandbox(id, undefined, undefined, {
+          signal: phase.signal,
+        });
+        return makeSandbox(data, () => cancellation);
+      } catch (error) {
+        throw providerError(error);
+      } finally {
+        phase.dispose();
+      }
+    },
+    async delete(sandbox: Pick<Sandbox, 'id'>, timeoutSeconds = 30) {
+      // Cleanup must survive execution cancellation and must not trigger the
+      // SDK's unawaited refreshDataSafe after a confirmed delete response.
+      const phase = deadline(timeoutSeconds * 1_000);
+      try {
+        const api = new SandboxApi(
+          new Configuration({
+            basePath: configuration.basePath,
+            baseOptions: { ...configuration.baseOptions, signal: phase.signal },
+          }),
+        );
+        await api.deleteSandbox(sandbox.id, undefined, {
+          timeout: timeoutSeconds * 1_000,
+        });
+      } catch (error) {
+        throw providerError(error);
+      } finally {
+        phase.dispose();
+      }
+    },
+    scope(sandbox: Sandbox, timeoutMs: number) {
+      const data = dataBySandbox.get(sandbox);
+      if (!data)
+        throw new Error(
+          'Daytona phase requires a sandbox owned by this launch client.',
+        );
+      const phase = deadline(timeoutMs, cancellation);
+      return {
+        sandbox: makeSandbox(data, () => phase.signal),
+        dispose: phase.dispose,
+      };
+    },
+  };
+}