deepline 0.3.308 → 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.308',
+  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/bundling-sources/shared_libs/plays/share/static-pipeline-summary.ts

@@ -7,6 +7,8 @@ import {
   deriveStaticPipelineEntryInputFields,
   flattenStaticPipeline,
   getTopLevelPipelineSubsteps,
+  inputFieldFromStaticCsvArg,
+  type PlayStaticColumnProducer,
   type PlayStaticPipeline,
   type PlayStaticSubstep,
 } from '../static-pipeline';
@@ -473,17 +475,49 @@ function publicSubstepBase(
   );
 }
 
+function projectPublicColumnProducer(
+  producer: PlayStaticColumnProducer,
+  depth: number,
+  maxDepth: number,
+): PlayStaticColumnProducer {
+  return {
+    id: producer.id,
+    kind: producer.kind,
+    field: producer.field,
+    ...(producer.toolId ? { toolId: producer.toolId } : {}),
+    ...(producer.playId ? { playId: producer.playId } : {}),
+    ...(producer.conditional !== undefined
+      ? { conditional: producer.conditional }
+      : {}),
+    substep: projectPublicSubstep(
+      producer.substep,
+      maxDepth === Infinity ? depth + 1 : MAX_PUBLIC_SUBSTEP_DEPTH,
+      maxDepth,
+    ),
+    ...(maxDepth === Infinity && producer.steps
+      ? {
+          steps: producer.steps.map((step) =>
+            projectPublicColumnProducer(step, depth + 1, maxDepth),
+          ),
+        }
+      : {}),
+  };
+}
+
 function projectPublicPipeline(
   pipeline: PlayStaticPipeline,
   depth: number,
+  maxDepth = MAX_PUBLIC_SUBSTEP_DEPTH,
 ): PlayStaticPipeline {
+  const safePipeline = buildAppGraphPipeline(pipeline)!;
+  if (maxDepth === Infinity) return safePipeline;
   return {
-    ...pipeline,
-    stages: (pipeline.stages ?? []).map((substep) =>
-      projectPublicSubstep(substep, depth),
+    ...safePipeline,
+    stages: (safePipeline.stages ?? []).map((substep) =>
+      projectPublicSubstep(substep, depth, maxDepth),
     ),
-    substeps: pipeline.substeps.map((substep) =>
-      projectPublicSubstep(substep, depth),
+    substeps: safePipeline.substeps.map((substep) =>
+      projectPublicSubstep(substep, depth, maxDepth),
     ),
   };
 }
@@ -491,12 +525,21 @@ function projectPublicPipeline(
 function projectPublicSubstep(
   substep: PlayStaticSubstep,
   depth: number,
+  maxDepth = MAX_PUBLIC_SUBSTEP_DEPTH,
 ): PlayStaticSubstep {
   const base = publicSubstepBase(substep);
-  const projectChildren = depth < MAX_PUBLIC_SUBSTEP_DEPTH;
+  const projectChildren = depth < maxDepth;
   const child = (value: PlayStaticSubstep) =>
-    projectPublicSubstep(value, depth + 1);
+    projectPublicSubstep(value, depth + 1, maxDepth);
 
+  if (substep.type === 'csv' && maxDepth === Infinity) {
+    return {
+      ...base,
+      type: 'csv',
+      field: substep.field,
+      ...(substep.path ? { path: `input.${substep.field}` } : {}),
+    } as PlayStaticSubstep;
+  }
   if (substep.type === 'dataset') {
     return {
       ...base,
@@ -506,20 +549,9 @@ function projectPublicSubstep(
         id: column.id,
         source: column.source,
         ...(column.sqlName ? { sqlName: column.sqlName } : {}),
-        producers: column.producers.map((producer) => ({
-          id: producer.id,
-          kind: producer.kind,
-          field: producer.field,
-          ...(producer.toolId ? { toolId: producer.toolId } : {}),
-          ...(producer.playId ? { playId: producer.playId } : {}),
-          ...(producer.conditional !== undefined
-            ? { conditional: producer.conditional }
-            : {}),
-          substep: projectPublicSubstep(
-            producer.substep,
-            MAX_PUBLIC_SUBSTEP_DEPTH,
-          ),
-        })),
+        producers: column.producers.map((producer) =>
+          projectPublicColumnProducer(producer, depth, maxDepth),
+        ),
       })),
       steps: projectChildren ? (substep.steps ?? []).map(child) : [],
     } as PlayStaticSubstep;
@@ -571,7 +603,7 @@ function projectPublicSubstep(
       field: substep.field,
       pipeline:
         projectChildren && substep.pipeline
-          ? projectPublicPipeline(substep.pipeline, depth + 1)
+          ? projectPublicPipeline(substep.pipeline, depth + 1, maxDepth)
           : null,
     } as PlayStaticSubstep;
   }
@@ -581,6 +613,10 @@ function projectPublicSubstep(
       type: 'play_launch',
       playId: substep.playId,
       field: substep.field,
+      pipeline:
+        projectChildren && substep.pipeline
+          ? projectPublicPipeline(substep.pipeline, depth + 1, maxDepth)
+          : null,
     } as PlayStaticSubstep;
   }
   return base as PlayStaticSubstep;
@@ -601,6 +637,45 @@ export function buildPublicSubsteps(
   return topLevel.map((substep) => projectPublicSubstep(substep, 0));
 }
 
+/** Full structural graph for an authenticated, sandboxed app view. Unlike the
+ * share package, this retains nested branches while excluding source locations
+ * and raw parameter text. The dashboard and MCP App then use one renderer. */
+export function buildAppGraphPipeline(
+  staticPipeline: unknown,
+): PlayStaticPipeline | null {
+  const pipeline = asPipeline(staticPipeline);
+  if (!pipeline) return null;
+  const docflow = buildPublicDocflow(pipeline);
+  const csvInput = inputFieldFromStaticCsvArg(pipeline.csvArg);
+  return {
+    ...(docflow ? { docflow } : {}),
+    ...(pipeline.tableNamespace
+      ? { tableNamespace: pipeline.tableNamespace }
+      : {}),
+    ...(pipeline.inputFields ? { inputFields: [...pipeline.inputFields] } : {}),
+    ...(pipeline.csvArg ? { csvArg: `input.${csvInput ?? 'csv'}` } : {}),
+    ...(pipeline.csvDescription
+      ? { csvDescription: pipeline.csvDescription }
+      : {}),
+    ...(pipeline.datasetDescription
+      ? { datasetDescription: pipeline.datasetDescription }
+      : {}),
+    fields: [...pipeline.fields],
+    ...(pipeline.returnFields
+      ? { returnFields: pipeline.returnFields.map((field) => ({ ...field })) }
+      : {}),
+    stages: (pipeline.stages ?? []).map((substep) =>
+      projectPublicSubstep(substep, 0, Infinity),
+    ),
+    substeps: pipeline.substeps.map((substep) =>
+      projectPublicSubstep(substep, 0, Infinity),
+    ),
+    ...(pipeline.sheetContract
+      ? { sheetContract: pipeline.sheetContract }
+      : {}),
+  };
+}
+
 /** Distinct provider names across the full (flattened) pipeline. */
 export function extractProviderNames(staticPipeline: unknown): string[] {
   const pipeline = asPipeline(staticPipeline);

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-ZWX4BF5K.mjs → auth-CS6NQ737.mjs}

@@ -9,11 +9,11 @@ import {
   registerAuthCommands,
   reportSetupCompleted,
   resolvePendingAuthClaimForResume
-} from "./chunk-CXU7ME5X.mjs";
-import "./chunk-ABMGEW3C.mjs";
-import "./chunk-T3P4NRZU.mjs";
+} from "./chunk-LUJGLZCJ.mjs";
+import "./chunk-OJWZADOG.mjs";
+import "./chunk-M4KGWEN2.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-YSZSERRZ.mjs";
+import "./chunk-VN7Y4LVH.mjs";
 import "./chunk-NXGCO4JB.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";