deepline 0.3.309 → 0.3.311

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.311',
   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/ledger-safe-payload.ts

@@ -95,8 +95,12 @@ export function sanitizeLedgerLogLines(value: unknown): string[] {
   return value
     .filter((line): line is string => typeof line === 'string')
     .slice(0, MAX_LEDGER_LOG_LINES_PER_EVENT)
-    .map((line) =>
-      boundRunLogLine(ledgerIngressRedactor.redactString(line.trim())),
-    )
+    .map((line) => sanitizeLedgerLogLine(line))
     .filter(Boolean);
 }
+
+/** Runtime measurement records use the terminal transport's existing byte budget. */
+export function sanitizeLedgerLogLine(line: string, bounded = true): string {
+  const redacted = ledgerIngressRedactor.redactString(line.trim());
+  return bounded ? boundRunLogLine(redacted) : redacted;
+}

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/bundling-sources/shared_libs/play-runtime/scheduler-backends/postgres.ts

@@ -4,6 +4,7 @@ import {
   type RunLedgerDispatchLaunch,
 } from './run-ledger-dispatch-authority';
 import { normalizeRunLogIds } from '../run-log-buffer';
+import { sanitizeLedgerLogLine } from '../ledger-safe-payload';
 import {
   retainedPlayPipelineFields,
   hydrateRetainedPlayPipelines,
@@ -10926,7 +10927,9 @@ export async function directCompletePostgresSchedulerRunnerTerminal(
       stringifyPostgresJson(runtimeTiming ?? null),
       stringifyPostgresJson(ledgerTerminalResult ?? null),
       JSON.stringify(terminalLogLines),
-      JSON.stringify(input.terminalProgressEvents ?? []),
+      JSON.stringify(
+        sanitizeTerminalProgressEvents(input.terminalProgressEvents),
+      ),
       postgresSchedulerNotifyChannel('terminal', options),
       JSON.stringify({ runId: input.runId, status: 'completed' }),
       input.leaseToken,
@@ -13305,7 +13308,7 @@ export async function completePostgresSchedulerAttempt(
   );
   const terminalLogEntries = (input.terminalLogLines ?? [])
     .map((line, index) => ({
-      line: line.trim(),
+      line: sanitizeTerminalLogBody(line),
       context: input.terminalLogContexts?.[index] ?? null,
       metadata: input.terminalLogMetadata?.[index] ?? null,
       entryId: terminalLogIds?.[index] ?? null,
@@ -13529,7 +13532,9 @@ export async function completePostgresSchedulerAttempt(
       JSON.stringify(terminalLogContexts),
       stringifyPostgresJson(input.terminalWorkCounterSegment ?? null),
       JSON.stringify(terminalLogMetadata),
-      JSON.stringify(input.terminalProgressEvents ?? []),
+      JSON.stringify(
+        sanitizeTerminalProgressEvents(input.terminalProgressEvents),
+      ),
       stringifyPostgresJson(
         terminalLogIds
           ? terminalLogEntries.map((entry) => entry.entryId)
@@ -13615,7 +13620,7 @@ export async function failPostgresSchedulerAttempt(
   );
   const terminalLogEntries = (input.terminalLogLines ?? [])
     .map((line, index) => ({
-      line: line.trim(),
+      line: sanitizeTerminalLogBody(line),
       context: input.terminalLogContexts?.[index] ?? null,
       metadata: input.terminalLogMetadata?.[index] ?? null,
       entryId: terminalLogIds?.[index] ?? null,
@@ -13901,7 +13906,9 @@ export async function failPostgresSchedulerAttempt(
       stringifyPostgresJson(resultSummary),
       JSON.stringify(terminalLogContexts),
       stringifyPostgresJson(terminalWorkCounterSegment ?? null),
-      stringifyPostgresJson(input.terminalProgressEvents ?? []),
+      stringifyPostgresJson(
+        sanitizeTerminalProgressEvents(input.terminalProgressEvents),
+      ),
       JSON.stringify(terminalLogMetadata),
       stringifyPostgresJson(
         terminalLogIds
@@ -14612,7 +14619,9 @@ function runnerTerminalLogPayload(input: {
     terminalLogContexts: projection.lineContexts,
     terminalLogMetadata: projection.lineMetadata,
     ...(projection.lineIds ? { terminalLogIds: projection.lineIds } : {}),
-    terminalProgressEvents: input.terminalProgressEvents ?? [],
+    terminalProgressEvents: sanitizeTerminalProgressEvents(
+      input.terminalProgressEvents,
+    ),
     // Older runner envelopes conveyed these diagnostics only in tagged log
     // text. Preserve their small structured facts before removing that text.
     recoveredRuntimeDiagnostics:
@@ -14629,6 +14638,41 @@ function runnerTerminalLogPayload(input: {
   };
 }
 
+function sanitizeTerminalProgressEvents(
+  events: readonly unknown[] = [],
+): unknown[] {
+  return events.map((event) => {
+    if (!event || typeof event !== 'object' || Array.isArray(event))
+      return event;
+    const item = event as Record<string, unknown>;
+    if (item.type !== 'log.appended' || !Array.isArray(item.lines))
+      return event;
+    return {
+      ...item,
+      // Keep every position and annotation aligned, including blank lines.
+      // Invalid values still reach the existing SQL validation unchanged.
+      lines: item.lines.map((line) =>
+        typeof line === 'string'
+          ? sanitizeTerminalLogBody(line) || '(blank log line)'
+          : line,
+      ),
+    };
+  });
+}
+
+function sanitizeTerminalLogBody(line: string): string {
+  const body = line.trim();
+  const runtimeDiagnostic =
+    body.startsWith('[runtime.failure_diagnostic] ') ||
+    body.startsWith('[runtime.phase_summary] ') ||
+    body.startsWith('[runtime.logs] ') ||
+    body.startsWith('[runtime.log_transport] ');
+  // These runtime records contain machine-readable JSON, already bounded by
+  // the terminal transport. Keep it parseable while applying the same redaction.
+  // Authored tagged lines retain the ordinary live-ingress line bound.
+  return sanitizeLedgerLogLine(body, !runtimeDiagnostic);
+}
+
 function terminalLogProjectionForOutbox(
   runnerResult: unknown,
   mode: PostgresSchedulerTerminalLogOutbox | undefined,
@@ -14689,7 +14733,9 @@ function terminalLogProjectionForOutbox(
         normalized.startsWith('[runtime.log_transport] ');
       if (!retained) return null;
       return {
-        line: line.trim(),
+        // The live API applies this same canonicalization before indexing.
+        // Replaying an origin ID must carry that exact redacted, bounded body.
+        line: sanitizeTerminalLogBody(line),
         context: normalizePlayLogContext(logContexts?.[index]),
         metadata: normalizePlayLogMetadata(logMetadata?.[index]),
         entryId: logIds?.[index] ?? null,

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

@@ -9,11 +9,11 @@ import {
   registerAuthCommands,
   reportSetupCompleted,
   resolvePendingAuthClaimForResume
-} from "./chunk-TQ5BV5RT.mjs";
-import "./chunk-GUUQJJBS.mjs";
-import "./chunk-N6P7NBX3.mjs";
+} from "./chunk-HOCPOTDX.mjs";
+import "./chunk-SPUTBCUR.mjs";
+import "./chunk-Q3LYQTSO.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-3EVKBS6J.mjs";
+import "./chunk-SGTSJCOA.mjs";
 import "./chunk-NXGCO4JB.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";

package/dist/cli/auth-66JFXP6C.js

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