deepline 0.1.149 → 0.1.151

package/dist/bundling-sources/shared_libs/plays/bundling/index.ts

@@ -1513,18 +1513,28 @@ async function computeWorkersHarnessFingerprintWithAdapter(
       hash: sha256(contents),
     });
   };
-  const collectTopLevelTsFiles = async (
+  const collectTsFilesRecursive = async (
     rootDir: string,
     parts: Array<{ name: string; hash: string }>,
   ) => {
     if (!(await fileExists(rootDir))) return;
-    const entries = await readdir(rootDir, { withFileTypes: true });
-    const tsFiles = entries
-      .filter((entry) => entry.isFile() && /\.[cm]?ts$/.test(entry.name))
-      .map((entry) => entry.name)
-      .sort();
-    for (const name of tsFiles) {
-      await addFilePart(parts, rootDir, join(rootDir, name));
+    const filePaths: string[] = [];
+    const visitDir = async (dir: string) => {
+      const entries = await readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const childPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          await visitDir(childPath);
+          continue;
+        }
+        if (entry.isFile() && /\.[cm]?ts$/.test(entry.name)) {
+          filePaths.push(childPath);
+        }
+      }
+    };
+    await visitDir(rootDir);
+    for (const filePath of filePaths.sort()) {
+      await addFilePart(parts, rootDir, filePath);
     }
   };
   const collectIntegrationBatchingFiles = async (
@@ -1554,26 +1564,13 @@ async function computeWorkersHarnessFingerprintWithAdapter(
     }
   };
 
-  const entries = await readdir(adapter.workersHarnessFilesDir, {
-    withFileTypes: true,
-  });
-  const tsFiles = entries
-    .filter((e) => e.isFile() && /\.[cm]?ts$/.test(e.name))
-    .map((e) => e.name)
-    .sort();
   const parts: Array<{ name: string; hash: string }> = [];
-  for (const name of tsFiles) {
-    await addFilePart(
-      parts,
-      adapter.workersHarnessFilesDir,
-      join(adapter.workersHarnessFilesDir, name),
-    );
-  }
+  await collectTsFilesRecursive(adapter.workersHarnessFilesDir, parts);
   for (const dir of adapter.workersRuntimeFingerprintDirs ?? []) {
     if (basename(dir) === 'integrations') {
       await collectIntegrationBatchingFiles(dir, parts);
     } else {
-      await collectTopLevelTsFiles(dir, parts);
+      await collectTsFilesRecursive(dir, parts);
     }
   }
   return sha256(JSON.stringify(parts));

package/dist/cli/index.js

@@ -420,7 +420,7 @@ function loadProjectEnvCandidates(startDir = process.cwd()) {
   }));
 }
 function normalizeBaseUrl(baseUrl) {
-  const trimmed = baseUrl.trim().replace(/\/+$/, "");
+  const trimmed = baseUrl?.trim().replace(/\/+$/, "") ?? "";
   if (!trimmed) return "";
   try {
     const parsed = new URL(trimmed);
@@ -655,10 +655,10 @@ var SDK_RELEASE = {
   // the SDK enrich generator's one-second stale policy.
   // 0.1.110 ships authored V2 prebuilts and required top-level play descriptions.
   // 0.1.111 ships dataset-native tool list getters and result row datasets.
-  version: "0.1.149",
+  version: "0.1.151",
   apiContract: "2026-06-dataset-handle-results-hard-cutover",
   supportPolicy: {
-    latest: "0.1.149",
+    latest: "0.1.151",
     minimumSupported: "0.1.53",
     deprecatedBelow: "0.1.53",
     commandMinimumSupported: [
@@ -2122,6 +2122,7 @@ async function* observeRunEvents(options) {
 var TERMINAL_PLAY_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
 var INCLUDE_TOOL_METADATA_HEADER = "x-deepline-include-tool-metadata";
 var EXECUTE_RESPONSE_CONTRACT_HEADER = "x-deepline-execute-response-contract";
+var EXECUTE_RESPONSE_INTENT_HEADER = "x-deepline-execute-response-intent";
 var V2_EXECUTE_RESPONSE_CONTRACT = "v2-tool-response";
 var COMPILE_MANIFEST_RETRY_DELAYS_MS = [250, 1e3];
 var REGISTER_PLAY_ARTIFACTS_COMPILE_CONCURRENCY = 3;
@@ -2606,7 +2607,8 @@ var DeeplineClient = class {
   async executeTool(toolId, input2, options) {
     const headers = {
       [EXECUTE_RESPONSE_CONTRACT_HEADER]: V2_EXECUTE_RESPONSE_CONTRACT,
-      ...options?.includeToolMetadata ? { [INCLUDE_TOOL_METADATA_HEADER]: "true" } : {}
+      ...options?.includeToolMetadata ? { [INCLUDE_TOOL_METADATA_HEADER]: "true" } : {},
+      ...options?.responseIntent ? { [EXECUTE_RESPONSE_INTENT_HEADER]: options.responseIntent } : {}
     };
     return this.http.post(
       `/api/v2/integrations/${encodeURIComponent(toolId)}/execute`,
@@ -10788,6 +10790,23 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
     },
     Math.max(1, input2.waitTimeoutMs)
   );
+  const fetchKnownTerminalStatus = async () => {
+    if (!lastKnownWorkflowId) {
+      return null;
+    }
+    let refreshed;
+    try {
+      refreshed = await input2.client.getPlayStatus(lastKnownWorkflowId, {
+        billing: false
+      });
+    } catch (error) {
+      if (isTransientPlayStreamError(error)) {
+        return null;
+      }
+      throw error;
+    }
+    return TERMINAL_PLAY_STATUSES2.has(refreshed.status) ? { ...refreshed, dashboardUrl } : null;
+  };
   try {
     for await (const event of input2.client.startPlayRunStream(input2.request, {
       signal: controller.signal
@@ -10883,6 +10902,21 @@ async function startAndWaitForPlayCompletionByStreamOnce(input2) {
     }
   } catch (error) {
     if (timedOut) {
+      const terminal = await fetchKnownTerminalStatus();
+      if (terminal) {
+        recordCliTrace({
+          phase: "cli.play_start_stream_timeout_status_reconcile",
+          ms: Date.now() - startedAt,
+          ok: true,
+          playName: input2.playName,
+          workflowId: lastKnownWorkflowId,
+          eventCount,
+          firstRunIdMs,
+          lastPhase,
+          status: terminal.status
+        });
+        return terminal;
+      }
       assertPlayWaitNotTimedOut({
         workflowId: lastKnownWorkflowId,
         startedAt,
@@ -20554,6 +20588,19 @@ function normalizeRows(value) {
     return { value: entry };
   });
 }
+function columnsForRows(rows) {
+  const seen = /* @__PURE__ */ new Set();
+  const columns = [];
+  for (const row of rows) {
+    for (const key of Object.keys(row)) {
+      if (!seen.has(key)) {
+        seen.add(key);
+        columns.push(key);
+      }
+    }
+  }
+  return columns;
+}
 function candidateRoots(payload) {
   const roots = [
     { path: null, value: payload }
@@ -20636,6 +20683,16 @@ function tryConvertToList(payload, options) {
   }
   return null;
 }
+function projectRowOutput(conversion) {
+  return {
+    rows: conversion.rows,
+    rowCount: conversion.rows.length,
+    columns: columnsForRows(conversion.rows),
+    previewRows: conversion.rows.slice(0, 5),
+    strategy: conversion.strategy,
+    sourcePath: conversion.sourcePath
+  };
+}
 function ensureOutputDir() {
   const outputDir = (0, import_node_path14.join)((0, import_node_os10.homedir)(), ".local", "share", "deepline", "data");
   (0, import_node_fs12.mkdirSync)(outputDir, { recursive: true });
@@ -20650,16 +20707,7 @@ function writeJsonOutputFile(payload, stem) {
 function writeCsvOutputFile(rows, stem, options) {
   const outputPath = options?.outPath ? options.outPath : (0, import_node_path14.join)(ensureOutputDir(), `${stem}_${Date.now()}.csv`);
   (0, import_node_fs12.mkdirSync)((0, import_node_path14.dirname)(outputPath), { recursive: true });
-  const seen = /* @__PURE__ */ new Set();
-  const columns = [];
-  for (const row of rows) {
-    for (const key of Object.keys(row)) {
-      if (!seen.has(key)) {
-        seen.add(key);
-        columns.push(key);
-      }
-    }
-  }
+  const columns = columnsForRows(rows);
   const escapeCell = (value) => {
     const normalized = value == null ? "" : typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? String(value) : JSON.stringify(value);
     if (/[",\n]/.test(normalized)) {
@@ -20667,13 +20715,20 @@ function writeCsvOutputFile(rows, stem, options) {
     }
     return normalized;
   };
-  const lines = [];
-  lines.push(columns.map(escapeCell).join(","));
-  for (const row of rows) {
-    lines.push(columns.map((column) => escapeCell(row[column])).join(","));
+  const fd = (0, import_node_fs12.openSync)(outputPath, "w");
+  try {
+    (0, import_node_fs12.writeSync)(fd, `${columns.map(escapeCell).join(",")}
+`);
+    for (const row of rows) {
+      (0, import_node_fs12.writeSync)(
+        fd,
+        `${columns.map((column) => escapeCell(row[column])).join(",")}
+`
+      );
+    }
+  } finally {
+    (0, import_node_fs12.closeSync)(fd);
   }
-  (0, import_node_fs12.writeFileSync)(outputPath, `${lines.join("\n")}
-`, "utf-8");
   const previewRows = rows.slice(0, 5);
   const previewColumns = columns.slice(0, 5);
   const preview = [
@@ -21200,10 +21255,7 @@ Examples:
   ).option(
     "--output-format <format>",
     "Output format: auto, csv, csv_file, json, or json_file"
-  ).option(
-    "-o, --out <path>",
-    "Write row-shaped tool output to this CSV path"
-  ).option(
+  ).option("-o, --out <path>", "Write row-shaped tool output to this CSV path").option(
     "--no-preview",
     "Only print the extracted output path when applicable"
   ).action(async (toolId, options) => {
@@ -22057,6 +22109,100 @@ function buildToolExecuteBaseEnvelope(input2) {
     }
   };
 }
+function buildToolExecuteRowArtifactEnvelope(input2) {
+  const {
+    toolResponse: _toolResponse,
+    result: _result,
+    output: _output,
+    output_preview: _outputPreview,
+    render: _render,
+    next: _next,
+    local: _local,
+    ...base
+  } = input2.baseEnvelope;
+  void _toolResponse;
+  void _result;
+  void _output;
+  void _outputPreview;
+  void _render;
+  void _next;
+  void _local;
+  return {
+    ...base,
+    status: typeof base.status === "string" ? base.status : "completed",
+    output_preview: {
+      kind: "list",
+      rowCount: input2.rowOutput.rowCount,
+      columns: input2.rowOutput.columns,
+      preview: input2.rowOutput.previewRows,
+      listStrategy: input2.rowOutput.strategy,
+      listSourcePath: input2.rowOutput.sourcePath
+    },
+    csv_path: input2.csv.path,
+    row_count: input2.csv.rowCount,
+    row_count_returned: input2.csv.rowCount,
+    columns: input2.csv.columns,
+    extracted_csv: input2.csv.path,
+    extracted_csv_rows: input2.csv.rowCount,
+    extracted_csv_columns: input2.csv.columns,
+    preview: input2.csv.preview,
+    list_strategy: input2.rowOutput.strategy,
+    list_source_path: input2.rowOutput.sourcePath,
+    summary: input2.summary,
+    local: {
+      extracted_csv: input2.csv.path,
+      extracted_csv_rows: input2.csv.rowCount,
+      extracted_csv_columns: input2.csv.columns,
+      preview: input2.csv.preview,
+      starter_script: input2.seededScript.path,
+      project_dir: input2.seededScript.projectDir,
+      copy_to_project: {
+        macos_linux: input2.seededScript.macCopyCommand,
+        windows_powershell: input2.seededScript.windowsCopyCommand
+      }
+    },
+    starter_script: input2.seededScript.path,
+    project_dir: input2.seededScript.projectDir,
+    copy_to_project: {
+      macos_linux: input2.seededScript.macCopyCommand,
+      windows_powershell: input2.seededScript.windowsCopyCommand
+    },
+    next: {
+      inspect: "Re-run with --json only when you need the raw provider/tool response.",
+      listSourcePath: input2.rowOutput.sourcePath,
+      expandToPlay: "Use stable map and step keys so reruns are idempotent: completed rows are reused, and only missing or stale work runs again."
+    },
+    render: {
+      sections: [
+        {
+          title: `${input2.csv.path} (${input2.csv.rowCount} rows)`,
+          lines: [
+            ...input2.csv.columns.length > 0 ? [`columns: ${JSON.stringify(input2.csv.columns)}`] : [],
+            ...Object.keys(input2.summary).length > 0 ? [
+              `summary: ${Object.entries(input2.summary).map(([key, value]) => `${key}=${String(value)}`).join(", ")}`
+            ] : [],
+            `preview: ${JSON.stringify(input2.rowOutput.previewRows)}`,
+            `starter script: ${input2.seededScript.path}`
+          ]
+        }
+      ],
+      actions: [
+        {
+          label: "next",
+          command: "Move the script into a project folder and expand it into a Deepline play. Use stable map and step keys so reruns are idempotent: completed rows are reused, and only missing or stale work runs again."
+        },
+        {
+          label: "macOS/Linux",
+          command: input2.seededScript.macCopyCommand
+        },
+        {
+          label: "Windows PowerShell",
+          command: input2.seededScript.windowsCopyCommand
+        }
+      ]
+    }
+  };
+}
 async function executeTool(args) {
   let parsed;
   try {
@@ -22108,7 +22254,9 @@ async function executeTool(args) {
     }
     return 2;
   }
-  const rawResponse = await client2.executeTool(parsed.toolId, parsed.params);
+  const rawResponse = await client2.executeTool(parsed.toolId, parsed.params, {
+    responseIntent: parsed.outPath || parsed.outputFormat === "csv" || parsed.outputFormat === "csv_file" ? "row_artifact" : "raw"
+  });
   const listConversion = tryConvertToList(rawResponse, {
     listExtractorPaths: listExtractorPathsFromUsageGuidance(metadata)
   });
@@ -22172,6 +22320,7 @@ async function executeTool(args) {
     printCommandEnvelope(baseEnvelope, { json: false });
     return 0;
   }
+  const rowOutput = projectRowOutput(listConversion);
   const csv = writeCsvOutputFile(
     listConversion.rows,
     `${parsed.toolId}_output`,
@@ -22182,91 +22331,23 @@ async function executeTool(args) {
     payload: parsed.params,
     rows: listConversion.rows
   });
-  const materializedEnvelope = {
-    ...baseEnvelope,
-    local: {
-      extracted_csv: csv.path,
-      extracted_csv_rows: csv.rowCount,
-      extracted_csv_columns: csv.columns,
-      preview: csv.preview,
-      starter_script: seededScript.path,
-      project_dir: seededScript.projectDir,
-      copy_to_project: {
-        macos_linux: seededScript.macCopyCommand,
-        windows_powershell: seededScript.windowsCopyCommand
-      }
-    },
-    render: {
-      sections: [
-        {
-          title: `${csv.path} (${csv.rowCount} rows)`,
-          lines: [
-            ...csv.columns.length > 0 ? [`columns: ${JSON.stringify(csv.columns)}`] : [],
-            ...Object.keys(summary).length > 0 ? [
-              `summary: ${Object.entries(summary).map(([key, value]) => `${key}=${String(value)}`).join(", ")}`
-            ] : [],
-            `preview: ${JSON.stringify(csv.preview)}`,
-            `starter script: ${seededScript.path}`
-          ]
-        }
-      ],
-      actions: [
-        {
-          label: "next",
-          command: "Move the script into a project folder and expand it into a Deepline play. Use stable map and step keys so reruns are idempotent: completed rows are reused, and only missing or stale work runs again."
-        },
-        {
-          label: "macOS/Linux",
-          command: seededScript.macCopyCommand
-        },
-        {
-          label: "Windows PowerShell",
-          command: seededScript.windowsCopyCommand
-        }
-      ]
-    }
-  };
+  const materializedEnvelope = buildToolExecuteRowArtifactEnvelope({
+    baseEnvelope,
+    csv,
+    rowOutput,
+    summary,
+    seededScript
+  });
   if (parsed.outputFormat === "csv_file") {
-    printCommandEnvelope(
-      {
-        ...materializedEnvelope,
-        extracted_csv: csv.path,
-        extracted_csv_rows: csv.rowCount,
-        extracted_csv_columns: csv.columns,
-        preview: csv.preview,
-        list_strategy: listConversion.strategy,
-        list_source_path: listConversion.sourcePath,
-        starter_script: seededScript.path,
-        project_dir: seededScript.projectDir,
-        copy_to_project: {
-          macos_linux: seededScript.macCopyCommand,
-          windows_powershell: seededScript.windowsCopyCommand
-        },
-        summary
-      },
-      { json: true }
-    );
+    printCommandEnvelope(materializedEnvelope, { json: true });
     return 0;
   }
   if (parsed.outPath) {
-    printCommandEnvelope(
-      {
-        ...materializedEnvelope,
-        csv_path: csv.path,
-        row_count: csv.rowCount,
-        row_count_returned: csv.rowCount,
-        columns: csv.columns,
-        preview: csv.preview,
-        list_strategy: listConversion.strategy,
-        list_source_path: listConversion.sourcePath,
-        summary
-      },
-      {
-        json: argsWantJson(args) || shouldEmitJson(),
-        text: `Wrote ${csv.rowCount} row(s) to ${csv.path}
+    printCommandEnvelope(materializedEnvelope, {
+      json: argsWantJson(args) || shouldEmitJson(),
+      text: `Wrote ${csv.rowCount} row(s) to ${csv.path}
 `
-      }
-    );
+    });
     return 0;
   }
   if (parsed.noPreview) {