deepline 0.3.89 → 0.3.91

package/dist/bundling-sources/shared_libs/play-runtime/ctx-types.ts

@@ -399,6 +399,15 @@ export interface MapExecutionFrame {
   totalRows: number;
   completedRowKeys: string[];
   pendingRowKeys: string[];
+  /**
+   * The admitted inputs that still need to run after a durable suspension.
+   * This prevents a replay from losing work when its authored source query is
+   * stateful and no longer returns rows that were selected before the pause.
+   */
+  suspendedInputRows?: Array<{
+    inputIndex: number;
+    data: Record<string, unknown>;
+  }>;
   completedRowsCount?: number;
   pendingRowsCount?: number;
   failedRowsCount?: number;
@@ -574,6 +583,8 @@ export type IntegrationEventWaitRuntimeContext = {
   orgId?: string;
   executorToken?: string;
   slackHitlDefaultTimeoutMs?: number;
+  /** Behavior selected by the admitted Play artifact, never worker version. */
+  slackHitlTimeoutOutcome?: 'park' | 'error';
 };
 
 export type IntegrationEventWaitBoundary = {
@@ -593,6 +604,13 @@ export type IntegrationEventWaitBoundary = {
   timeoutPolicy?: {
     suspendAfterTimeoutMs?: number;
     finalizeOnTimeout?: boolean;
+    /**
+     * A terminal policy is persisted with the boundary so durable replay never
+     * changes a published Play's timeout behavior.
+     */
+    timeoutOutcome?: 'return_null' | 'error';
+    /** Customer-authored message used only for the terminal error outcome. */
+    timeoutError?: string;
   };
 };
 
@@ -637,6 +655,8 @@ export interface ContextOptions {
   executionScope?: RunExecutionScope;
   /** Authoring semantics pinned by the immutable artifact. */
   authoringContractEdition?: PlayAuthoringContractEdition;
+  /** Direct/local callers may opt into the new terminal Slack HITL outcome. */
+  slackHitlTimeoutOutcome?: 'park' | 'error';
   /** Error shape pinned by the immutable play artifact; missing preserves legacy schema 0. */
   toolErrorSchemaVersion?: ToolExecutionErrorSchemaVersion;
   /** Execute-result contract pinned by the immutable Play artifact. */
@@ -856,7 +876,17 @@ export interface ContextOptions {
     requiresExecutionFence?: boolean;
   } | null>;
   getToolActionCacheVersion?: (toolId: string) => Promise<string> | string;
+  /**
+   * Source-declared older action identities that remain safe to read. They
+   * are read-only fallbacks: new receipts and provider calls always use the
+   * primary `getToolActionCacheVersion` value.
+   */
+  getToolActionCacheReadVersions?: (
+    toolId: string,
+  ) => Promise<string[]> | string[];
   getToolAuthScopeDigest?: (toolId: string) => Promise<string> | string;
+  /** Original run for an explicit customer rerun, never an automatic retry. */
+  replayedFromRunId?: string | null;
   getToolRateScope?: (
     toolId: string,
     provider: string,
@@ -887,6 +917,17 @@ export interface ContextOptions {
     | Promise<import('./async-operation').AsyncOperationContractWire | null>
     | import('./async-operation').AsyncOperationContractWire
     | null;
+  /**
+   * Bounded-check policy projected onto a caller-managed async lifecycle
+   * companion. The runtime owns cadence; provider adapters only translate
+   * this budget into their native result/status request.
+   */
+  getToolAsyncOperationPoll?: (
+    toolId: string,
+  ) =>
+    | Promise<import('./async-operation').AsyncOperationPollExecution | null>
+    | import('./async-operation').AsyncOperationPollExecution
+    | null;
   getIntegrationEventWaitHandler?: (
     toolId: string,
   ) =>
@@ -1027,6 +1068,11 @@ export interface PlayCheckpoint {
           channel: string;
           ts: string;
         };
+        /**
+         * Control-plane timeout behavior captured when the wait was armed.
+         * Missing fields preserve legacy checkpoint replay behavior.
+         */
+        timeoutPolicy?: IntegrationEventWaitBoundary['timeoutPolicy'];
         output?: unknown;
         completedAt?: number;
       }

package/dist/bundling-sources/shared_libs/play-runtime/daytona-payload-contract.ts

@@ -0,0 +1,68 @@
+import {
+  deployed,
+  readDeployedObject,
+  type DeployedDiagnostic,
+} from '@deepline/deployed-contracts';
+import type { PlayRunnerExecutionConfig } from './protocol';
+
+export type DaytonaPayloadEnvelope = {
+  /** Diagnostic only. A missing/different marker cannot block materialization. */
+  schemaVersion?: number;
+  runnerCode: string;
+  artifactBundledCode: string;
+  artifactSourceMap: string;
+  config: PlayRunnerExecutionConfig;
+  crashPusherCode: string;
+};
+
+export const DAYTONA_PAYLOAD_CONTRACT = deployed.object({
+  id: 'daytona-payload',
+  unknown: 'preserve',
+  fields: {
+    runnerCode: deployed.string(),
+    artifactBundledCode: deployed.string(),
+    artifactSourceMap: deployed.string(),
+    config: deployed.record(),
+    crashPusherCode: deployed.string(),
+    schemaVersion: deployed.optional(deployed.diagnostic.number(), {
+      whenAbsent: 'diagnostic unavailable',
+    }),
+  },
+});
+
+export const DAYTONA_PAYLOAD_FILE_FIELDS = [
+  'runnerCode',
+  'artifactBundledCode',
+  'artifactSourceMap',
+  'crashPusherCode',
+] as const;
+
+export function readDaytonaPayloadEnvelope(input: unknown): {
+  value: DaytonaPayloadEnvelope;
+  diagnostics: DeployedDiagnostic[];
+} {
+  const { value, diagnostics } = readDeployedObject(
+    DAYTONA_PAYLOAD_CONTRACT,
+    input,
+  );
+  return {
+    value: {
+      runnerCode: value.runnerCode as string,
+      artifactBundledCode: value.artifactBundledCode as string,
+      artifactSourceMap: value.artifactSourceMap as string,
+      config: value.config as PlayRunnerExecutionConfig,
+      crashPusherCode: value.crashPusherCode as string,
+    },
+    diagnostics,
+  };
+}
+
+/**
+ * The sandbox has only Node built-ins. Generate its tiny entry from the same
+ * contract-owned field list instead of maintaining a second hand-written list
+ * in transport code. This is shipped source, not Function#toString output.
+ */
+export function buildDaytonaPayloadMaterializerSource(): string {
+  const fields = JSON.stringify(DAYTONA_PAYLOAD_FILE_FIELDS);
+  return `const fs=require('node:fs');const zlib=require('node:zlib');const p=JSON.parse(zlib.gunzipSync(fs.readFileSync(process.argv[1])));if(!p||typeof p!=='object'||Array.isArray(p))throw new Error('Daytona payload: expected object');for(const key of ${fields})if(typeof p[key]!=='string')throw new Error('Daytona payload is missing required field '+key);if(!p.config||typeof p.config!=='object'||Array.isArray(p.config))throw new Error('Daytona payload is missing required field config');if(typeof p.schemaVersion==='number'&&p.schemaVersion!==1)console.warn('[daytona] payload schema marker differs; attempting structural materialization');fs.writeFileSync(process.argv[2],p.runnerCode);fs.writeFileSync(process.argv[3],JSON.stringify(p.config));fs.writeFileSync(process.argv[4],p.artifactBundledCode);fs.writeFileSync(process.argv[5],p.artifactSourceMap);fs.writeFileSync(process.argv[6],p.crashPusherCode);`;
+}

package/dist/bundling-sources/shared_libs/play-runtime/daytona-sandbox-janitor.ts

@@ -0,0 +1,103 @@
+import { withRuntimeSchedulerClient } from './/scheduler-backends/postgres-pool';
+import { isIsolatedRuntimeSchedulerSchema } from './/runtime-scheduler-topology';
+
+/** A single controller owns this fleet-wide sweep. Workers clean resources for
+ * their own attempts; they do not each enumerate the shared Daytona account. */
+export const DAYTONA_JANITOR_INTERVAL_MS = 5 * 60 * 1_000;
+
+export type DaytonaSandboxJanitorOptions = {
+  url: string;
+  schema: string;
+  maxClients?: number;
+};
+
+/**
+ * Start the production-only Daytona orphan sweep.
+ *
+ * Sandboxes have a source-scoped label shared by production, previews, and
+ * worktrees. An isolated schema cannot authoritatively distinguish its own
+ * sandboxes from the others, so it must never sweep. The fixed runtime
+ * controller is the one production owner; moving this here makes the Daytona
+ * list/read traffic constant with fleet size.
+ */
+export function startDaytonaSandboxJanitor(
+  options: DaytonaSandboxJanitorOptions,
+): { stop: () => void } {
+  if (!process.env.DAYTONA_API_KEY?.trim()) {
+    console.info('[daytona-janitor.controller] disabled (no DAYTONA_API_KEY)');
+    return { stop: () => undefined };
+  }
+  if (isIsolatedRuntimeSchedulerSchema(options.schema)) {
+    console.info('[daytona-janitor.controller] disabled (isolated schema)', {
+      schema: options.schema,
+    });
+    return { stop: () => undefined };
+  }
+
+  let running = false;
+  const runPass = async (): Promise<void> => {
+    if (running) {
+      console.info('[daytona-janitor.controller] skip (previous pass running)');
+      return;
+    }
+    running = true;
+    try {
+      const [
+        { Daytona },
+        { loadDaytonaRequiredConfig },
+        {
+          createPostgresDaytonaJanitorOwnershipPort,
+          reapOrphanDaytonaSandboxes,
+        },
+      ] = await Promise.all([
+        import('@daytonaio/sdk'),
+        import('.//daytona-runtime-config'),
+        import('./daytona-sandbox-reaper'),
+      ]);
+      const { clientOptions } = loadDaytonaRequiredConfig();
+      const daytona = new Daytona(clientOptions);
+      await withRuntimeSchedulerClient(
+        {
+          url: options.url,
+          applicationName: 'deepline-daytona-janitor',
+          maxClients: options.maxClients ?? 2,
+        },
+        (client) =>
+          reapOrphanDaytonaSandboxes({
+            daytona: {
+              list: (query) => daytona.list(query),
+            },
+            ownership: createPostgresDaytonaJanitorOwnershipPort({
+              client,
+              schema: options.schema,
+            }),
+          }),
+      );
+    } catch (error) {
+      // This is a best-effort resource backstop. A failed sweep must never
+      // terminate the controller that scales and recovers customer work.
+      console.warn('[daytona-janitor.controller] pass failed', {
+        error: error instanceof Error ? error.message : String(error),
+      });
+    } finally {
+      running = false;
+    }
+  };
+
+  const interval = setInterval(() => {
+    void runPass();
+  }, DAYTONA_JANITOR_INTERVAL_MS);
+  interval.unref();
+
+  // Run once immediately. The singleton controller has no fleet-start
+  // stampede to smooth, and an early pass shortens recovery after deploy.
+  void runPass();
+  console.info('[daytona-janitor.controller] scheduled', {
+    intervalMs: DAYTONA_JANITOR_INTERVAL_MS,
+    schema: options.schema,
+  });
+
+  return {
+    stop: () => clearInterval(interval),
+  };
+}