deepline 0.3.373 → 0.3.375

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.373',
+  version: '0.3.375',
   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-payload-transport.ts

@@ -28,7 +28,6 @@ import {
   RUNTIME_SANDBOX_MEMORY_ABORT_CODE,
   RUNTIME_SANDBOX_MEMORY_ABORT_MESSAGE,
   RUNTIME_SANDBOX_OOM_MESSAGE,
-  RUNTIME_CONTROL_PLANE_UNAVAILABLE_MESSAGE,
 } from '../../run-failure';
 import {
   buildDaytonaPayloadMaterializerSource,
@@ -295,41 +294,6 @@ function watchdogMemoryAbortDiagnostic() {
   return null;
 }
 
-function watchdogRunnerHeartbeatUnavailableDiagnostic() {
-  try {
-    if (!terminationDiagnosticPath) return null;
-    const diagnostic = JSON.parse(
-      fs.readFileSync(terminationDiagnosticPath, 'utf8'),
-    );
-    if (
-      !diagnostic ||
-      diagnostic.schemaVersion !== 1 ||
-      diagnostic.reason !== 'runner_heartbeat_unreachable'
-    ) {
-      return null;
-    }
-    return {
-      heartbeatAttempt: Number.isSafeInteger(diagnostic.heartbeatAttempt)
-        ? diagnostic.heartbeatAttempt
-        : null,
-      heartbeatAgeMs: Number.isFinite(diagnostic.heartbeatAgeMs)
-        ? Math.max(0, diagnostic.heartbeatAgeMs)
-        : null,
-      leaseMs: Number.isFinite(diagnostic.leaseMs)
-        ? Math.max(0, diagnostic.leaseMs)
-        : null,
-      lastErrorCode:
-        typeof diagnostic.lastErrorCode === 'string' &&
-        /^(?:E[A-Z0-9_]+|ERR_[A-Z0-9_]+|UND_ERR_[A-Z0-9_]+|TimeoutError|redirect_[0-9]{3}|http_[0-9]{3}|protocol_error|unknown)$/.test(
-          diagnostic.lastErrorCode,
-        )
-          ? diagnostic.lastErrorCode
-          : 'unknown',
-    };
-  } catch {}
-  return null;
-}
-
 function memoryAbortCause(diagnostic) {
   const parts = [
     ${JSON.stringify(`${RUNTIME_SANDBOX_MEMORY_ABORT_CODE}: ${RUNTIME_SANDBOX_MEMORY_ABORT_MESSAGE}`)},
@@ -411,7 +375,6 @@ async function main() {
   // SIGKILL does not collapse into the wrapper's generic exit code 1.
   const sandboxKilled = exitCode === 137 || watchdogObservedChildSigkill();
   const memoryAbort = watchdogMemoryAbortDiagnostic();
-  const heartbeatUnavailable = watchdogRunnerHeartbeatUnavailableDiagnostic();
   const sandboxOom =
     !memoryAbort &&
     sandboxKilled &&
@@ -422,10 +385,6 @@ async function main() {
       ? memoryAbortCause(memoryAbort)
     : sandboxOom
       ? 'RUNTIME_SANDBOX_OOM: ' + ${JSON.stringify(RUNTIME_SANDBOX_OOM_MESSAGE)}
-    : heartbeatUnavailable
-      ? 'RUNTIME_CONTROL_PLANE_UNAVAILABLE: ' +
-        ${JSON.stringify(RUNTIME_CONTROL_PLANE_UNAVAILABLE_MESSAGE)} +
-        ' heartbeat=' + JSON.stringify(heartbeatUnavailable)
       : sandboxKilled
         ? 'RUNTIME_SANDBOX_KILLED: ' + ${JSON.stringify(RUNTIME_SANDBOX_KILLED_MESSAGE)}
     :
@@ -453,15 +412,6 @@ async function main() {
           cause: synthesizedError,
       }] }
       : {}),
-    ...(heartbeatUnavailable && !runtimeLimitExceeded && !memoryAbort && !sandboxOom
-      ? { errors: [{
-          code: 'RUNTIME_CONTROL_PLANE_UNAVAILABLE',
-          phase: 'infrastructure',
-          message: ${JSON.stringify(RUNTIME_CONTROL_PLANE_UNAVAILABLE_MESSAGE)},
-          retryable: false,
-          cause: synthesizedError,
-        }] }
-      : {}),
     ...(sandboxOom
       ? { errors: [{
           code: 'RUNTIME_SANDBOX_OOM',
@@ -480,9 +430,7 @@ async function main() {
           cause: synthesizedError,
         }] }
       : {}),
-    logs: heartbeatUnavailable
-      ? ['[runtime.failure_diagnostic] ' + JSON.stringify({ event: 'runner_heartbeat_unavailable', ...heartbeatUnavailable })]
-      : [],
+    logs: [],
     stats: {},
     steps: [],
     checkpointDisposition: '${RUNNER_TERMINAL_CHECKPOINT_DISPOSITION.ABSENT}',

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

@@ -196,8 +196,6 @@ let heartbeatConfigRead = false;
 let heartbeatConfig = null;
 let heartbeatLastSuccessAtMs = 0;
 let heartbeatAttempt = 0;
-let heartbeatLastErrorCode = null;
-let heartbeatStopBeforeLeaseMs = 0;
 let stopRequested = false;
 
 function readRunnerHeartbeatConfig() {
@@ -246,7 +244,7 @@ function stopRunnerHeartbeat() {
 
 function runnerHeartbeatErrorCode(error) {
   const code = error && typeof error.code === 'string' ? error.code : '';
-  if (/^(?:E[A-Z0-9_]+|ERR_[A-Z0-9_]+|UND_ERR_[A-Z0-9_]+)$/.test(code)) return code;
+  if (/^(?:E[A-Z0-9_]+|ERR_[A-Z0-9_]+|UND_ERR_[A-Z0-9_]+|http_[0-9]{3}|redirect_[0-9]{3}|protocol_error)$/.test(code)) return code;
   const name = error && typeof error.name === 'string' ? error.name : '';
   if (name === 'AbortError' || name === 'TimeoutError') return name;
   return 'unknown';
@@ -263,10 +261,6 @@ function startRunnerHeartbeatSupervisor() {
   const handoffAt = Number(handoff && handoff.lastHeartbeatAtMs);
   heartbeatLastSuccessAtMs = Number.isFinite(handoffAt) ? handoffAt : Date.now();
   const cadenceMs = Math.max(250, Math.floor(config.leaseMs / ${RUNTIME_CLAIM_HEARTBEAT_DIVISOR}));
-  heartbeatStopBeforeLeaseMs = Math.max(
-    0,
-    config.leaseMs - cadenceMs - ${RUNNER_HEARTBEAT_REQUEST_TIMEOUT_MS},
-  );
   process.stderr.write(
     '[play-runner.heartbeat] watchdog_owner_started ' +
       JSON.stringify({ runId: config.runId, cadenceMs, handoffHeartbeatAgeMs: Math.max(0, Date.now() - heartbeatLastSuccessAtMs) }) +
@@ -325,35 +319,33 @@ async function runnerHeartbeatTick() {
       throw Object.assign(new Error('gateway_protocol_error'), { code: 'protocol_error' });
     }
     heartbeatLastSuccessAtMs = Date.now();
-    heartbeatLastErrorCode = null;
   } catch (error) {
     if (heartbeatStopped || settled) return;
-    heartbeatLastErrorCode = controller.signal.aborted
+    const errorCode = controller.signal.aborted
       ? 'TimeoutError'
       : runnerHeartbeatErrorCode(error);
     const heartbeatAgeMs = Math.max(0, Date.now() - heartbeatLastSuccessAtMs);
     process.stderr.write(
       '[play-runner.heartbeat] watchdog_owner_retrying ' +
-        JSON.stringify({ runId: config.runId, attempt: heartbeatAttempt, durationMs: Math.max(0, Date.now() - startedAt), heartbeatAgeMs, errorCode: heartbeatLastErrorCode }) +
+        JSON.stringify({ runId: config.runId, attempt: heartbeatAttempt, durationMs: Math.max(0, Date.now() - startedAt), heartbeatAgeMs, errorCode }) +
         '\\n',
     );
-    // Stop before the scheduler's lease expires. A failed request can consume
-    // its full timeout, and the next cadence would otherwise let the scheduler
-    // win the terminal race and report an ambiguous runner loss.
-    if (heartbeatAgeMs >= heartbeatStopBeforeLeaseMs) {
+    // The gateway answered definitively: this token is invalid (401), out of
+    // scope (403), or its attempt is no longer the run's current one (404).
+    // Nothing else stops a superseded attempt's paid calls, so stop now.
+    const rejection = /^http_(401|403|404)$/.exec(errorCode);
+    if (rejection) {
       stopRunnerHeartbeat();
-      const diagnostic = {
-        heartbeatAttempt,
-        heartbeatAgeMs,
-        leaseMs: config.leaseMs,
-        stopBeforeLeaseMs: heartbeatStopBeforeLeaseMs,
-        lastErrorCode: heartbeatLastErrorCode,
-      };
+      const diagnostic = { heartbeatAttempt, status: Number(rejection[1]) };
       process.stderr.write(
-        'RUNTIME_CONTROL_PLANE_UNAVAILABLE: ' + JSON.stringify(diagnostic) + '\\n',
+        '[play-runner.heartbeat] watchdog_owner_rejected ' + JSON.stringify(diagnostic) + '\\n',
       );
-      stopChild('runner_heartbeat_unreachable', diagnostic);
+      stopChild('runner_heartbeat_rejected', diagnostic);
     }
+    // Otherwise keep renewing. An unreachable or failing control plane is not
+    // evidence that this run is over: the scheduler owns the liveness verdict
+    // and confirms it only after it can accept heartbeats again. The runtime
+    // limit, the terminal channel above, and sandbox cleanup bound this process.
   } finally {
     clearTimeout(timeout);
     if (heartbeatController === controller) heartbeatController = null;

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

@@ -45,6 +45,7 @@ import {
 } from '../app-runtime-api';
 import { RUNTIME_CAPACITY_POLICY } from '../runtime-capacity-policy';
 import { RUNTIME_RELIABILITY_POLICY } from '../runtime-reliability-policy';
+import { RUNTIME_CLAIM_HEARTBEAT_DIVISOR } from '../runtime-constants';
 import type { RuntimeTrafficPolicy } from '../runtime-traffic-policy';
 import { runtimeLimitExceededCause } from '../run-failure';
 import {
@@ -736,7 +737,7 @@ export class AbsurdExecutionOperationTimeoutError extends Error {
  * park/resume seam without a real engine. */
 export type AbsurdSuspensionContext = Pick<
   TaskContext,
-  'sleepFor' | 'sleepUntil' | 'awaitEvent' | 'heartbeat'
+  'sleepFor' | 'sleepUntil' | 'awaitEvent' | 'heartbeat' | 'step'
 >;
 
 /** Injected DB + app-runtime seams so the handler is testable against real SQL
@@ -1284,6 +1285,46 @@ function signalData(
   return null;
 }
 
+const LIVENESS_CONFIRMATION_SLICES_PER_CADENCE = 4;
+
+/**
+ * A stale heartbeat proves a lost runner only if the runner could have renewed
+ * it. During a scheduler-store stall no runner can, and the worker's own
+ * scheduling writes (`schedule_run` NOTIFYs) stall with it. So the worker
+ * counts only short sleep slices that woke on time, and decides after two
+ * heartbeat cadences of such observed availability. A late slice counts for
+ * nothing. Slice times and lateness are checkpointed, so replay is
+ * deterministic. Returns true when the runner stayed silent or the hard
+ * ceiling arrived, false as soon as it renewed or pushed its terminal.
+ */
+async function confirmDetachedRunnerSilence(input: {
+  ctx: AbsurdSuspensionContext;
+  stepPrefix: string;
+  cadenceMs: number;
+  ceilingDeadlineMs: number;
+  runnerResponded: () => Promise<boolean>;
+}): Promise<boolean> {
+  const sliceMs = Math.floor(
+    input.cadenceMs / LIVENESS_CONFIRMATION_SLICES_PER_CADENCE,
+  );
+  let observedMs = 0;
+  for (let slice = 1; observedMs < 2 * input.cadenceMs; slice += 1) {
+    const stepName = `${input.stepPrefix}:${slice}`;
+    const wakeAtMs = await input.ctx.step(`${stepName}:at`, async () =>
+      Math.min(input.ceilingDeadlineMs, Date.now() + sliceMs),
+    );
+    await input.ctx.sleepUntil(stepName, new Date(wakeAtMs));
+    if (await input.runnerResponded()) return false;
+    if (wakeAtMs >= input.ceilingDeadlineMs) return true;
+    const lateMs = await input.ctx.step(
+      `${stepName}:late`,
+      async () => Date.now() - wakeAtMs,
+    );
+    if (lateMs <= sliceMs) observedMs += sliceMs;
+  }
+  return true;
+}
+
 /**
  * Map a runner suspension onto an absurd durable primitive and return the
  * checkpoint with the resolved boundary output. THROWS `SuspendTask` when the
@@ -1382,9 +1423,30 @@ export async function parkAndResolveSuspension(input: {
         (Number.isFinite(renewedAtMs) ? renewedAtMs : suspension.startedAtMs) +
           heartbeatTimeoutMs,
       );
-      if (renewedDeadlineMs <= Date.now() || renewedDeadlineMs === deadlineMs) {
-        break;
+      if (renewedDeadlineMs > Date.now()) {
+        if (renewedDeadlineMs === deadlineMs) break;
+        continue;
       }
+      if (ceilingDeadlineMs <= Date.now()) break;
+      const readRunnerTerminal = input.readRunnerTerminal;
+      const readRunnerLiveness = input.readRunnerLiveness;
+      const silent = await confirmDetachedRunnerSilence({
+        ctx,
+        stepPrefix: `${suspension.boundaryId}:liveness-confirm:${Number.isFinite(renewedAtMs) ? renewedAtMs : 'none'}`,
+        cadenceMs: Math.floor(
+          heartbeatTimeoutMs / RUNTIME_CLAIM_HEARTBEAT_DIVISOR,
+        ),
+        ceilingDeadlineMs,
+        runnerResponded: async () => {
+          if (await readRunnerTerminal(suspension.runnerAttempt)) return true;
+          const current = await readRunnerLiveness(suspension.runnerAttempt);
+          const currentAtMs = current?.heartbeatAt
+            ? Date.parse(current.heartbeatAt)
+            : Number.NaN;
+          return Number.isFinite(currentAtMs) && !(currentAtMs <= renewedAtMs);
+        },
+      });
+      if (silent) break;
     }
     // Truth is the persisted terminal (read by the caller's wake path); the
     // absurd event carries no payload we trust.

package/dist/cli/auth-B7CLYD7R.js

@@ -0,0 +1,35 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkHP4BE43Njs = require('./chunk-HP4BE43N.js');
+require('./chunk-GN5QM2BB.js');
+require('./chunk-IQTHRG6E.js');
+require('./chunk-XNYIZMNQ.js');
+require('./chunk-7P5AA3SN.js');
+require('./chunk-ADSZGPYZ.js');
+require('./chunk-OG64RBAC.js');
+require('./chunk-COGTRVWW.js');
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.EXIT_WORKSPACE_MISMATCH = _chunkHP4BE43Njs.EXIT_WORKSPACE_MISMATCH; exports.authStatusLine = _chunkHP4BE43Njs.authStatusLine; exports.clearPendingClaim = _chunkHP4BE43Njs.clearPendingClaim; exports.clearSatisfiedPendingClaim = _chunkHP4BE43Njs.clearSatisfiedPendingClaim; exports.handleRegister = _chunkHP4BE43Njs.handleRegister; exports.handleStatus = _chunkHP4BE43Njs.handleStatus; exports.handleWait = _chunkHP4BE43Njs.handleWait; exports.httpJson = _chunkHP4BE43Njs.httpJson; exports.readPendingAuthClaim = _chunkHP4BE43Njs.readPendingAuthClaim; exports.registerAuthCommands = _chunkHP4BE43Njs.registerAuthCommands; exports.reportSetupCompleted = _chunkHP4BE43Njs.reportSetupCompleted; exports.resolvePendingAuthClaimForResume = _chunkHP4BE43Njs.resolvePendingAuthClaimForResume;

package/dist/cli/{auth-7BMCDCRH.mjs → auth-U3Y7DTIG.mjs}

@@ -6,16 +6,17 @@ import {
   handleRegister,
   handleStatus,
   handleWait,
+  httpJson,
   readPendingAuthClaim,
   registerAuthCommands,
   reportSetupCompleted,
   resolvePendingAuthClaimForResume
-} from "./chunk-XMME4SCK.mjs";
-import "./chunk-HNLXC5BP.mjs";
-import "./chunk-IUYKSTWB.mjs";
+} from "./chunk-MKS7C3YR.mjs";
+import "./chunk-M5QDOHLG.mjs";
+import "./chunk-4GP56LRE.mjs";
 import "./chunk-DLIRSHV6.mjs";
 import "./chunk-NXGCO4JB.mjs";
-import "./chunk-P5JPGZNI.mjs";
+import "./chunk-IG3GOO4T.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";
 export {
@@ -26,6 +27,7 @@ export {
   handleRegister,
   handleStatus,
   handleWait,
+  httpJson,
   readPendingAuthClaim,
   registerAuthCommands,
   reportSetupCompleted,