deepline 0.3.309 → 0.3.310

package/dist/bundling-sources/sdk/src/release.ts

@@ -200,7 +200,7 @@ export const SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: '0.3.309',
+  version: '0.3.310',
   updateSummary:
     'Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.',
   packageCapabilities: {

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

@@ -379,6 +379,12 @@ async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
   daytona: DaytonaClient;
   sandboxName: string;
   cancellationSignal?: AbortSignal;
+  emitStage?: DaytonaStageEmitter;
+  operationIdentity?: {
+    providerOperationToken: string;
+    orgId: string;
+    runId?: string;
+  };
 }): Promise<TimedOutDaytonaSandboxReconciliation> {
   if (!input.daytona.get) return { kind: 'not_found' };
   let lastDeleteConflict: unknown = null;
@@ -391,12 +397,26 @@ async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
     try {
       sandbox = await input.daytona.get(input.sandboxName);
     } catch (error) {
+      const providerStatus =
+        error && typeof error === 'object' && 'statusCode' in error
+          ? error.statusCode
+          : null;
+      input.emitStage?.('create:reconcile_lookup_failed', {
+        providerStatus:
+          typeof providerStatus === 'number' ? providerStatus : null,
+      });
+      // Invalid provider credentials are not a sandbox state transition.
+      if (providerStatus === 401 || providerStatus === 403) throw error;
       // A current absence is not proof that the sent create cannot commit.
       // Return it to the durable operation owner without another create or
       // releasing capacity; later recovery re-reads the same identity.
       if (isDaytonaSandboxNotFound(error)) return { kind: 'not_found' };
       continue;
     }
+    input.emitStage?.('create:reconcile_state', {
+      sandboxId: sandbox.id,
+      state: sandbox.state ?? null,
+    });
     // `create` waits only a bounded interval, but the named sandbox may finish
     // the same create transition immediately afterwards. It is already the
     // durable identity associated with this provider operation, so reusing it
@@ -405,6 +425,26 @@ async function reconcileAndDeleteTimedOutDaytonaSandbox(input: {
     if (sandbox.state === 'started') {
       return { kind: 'started', sandbox };
     }
+    if (input.operationIdentity) {
+      const expected = input.operationIdentity;
+      const configuredOrganizationId =
+        process.env.DAYTONA_ORGANIZATION_ID?.trim();
+      if (
+        sandbox.name !== input.sandboxName ||
+        sandbox.labels?.source !== DAYTONA_PLAY_RUNNER_LABEL_SOURCE ||
+        sandbox.labels?.operationKey !== expected.providerOperationToken ||
+        sandbox.labels?.orgId !== normalizeLabelValue(expected.orgId) ||
+        (normalizeLabelValue(expected.runId) &&
+          sandbox.labels?.runId !== normalizeLabelValue(expected.runId)) ||
+        !sandbox.organizationId?.trim() ||
+        (configuredOrganizationId &&
+          sandbox.organizationId !== configuredOrganizationId)
+      ) {
+        throw new Error(
+          'Daytona resumed sandbox identity or organization routing does not match its reserved operation. Cleanup and fallback suppressed.',
+        );
+      }
+    }
     try {
       await input.daytona.delete(sandbox, 30);
     } catch (error) {
@@ -474,14 +514,24 @@ async function createRetriedOneShotDaytonaSandbox(input: {
     const reservation = await input.reserveSandboxCapacity?.(attempt);
     const sandboxName = daytonaSandboxName(reservation?.providerOperationToken);
     if (reservation?.resumeExistingProviderOperation) {
-      if (!input.daytona.get) {
+      if (!reservation.providerOperationToken) {
         throw new DaytonaSandboxTransitionPendingError(sandboxName);
       }
-      try {
-        const sandbox = await input.daytona.get(sandboxName);
-        if (sandbox.state !== 'started') {
-          throw new DaytonaSandboxTransitionPendingError(sandboxName);
-        }
+      // Recovery must converge when the timed-out create has stopped or failed,
+      // using the same provider-confirmed cleanup path as its initial observer.
+      const reconciliation = await reconcileAndDeleteTimedOutDaytonaSandbox({
+        daytona: input.daytona,
+        sandboxName,
+        cancellationSignal: input.cancellationSignal,
+        emitStage: input.emitStage,
+        operationIdentity: {
+          providerOperationToken: reservation.providerOperationToken,
+          orgId: input.orgId,
+          runId: input.context.runId ?? undefined,
+        },
+      });
+      if (reconciliation.kind === 'started') {
+        const sandbox = reconciliation.sandbox;
         const acquiredAt = Date.now();
         input.emitStage('create:resumed', {
           attempt,
@@ -494,15 +544,17 @@ async function createRetriedOneShotDaytonaSandbox(input: {
           attemptElapsedMs: acquiredAt - attemptStartedAt,
           sandboxCapacityLeaseId: reservation.leaseId,
         };
-      } catch (error) {
-        if (error instanceof DaytonaSandboxTransitionPendingError) throw error;
-        if (!isDaytonaSandboxNotFound(error)) {
-          throw new DaytonaSandboxTransitionPendingError(sandboxName);
-        }
-        // A lookup 404 does not prove that an earlier sent create cannot still
-        // commit. Keep the durable identity reserved; never hedge its outcome.
-        throw new DaytonaSandboxTransitionPendingError(sandboxName);
       }
+      if (reconciliation.kind === 'deleted') {
+        await input.releaseSandboxCapacity?.(reservation.leaseId);
+        throw new DaytonaSandboxAcquisitionUnavailableError(
+          'daytona_sandbox_start_timeout',
+          'The resumed timed-out Daytona sandbox was reconciled and deleted before fallback.',
+        );
+      }
+      // Neither absence nor an ongoing transition proves that create cannot
+      // commit. Retain the durable identity and its capacity reservation.
+      throw new DaytonaSandboxTransitionPendingError(sandboxName);
     }
     let sandbox: DaytonaSandbox;
     try {
@@ -551,6 +603,7 @@ async function createRetriedOneShotDaytonaSandbox(input: {
             daytona: input.daytona,
             sandboxName,
             cancellationSignal: input.cancellationSignal,
+            emitStage: input.emitStage,
           });
         } catch (reconciliationError) {
           await recordCreateFailure();

package/dist/bundling-sources/shared_libs/play-runtime/scheduler-backends/absurd-runtime-worker.ts

@@ -2271,6 +2271,10 @@ async function settleObservedTerminal(input: {
     });
     return;
   }
+  // The terminal and its outbox fact are already committed. Visibility must
+  // not wait for the mixed-version billing repair below; repair still finishes
+  // before this worker retires the attempt.
+  requestTerminalOutboxProjection({ ...input, trigger: input.source });
   const backfilledBilling = await input.deps.runWithClient((client) =>
     ensurePostgresSchedulerTerminalComputeBillingJob(
       client,
@@ -2288,7 +2292,6 @@ async function settleObservedTerminal(input: {
       },
     );
   }
-  requestTerminalOutboxProjection({ ...input, trigger: input.source });
 }
 
 /**

package/dist/cli/auth-CP4YBO33.js

@@ -0,0 +1,31 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+var _chunkDCUYMHHVjs = require('./chunk-DCUYMHHV.js');
+require('./chunk-RYO6353O.js');
+require('./chunk-QARMMLYE.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-KKAAKV77.js');
+require('./chunk-7P5AA3SN.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+
+
+
+
+
+
+
+
+
+
+exports.EXIT_WORKSPACE_MISMATCH = _chunkDCUYMHHVjs.EXIT_WORKSPACE_MISMATCH; exports.clearPendingClaim = _chunkDCUYMHHVjs.clearPendingClaim; exports.clearSatisfiedPendingClaim = _chunkDCUYMHHVjs.clearSatisfiedPendingClaim; exports.handleRegister = _chunkDCUYMHHVjs.handleRegister; exports.handleStatus = _chunkDCUYMHHVjs.handleStatus; exports.handleWait = _chunkDCUYMHHVjs.handleWait; exports.readPendingAuthClaim = _chunkDCUYMHHVjs.readPendingAuthClaim; exports.registerAuthCommands = _chunkDCUYMHHVjs.registerAuthCommands; exports.reportSetupCompleted = _chunkDCUYMHHVjs.reportSetupCompleted; exports.resolvePendingAuthClaimForResume = _chunkDCUYMHHVjs.resolvePendingAuthClaimForResume;

package/dist/cli/{auth-AA5SXOB6.mjs → auth-CS6NQ737.mjs}

@@ -9,11 +9,11 @@ import {
   registerAuthCommands,
   reportSetupCompleted,
   resolvePendingAuthClaimForResume
-} from "./chunk-TQ5BV5RT.mjs";
-import "./chunk-GUUQJJBS.mjs";
-import "./chunk-N6P7NBX3.mjs";
+} from "./chunk-LUJGLZCJ.mjs";
+import "./chunk-OJWZADOG.mjs";
+import "./chunk-M4KGWEN2.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-3EVKBS6J.mjs";
+import "./chunk-VN7Y4LVH.mjs";
 import "./chunk-NXGCO4JB.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";