deepline 0.2.0 → 0.2.2

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

@@ -0,0 +1,218 @@
+import type {
+  PlayRunnerBackend,
+  PlayRunnerCallbacks,
+  PlayRunnerPreparedExecution,
+  PlayRunnerPrepareInput,
+} from '../types';
+import type {
+  PlayRunnerExecutionConfig,
+  PlayRunnerResult,
+} from '@shared_libs/play-runtime/protocol';
+import { daytonaPlayRunnerBackend } from './daytona';
+import { DaytonaSandboxAcquisitionUnavailableError } from './daytona-lifecycle';
+import { modalPlayRunnerBackend } from './modal';
+import {
+  canTransitionRuntimeSandboxPlacement,
+  resolveRuntimeSandboxPlacementPolicy,
+  RUNTIME_SANDBOX_PLACEMENT_POLICIES,
+  type RuntimeSandboxPlacementPolicyId,
+  type RuntimeSandboxPlacementFailureReason,
+  type RuntimeSandboxPlacementPolicy,
+  type RuntimeSandboxProvider,
+} from '@shared_libs/play-runtime/runtime-sandbox-placement-policy';
+
+type DaytonaFallbackPreparedExecution = PlayRunnerPreparedExecution & {
+  kind: 'runtime_sandbox_placement';
+  policyId: string;
+  provider: RuntimeSandboxProvider;
+  providerPrepared: PlayRunnerPreparedExecution | undefined;
+};
+
+function isPrepared(
+  prepared: PlayRunnerPreparedExecution | undefined,
+): prepared is DaytonaFallbackPreparedExecution {
+  return prepared?.kind === 'runtime_sandbox_placement';
+}
+
+type RuntimeSandboxProviderAdapter = {
+  backend: PlayRunnerBackend;
+  classifyAcquisitionFailure: (
+    error: unknown,
+  ) => RuntimeSandboxPlacementFailureReason | null;
+};
+
+function classifyDaytonaAcquisitionFailure(
+  error: unknown,
+): RuntimeSandboxPlacementFailureReason | null {
+  if (!(error instanceof DaytonaSandboxAcquisitionUnavailableError)) {
+    return null;
+  }
+  if (error.reason === 'daytona_total_cpu_limit_exceeded') {
+    return 'provider_capacity_exhausted';
+  }
+  if (error.reason === 'daytona_sandbox_start_timeout') {
+    return 'provider_start_timeout_before_execution';
+  }
+  return null;
+}
+
+/**
+ * Deep placement Implementation. Provider order alone never permits a retry:
+ * the policy must also name the exact pre-execution transition and the source
+ * Adapter must classify the thrown failure into that provider-neutral reason.
+ */
+export function createRuntimeSandboxPlacementBackend(input: {
+  policy: RuntimeSandboxPlacementPolicy;
+  adapters: Readonly<
+    Partial<Record<RuntimeSandboxProvider, RuntimeSandboxProviderAdapter>>
+  >;
+}): PlayRunnerBackend {
+  const primaryProvider = input.policy.providers[0];
+  const primaryAdapter = input.adapters[primaryProvider];
+  if (!primaryAdapter) {
+    throw new Error(
+      `Runtime sandbox placement policy ${input.policy.id} has no Adapter for ${primaryProvider}.`,
+    );
+  }
+  return {
+    async prepare(
+      prepareInput: PlayRunnerPrepareInput,
+      callbacks?: PlayRunnerCallbacks,
+    ): Promise<PlayRunnerPreparedExecution> {
+      const providerPrepared = await primaryAdapter.backend.prepare?.(
+        prepareInput,
+        callbacks,
+      );
+      const prepared: DaytonaFallbackPreparedExecution = {
+        kind: 'runtime_sandbox_placement',
+        policyId: input.policy.id,
+        provider: primaryProvider,
+        providerPrepared,
+        dispose: async () => await providerPrepared?.dispose?.(),
+      };
+      return prepared;
+    },
+
+    async execute(
+      config: PlayRunnerExecutionConfig,
+      callbacks?: PlayRunnerCallbacks,
+      prepared?: PlayRunnerPreparedExecution,
+    ): Promise<PlayRunnerResult> {
+      const policyPrepared =
+        isPrepared(prepared) && prepared.policyId === input.policy.id
+          ? prepared
+          : null;
+      for (const [index, provider] of input.policy.providers.entries()) {
+        const adapter = input.adapters[provider];
+        if (!adapter) {
+          throw new Error(
+            `Runtime sandbox placement policy ${input.policy.id} has no Adapter for ${provider}.`,
+          );
+        }
+        try {
+          return await adapter.backend.execute(
+            config,
+            callbacks,
+            index === 0 && policyPrepared?.provider === provider
+              ? policyPrepared.providerPrepared
+              : undefined,
+          );
+        } catch (error) {
+          const nextProvider = input.policy.providers[index + 1];
+          const reason = adapter.classifyAcquisitionFailure(error);
+          if (
+            !nextProvider ||
+            !reason ||
+            callbacks?.cancellationSignal?.aborted ||
+            !canTransitionRuntimeSandboxPlacement({
+              policy: input.policy,
+              from: provider,
+              to: nextProvider,
+              stage: 'acquisition',
+              reason,
+            })
+          ) {
+            throw error;
+          }
+          console.warn('[play-runner.sandbox_provider_fallback]', {
+            runId: config.context.runId ?? null,
+            workflowId: config.context.workflowId ?? null,
+            policyId: input.policy.id,
+            from: provider,
+            to: nextProvider,
+            stage: 'acquisition',
+            reason,
+          });
+        }
+      }
+      throw new Error(
+        `Runtime sandbox placement policy ${input.policy.id} exhausted without a result.`,
+      );
+    },
+  };
+}
+
+export function createRuntimeSandboxPlacementBackendForPolicy(
+  policyId: RuntimeSandboxPlacementPolicyId | string,
+  overrides: {
+    daytona?: PlayRunnerBackend;
+    modal?: PlayRunnerBackend;
+  } = {},
+): PlayRunnerBackend {
+  return createRuntimeSandboxPlacementBackend({
+    policy: resolveRuntimeSandboxPlacementPolicy(policyId),
+    adapters: {
+      daytona: {
+        backend: overrides.daytona ?? daytonaPlayRunnerBackend,
+        classifyAcquisitionFailure: classifyDaytonaAcquisitionFailure,
+      },
+      modal: {
+        backend: overrides.modal ?? modalPlayRunnerBackend,
+        classifyAcquisitionFailure: () => null,
+      },
+    },
+  });
+}
+
+/** Compatibility factory retained for existing imports and tests. */
+export function createDaytonaModalFallbackBackend(
+  input: {
+    daytona?: PlayRunnerBackend;
+    modal?: PlayRunnerBackend;
+  } = {},
+): PlayRunnerBackend {
+  return createRuntimeSandboxPlacementBackendForPolicy(
+    RUNTIME_SANDBOX_PLACEMENT_POLICIES.daytonaThenModalV1,
+    input,
+  );
+}
+
+export const daytonaModalFallbackPlayRunnerBackend =
+  createDaytonaModalFallbackBackend();
+
+export const daytonaOnlyPlayRunnerBackend =
+  createRuntimeSandboxPlacementBackendForPolicy(
+    RUNTIME_SANDBOX_PLACEMENT_POLICIES.daytonaOnlyV1,
+  );
+
+export const modalOnlyPlayRunnerBackend =
+  createRuntimeSandboxPlacementBackendForPolicy(
+    RUNTIME_SANDBOX_PLACEMENT_POLICIES.modalOnlyV1,
+  );
+
+const DEFAULT_POLICY_BACKENDS: Readonly<
+  Record<RuntimeSandboxPlacementPolicyId, PlayRunnerBackend>
+> = {
+  [RUNTIME_SANDBOX_PLACEMENT_POLICIES.daytonaOnlyV1]:
+    daytonaOnlyPlayRunnerBackend,
+  [RUNTIME_SANDBOX_PLACEMENT_POLICIES.daytonaThenModalV1]:
+    daytonaModalFallbackPlayRunnerBackend,
+  [RUNTIME_SANDBOX_PLACEMENT_POLICIES.modalOnlyV1]: modalOnlyPlayRunnerBackend,
+};
+
+export function resolveDefaultRuntimeSandboxPlacementBackend(
+  policyId: RuntimeSandboxPlacementPolicyId | string,
+): PlayRunnerBackend {
+  const policy = resolveRuntimeSandboxPlacementPolicy(policyId);
+  return DEFAULT_POLICY_BACKENDS[policy.id];
+}

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

@@ -65,6 +65,11 @@ export type StagedDaytonaPayload = {
   progressEventPath: string;
 };
 
+export type RemoteRunnerPayloadSandbox = {
+  id: string;
+  uploadFile(content: Buffer, path: string): Promise<void>;
+};
+
 function shellQuote(value: string): string {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -390,23 +395,23 @@ function remoteRuntimeContextForDaytona(
   };
 }
 
-async function timedDaytonaUpload(input: {
-  sandbox: DaytonaSandbox;
+async function timedRunnerPayloadUpload(input: {
+  sandbox: RemoteRunnerPayloadSandbox;
   emitStage: DaytonaStageEmitter;
   label: string;
   path: string;
   content: Buffer;
 }) {
   const startedAt = Date.now();
-  await input.sandbox.fs.uploadFile(input.content, input.path);
+  await input.sandbox.uploadFile(input.content, input.path);
   input.emitStage(`upload:${input.label}:done`, {
     bytes: input.content.byteLength,
     elapsedMs: Date.now() - startedAt,
   });
 }
 
-export async function stageDaytonaRunnerPayload(input: {
-  sandbox: DaytonaSandbox;
+export async function stageRunnerPayload(input: {
+  sandbox: RemoteRunnerPayloadSandbox;
   bundlePromise: Promise<string>;
   config: PlayRunnerExecutionConfig;
   workDir: string;
@@ -458,7 +463,7 @@ export async function stageDaytonaRunnerPayload(input: {
 
   await Promise.all(
     [...uniqueLocalPaths.entries()].map(async ([localPath, remotePath]) => {
-      await timedDaytonaUpload({
+      await timedRunnerPayloadUpload({
         sandbox: input.sandbox,
         emitStage: input.emitStage,
         label:
@@ -508,7 +513,7 @@ export async function stageDaytonaRunnerPayload(input: {
     STANDARD_PLAY_RUNTIME_LIMIT_SECONDS;
 
   const envelopeUpload = input.bundlePromise.then((bundle) =>
-    timedDaytonaUpload({
+    timedRunnerPayloadUpload({
       sandbox: input.sandbox,
       emitStage: input.emitStage,
       label: 'payload',
@@ -583,3 +588,17 @@ export async function stageDaytonaRunnerPayload(input: {
     progressEventPath,
   };
 }
+
+export async function stageDaytonaRunnerPayload(
+  input: Omit<Parameters<typeof stageRunnerPayload>[0], 'sandbox'> & {
+    sandbox: DaytonaSandbox;
+  },
+): Promise<StagedDaytonaPayload> {
+  return await stageRunnerPayload({
+    ...input,
+    sandbox: {
+      id: input.sandbox.id,
+      uploadFile: (content, path) => input.sandbox.fs.uploadFile(content, path),
+    },
+  });
+}

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

@@ -24,6 +24,7 @@ import {
 } from '@shared_libs/play-runtime/daytona-runtime-config';
 import {
   DAYTONA_CANCELLED_ERROR,
+  DaytonaSandboxAcquisitionUnavailableError,
   createDaytonaSandboxCleanupManager,
   createOneShotDaytonaSandboxLifecycle,
   type DaytonaClient,
@@ -290,12 +291,29 @@ export async function inspectDetachedDaytonaRunner(input: {
 export async function readDetachedDaytonaRuntimeCompletion(input: {
   sandboxId: string;
   runtimeCompletedPath: string;
+  expectedOrganizationId?: string | null;
 }): Promise<number | null> {
   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
+    ) {
+      console.warn(
+        '[play-runner.daytona.runtime_completion_wrong_routing_domain]',
+        {
+          sandboxId: input.sandboxId,
+          expectedOrganizationId,
+          observedOrganizationId,
+        },
+      );
+      return null;
+    }
     const marker = JSON.parse(
       (await sandbox.fs.downloadFile(input.runtimeCompletedPath, 5)).toString(
         'utf-8',
@@ -652,6 +670,7 @@ function prepareDaytonaExecution(
     context: input.context,
     emitStage: (stage, extra) =>
       emitDaytonaStage(callbacks, input.context, stage, extra),
+    observeCreateCall: callbacks?.onRuntimeLifecycleEvent,
   });
   return {
     kind: 'daytona',
@@ -790,6 +809,10 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
         await callbacks?.onRuntimeResourceAcquired?.({
           kind: 'daytona_sandbox',
           sandboxId: sandbox.id,
+          runtimeEnvironment:
+            process.env.DEEPLINE_RUNTIME_ENVIRONMENT === 'preview'
+              ? 'preview'
+              : 'production',
           daytonaEnvironment:
             process.env.DEEPLINE_RUNTIME_ENVIRONMENT === 'preview'
               ? 'preview'
@@ -1031,6 +1054,14 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
               kind: 'detached_runner',
               boundaryId: `detached-runner:${push.runId}:${runnerAttempt}`,
               runnerAttempt,
+              sandboxProvider: 'daytona',
+              runtimeSandboxRef: {
+                schemaVersion: 1,
+                provider: 'daytona',
+                resourceId: sandbox.id,
+                routingDomain:
+                  activeAcquiredResource?.daytonaOrganizationId ?? null,
+              },
               sandboxId: sandbox.id,
               sessionId: start.sessionId,
               cmdId: start.cmdId,
@@ -1121,6 +1152,9 @@ export const daytonaPlayRunnerBackend: PlayRunnerBackend = {
         }
         throw error;
       }
+      if (error instanceof DaytonaSandboxAcquisitionUnavailableError) {
+        throw error;
+      }
       emitDaytonaStage(callbacks, config.context, 'execute:error', {
         sandboxId: sandboxCleanup.currentSandbox()?.id ?? null,
         error: formatDaytonaError(error),