deepline 0.3.294 → 0.3.296

package/dist/cli/chunk-LIKFCE7Z.js

@@ -0,0 +1,190 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkOG64RBACjs = require('./chunk-OG64RBAC.js');
+
+// src/release.ts
+var SDK_RELEASE = {
+  // 0.1.94 is claimed by PR #1527 — this watch-render fix ships as 0.1.95.
+  // 0.1.98 ships the duplicate-browser-tab fix (default-browser detection).
+  // 0.1.99 ships prebuilt job-change source-column preservation and validation fixes.
+  // 0.1.101 ships retryable play artifact publish failures and CI retry hardening.
+  // 0.1.102 ships the job-change ledger fixes: recovered-dataset export on
+  // failed runs, persisted/succeeded/failed row counts, strict local CSV
+  // preflight (existence, data rows, quotes, duplicate headers), HTML error
+  // scrubbing, and word-boundary watch truncation.
+  // 0.1.103 ships the refined SDK CLI command surface.
+  // 0.1.104 shipped the retired Postgres scheduler suspension/billing parity and runtime worker hardening.
+  // 0.1.105 ships the billing catalog surface: billing plans, subscribe,
+  // subscription status/cancel, invoices, and the client.billing namespace.
+  // 0.1.106 ships play cell provenance metadata and v2 preview retry hardening.
+  // 0.1.107 ships the v2 quickstart command, the deepline-plays-quickstart
+  // skill on the sdk sync surface, and the people-search-to-email prebuilt.
+  // 0.1.108 ships explicit dataset column/tool recompute policy and removes
+  // 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.
+  // 0.1.154 removes the short-lived generated enrich StepOptions recompute
+  // fields shipped in 0.1.153.
+  // 0.1.175 ships loud `deepline enrich` empty-waterfall reporting.
+  // 0.1.230 propagates enrich extractor failures as failed rows rather than
+  // silently materializing them as unmatched results.
+  // 0.1.220 deprecates SDK CLI versions below 0.1.219 and updates them
+  // automatically without blocking their current command.
+  // 0.1.241 hard-cuts published and launched plays to immutable cjs_node20
+  // artifacts. Older clients can submit esm_workers artifacts that the Absurd
+  // runtime intentionally no longer compiles at publish or launch time.
+  // 0.1.242 removes the retired Workers/ESM compiler, generated bundles, and
+  // deploy-time artifact migration. Play authoring now has one CJS contract.
+  // 0.1.252 hard-cuts the customer Monitor catalog to the two launched
+  // Deepline-native radars. Older clients must update before discovering,
+  // checking, or deploying an unlaunched monitor integration.
+  // 0.1.253 makes play-page browser opening opt-in and retires --no-open.
+  // 0.1.254 removes the internal operations tree from the published SDK CLI.
+  // Operators use the checkout-local deepline-admin binary instead.
+  // 0.2.0 makes Dataset Handles uniformly async-only after 0.1.320 briefly
+  // exposed storage-dependent synchronous access. This deliberate minor
+  // release keeps lazy paging semantics independent of row residency.
+  // 0.3.0 introduces raw-v2: complete scrubbed provider responses are
+  // available at toolResponse.rawV2 while toolResponse.raw and all declared
+  // 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.296",
+  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: {
+    updatePreferences: 1
+  },
+  contracts: {
+    api: {
+      name: "sdk-http-api",
+      // Concise Play grep has the current wire id. Older ids follow the
+      // standard API support window.
+      currentMajor: 3,
+      supportedMajors: [3, 2],
+      // Older ids remain subject to the API support window.
+      legacyWireIds: [
+        "2026-09-play-grep-concise-results",
+        "2026-07-admin-cli-local-cutover",
+        "2026-07-native-monitor-launch-hard-cutover"
+      ]
+    },
+    playArtifact: {
+      name: "play-artifact-runtime",
+      currentVersion: _chunkOG64RBACjs.CURRENT_PLAY_ARTIFACT_CONTRACT_VERSION,
+      supportedVersions: [1, _chunkOG64RBACjs.CURRENT_PLAY_ARTIFACT_CONTRACT_VERSION]
+    },
+    release: {
+      name: "production-sdk-release",
+      publishFrom: "latest-successful-production-deployment",
+      coalesce: "latest-healthy"
+    }
+  },
+  supportPolicy: {
+    minimumSupported: "0.1.53",
+    deprecatedBelow: "0.3.1",
+    commandIntroducedIn: [
+      {
+        command: "search",
+        introducedIn: "0.3.91",
+        reason: "deepline search was added in SDK CLI 0.3.91 as the one search across tools, monitors, and plays. On an older version run deepline tools search or deepline plays search, or update."
+      },
+      {
+        command: "notifications",
+        introducedIn: "0.2.40",
+        reason: "deepline notifications was added in SDK CLI 0.2.40. Older versions have no way to configure a Play failure alert, so a cron Play that dies reports to nobody."
+      }
+    ],
+    commandMinimumSupported: [
+      {
+        command: "enrich",
+        // Compatibility window through 2026-08-22 (owner: Chirag): versions
+        // 0.1.238-0.1.252 differ only in local browser-opening behavior and
+        // already contain the enrich data-correctness fixes below.
+        minimumSupported: "0.1.238",
+        reason: 'Older SDK CLI enrich generated stale play source; SDK CLI enrich 0.1.153 generated removed StepOptions fields in play source; SDK CLI enrich before 0.1.175 could silently succeed on the empty-waterfall bug when a requested waterfall returned no values for selected rows; SDK CLI enrich before 0.1.230 could convert extractor failures into successful unmatched results; SDK CLI enrich before 0.1.238 could drop a nested provider email match during generic pick("email") extraction and materialize it as NO_MATCH.'
+      },
+      {
+        command: "plays",
+        minimumSupported: "0.1.241",
+        reason: "Older SDK CLI versions predate dataset-native Play results and can emit the retired esm_workers artifact contract. Update before checking, publishing, or running plays."
+      },
+      {
+        command: "plays run",
+        minimumSupported: "0.1.253",
+        reason: "Older SDK CLI versions predate dataset-native Play results and can emit the retired esm_workers artifact contract; versions before 0.1.253 open the play page by default and accept the removed --no-open flag."
+      },
+      {
+        command: "run",
+        displayCommand: "plays run",
+        minimumSupported: "0.1.253",
+        reason: "Older SDK CLI versions predate dataset-native Play results and can emit the retired esm_workers artifact contract; versions before 0.1.253 open the play page by default and accept the removed --no-open flag."
+      },
+      {
+        command: "plays check",
+        minimumSupported: "0.1.241",
+        reason: "Older SDK CLI versions predate dataset-native Play authoring and validate against the retired esm_workers artifact contract."
+      },
+      {
+        command: "check",
+        displayCommand: "plays check",
+        minimumSupported: "0.1.241",
+        reason: "Older SDK CLI versions predate dataset-native Play authoring and validate against the retired esm_workers artifact contract."
+      },
+      {
+        command: "plays publish",
+        minimumSupported: "0.1.241",
+        reason: "Older SDK CLI versions predate dataset-native Play artifacts and can publish the retired esm_workers artifact contract."
+      },
+      {
+        command: "publish",
+        displayCommand: "plays publish",
+        minimumSupported: "0.1.241",
+        reason: "Older SDK CLI versions predate dataset-native Play artifacts and can publish the retired esm_workers artifact contract."
+      },
+      {
+        command: "plays set-live",
+        minimumSupported: "0.1.241",
+        reason: "Older SDK CLI versions predate dataset-native Play artifacts and can publish the retired esm_workers artifact contract."
+      },
+      {
+        command: "set-live",
+        displayCommand: "plays set-live",
+        minimumSupported: "0.1.241",
+        reason: "Older SDK CLI versions predate dataset-native Play artifacts and can publish the retired esm_workers artifact contract."
+      },
+      {
+        command: "runs",
+        minimumSupported: "0.1.111",
+        reason: "Run result rows now render as dataset handles with explicit export commands."
+      },
+      {
+        command: "runs get",
+        minimumSupported: "0.1.111",
+        reason: "Run result rows now render as dataset handles with explicit export commands."
+      },
+      {
+        command: "get",
+        displayCommand: "runs get",
+        minimumSupported: "0.1.111",
+        reason: "Run result rows now render as dataset handles with explicit export commands."
+      },
+      {
+        command: "runs export",
+        minimumSupported: "0.1.111",
+        reason: "Run result row datasets now use the dataset-handle export contract."
+      },
+      {
+        command: "export",
+        displayCommand: "runs export",
+        minimumSupported: "0.1.111",
+        reason: "Run result row datasets now use the dataset-handle export contract."
+      }
+    ],
+    directToolsCompatibilityVersions: ["0.1.171"],
+    autoUpdatePatchLag: 2
+  }
+};
+
+
+
+exports.SDK_RELEASE = SDK_RELEASE;

package/dist/cli/chunk-MIMASXO4.mjs

@@ -0,0 +1,389 @@
+// src/tool-output.ts
+import {
+  closeSync,
+  mkdirSync,
+  openSync,
+  writeFileSync,
+  writeSync
+} from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function getByDottedPath(root, dottedPath) {
+  let current = root;
+  for (const segment of String(dottedPath || "").split(".").filter(Boolean)) {
+    if (!isPlainObject(current) || !(segment in current)) {
+      return null;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function normalizeRows(value) {
+  if (!Array.isArray(value)) return null;
+  return value.map((entry) => {
+    if (isPlainObject(entry)) return entry;
+    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 }
+  ];
+  if (isPlainObject(payload) && isPlainObject(payload.toolResponse)) {
+    roots.push({ path: "toolResponse", value: payload.toolResponse });
+    if (Object.prototype.hasOwnProperty.call(payload.toolResponse, "raw")) {
+      roots.push({
+        path: "toolResponse.raw",
+        value: payload.toolResponse.raw
+      });
+    }
+  }
+  if (isPlainObject(payload) && isPlainObject(payload.output)) {
+    roots.push({ path: "output", value: payload.output });
+    if (Object.prototype.hasOwnProperty.call(payload.output, "body")) {
+      roots.push({ path: "output.body", value: payload.output.body });
+    }
+  }
+  if (isPlainObject(payload) && isPlainObject(payload.result)) {
+    roots.push({ path: "result", value: payload.result });
+    if (isPlainObject(payload.result.data)) {
+      roots.push({ path: "result.data", value: payload.result.data });
+    }
+  }
+  return roots;
+}
+function findBestArrayCandidate(value, pathPrefix = "", depth = 0) {
+  if (depth > 5) return null;
+  const directRows = normalizeRows(value);
+  const hasObjectRow = directRows?.some(
+    (row) => Object.keys(row).some((key) => key !== "value")
+  ) ?? false;
+  let best = directRows && directRows.length > 0 && hasObjectRow ? { path: pathPrefix, rows: directRows } : null;
+  if (!isPlainObject(value)) {
+    return best;
+  }
+  for (const [key, child] of Object.entries(value)) {
+    const childPath = pathPrefix ? `${pathPrefix}.${key}` : key;
+    const candidate = findBestArrayCandidate(child, childPath, depth + 1);
+    if (!candidate) continue;
+    if (!best || candidate.rows.length > best.rows.length) {
+      best = candidate;
+    }
+  }
+  return best;
+}
+function tryConvertToList(payload, options) {
+  const listExtractorPaths = Array.isArray(options?.listExtractorPaths) ? options?.listExtractorPaths.filter(
+    (entry) => typeof entry === "string" && entry.trim().length > 0
+  ) : [];
+  if (listExtractorPaths.length > 0) {
+    let emptyMatch = null;
+    for (const root of candidateRoots(payload)) {
+      for (const extractorPath of listExtractorPaths) {
+        const resolved = getByDottedPath(root.value, extractorPath);
+        const rows = normalizeRows(resolved);
+        if (!rows) {
+          continue;
+        }
+        const sourcePath = root.path ? `${root.path}.${extractorPath}` : extractorPath;
+        if (rows.length > 0) {
+          return { rows, strategy: "configured_paths", sourcePath };
+        }
+        emptyMatch ??= { rows, strategy: "configured_paths", sourcePath };
+      }
+    }
+    if (emptyMatch) {
+      return emptyMatch;
+    }
+  }
+  for (const root of candidateRoots(payload)) {
+    const candidate = findBestArrayCandidate(root.value, root.path ?? "");
+    if (!candidate || candidate.rows.length === 0) continue;
+    return {
+      rows: candidate.rows,
+      strategy: "auto_detected",
+      sourcePath: candidate.path || root.path
+    };
+  }
+  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 = join(homedir(), ".local", "share", "deepline", "data");
+  mkdirSync(outputDir, { recursive: true });
+  return outputDir;
+}
+function writeJsonOutputFile(payload, stem) {
+  const outputDir = ensureOutputDir();
+  const outputPath = join(outputDir, `${stem}_${Date.now()}.json`);
+  writeFileSync(outputPath, JSON.stringify(payload, null, 2), "utf-8");
+  return outputPath;
+}
+function writeCsvOutputFile(rows, stem, options) {
+  const outputPath = options?.outPath ? options.outPath : join(ensureOutputDir(), `${stem}_${Date.now()}.csv`);
+  mkdirSync(dirname(outputPath), { recursive: true });
+  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)) {
+      return `"${normalized.replace(/"/g, '""')}"`;
+    }
+    return normalized;
+  };
+  const fd = openSync(outputPath, "w");
+  try {
+    writeSync(fd, `${columns.map(escapeCell).join(",")}
+`);
+    for (const row of rows) {
+      writeSync(
+        fd,
+        `${columns.map((column) => escapeCell(row[column])).join(",")}
+`
+      );
+    }
+  } finally {
+    closeSync(fd);
+  }
+  const previewRows = rows.slice(0, 5);
+  const previewColumns = columns.slice(0, 5);
+  const preview = [
+    previewColumns.join(","),
+    ...previewRows.map(
+      (row) => previewColumns.map((column) => escapeCell(row[column])).join(",")
+    )
+  ].join("\n");
+  return {
+    path: outputPath,
+    rowCount: rows.length,
+    columns,
+    preview
+  };
+}
+function extractSummaryFields(payload) {
+  const candidates = candidateRoots(payload);
+  for (const candidate of candidates) {
+    if (!isPlainObject(candidate.value)) continue;
+    const summaryEntries = Object.entries(candidate.value).filter(
+      ([, value]) => {
+        return value == null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+      }
+    );
+    if (summaryEntries.length === 0) continue;
+    return Object.fromEntries(summaryEntries);
+  }
+  return {};
+}
+
+// ../plays/row-identity.ts
+var POSTGRES_IDENTIFIER_MAX_LENGTH = 63;
+var MAP_KEY_NAMESPACE_MAX_LENGTH = POSTGRES_IDENTIFIER_MAX_LENGTH;
+var SHA256_INITIAL_HASH = [
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+];
+var SHA256_ROUND_CONSTANTS = [
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+];
+function stableValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => stableValue(entry));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, entry]) => entry !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, stableValue(entry)])
+    );
+  }
+  return value;
+}
+function stableStringify(value) {
+  return JSON.stringify(stableValue(value));
+}
+function rightRotate32(value, bits) {
+  return value >>> bits | value << 32 - bits;
+}
+function sha256Hex(input) {
+  const bytes = Array.from(new TextEncoder().encode(input));
+  const bitLength = bytes.length * 8;
+  bytes.push(128);
+  while (bytes.length % 64 !== 56) {
+    bytes.push(0);
+  }
+  const highBits = Math.floor(bitLength / 4294967296);
+  const lowBits = bitLength >>> 0;
+  bytes.push(
+    highBits >>> 24 & 255,
+    highBits >>> 16 & 255,
+    highBits >>> 8 & 255,
+    highBits & 255,
+    lowBits >>> 24 & 255,
+    lowBits >>> 16 & 255,
+    lowBits >>> 8 & 255,
+    lowBits & 255
+  );
+  const hash = [...SHA256_INITIAL_HASH];
+  const words = new Array(64).fill(0);
+  for (let offset = 0; offset < bytes.length; offset += 64) {
+    for (let index = 0; index < 16; index += 1) {
+      const wordOffset = offset + index * 4;
+      words[index] = (bytes[wordOffset] ?? 0) << 24 | (bytes[wordOffset + 1] ?? 0) << 16 | (bytes[wordOffset + 2] ?? 0) << 8 | (bytes[wordOffset + 3] ?? 0);
+    }
+    for (let index = 16; index < 64; index += 1) {
+      const s0 = rightRotate32(words[index - 15], 7) ^ rightRotate32(words[index - 15], 18) ^ words[index - 15] >>> 3;
+      const s1 = rightRotate32(words[index - 2], 17) ^ rightRotate32(words[index - 2], 19) ^ words[index - 2] >>> 10;
+      words[index] = words[index - 16] + s0 + words[index - 7] + s1 >>> 0;
+    }
+    let [a, b, c, d, e, f, g, h] = hash;
+    for (let index = 0; index < 64; index += 1) {
+      const s1 = rightRotate32(e, 6) ^ rightRotate32(e, 11) ^ rightRotate32(e, 25);
+      const ch = e & f ^ ~e & g;
+      const temp1 = h + s1 + ch + SHA256_ROUND_CONSTANTS[index] + words[index] >>> 0;
+      const s0 = rightRotate32(a, 2) ^ rightRotate32(a, 13) ^ rightRotate32(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = s0 + maj >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    hash[0] = hash[0] + a >>> 0;
+    hash[1] = hash[1] + b >>> 0;
+    hash[2] = hash[2] + c >>> 0;
+    hash[3] = hash[3] + d >>> 0;
+    hash[4] = hash[4] + e >>> 0;
+    hash[5] = hash[5] + f >>> 0;
+    hash[6] = hash[6] + g >>> 0;
+    hash[7] = hash[7] + h >>> 0;
+  }
+  return hash.map((word) => word.toString(16).padStart(8, "0")).join("");
+}
+function sanitizeIdentifierPart(value) {
+  return value.trim().replace(/[^a-z0-9]+/gi, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "").toLowerCase();
+}
+function validateIdentifierPart(rawValue, label, maxLength) {
+  const sanitized = sanitizeIdentifierPart(rawValue);
+  if (!sanitized) {
+    throw new Error(`${label} must contain a letter or number.`);
+  }
+  if (sanitized.length > maxLength) {
+    throw new Error(
+      `${label} is too long after normalization (${sanitized.length}/${maxLength}): "${sanitized}".`
+    );
+  }
+  return sanitized;
+}
+function normalizeTableNamespace(value) {
+  return validateIdentifierPart(
+    value,
+    "ctx.dataset() key",
+    MAP_KEY_NAMESPACE_MAX_LENGTH
+  );
+}
+
+export {
+  stableStringify,
+  sha256Hex,
+  normalizeTableNamespace,
+  tryConvertToList,
+  projectRowOutput,
+  writeJsonOutputFile,
+  writeCsvOutputFile,
+  extractSummaryFields
+};