deepline 0.3.325 → 0.3.326

package/dist/bundling-sources/sdk/src/plays/local-play-execution.ts

@@ -0,0 +1,189 @@
+import type { DeeplineClient } from '../client.js';
+import type { BundledPlayFileSuccess } from './bundle-play-file.js';
+
+export type LocalPlayGraph = {
+  root: BundledPlayFileSuccess;
+  nodes: Map<string, BundledPlayFileSuccess>;
+};
+
+function importedNodes(graph: LocalPlayGraph): BundledPlayFileSuccess[] {
+  const visited = new Set<string>();
+  const visiting = new Set<string>();
+  const ordered: BundledPlayFileSuccess[] = [];
+  const names = new Map<string, string>();
+  const visit = (node: BundledPlayFileSuccess) => {
+    if (visiting.has(node.filePath))
+      throw new Error(`Recursive imported Play graph at ${node.filePath}.`);
+    if (visited.has(node.filePath)) return;
+    visiting.add(node.filePath);
+    for (const dependency of node.importedPlayDependencies) {
+      const child = graph.nodes.get(dependency.filePath);
+      if (!child)
+        throw new Error(
+          `Missing bundled Play dependency ${dependency.filePath}.`,
+        );
+      visit(child);
+    }
+    visiting.delete(node.filePath);
+    visited.add(node.filePath);
+    if (node === graph.root) return;
+    if (!node.playName)
+      throw new Error(
+        `Imported Play ${node.filePath} must export definePlay(...).`,
+      );
+    const existing = names.get(node.playName);
+    if (existing !== undefined && existing !== node.filePath)
+      throw new Error(
+        `Imported Play name ${node.playName} belongs to more than one source file.`,
+      );
+    names.set(node.playName, node.filePath);
+    ordered.push(node);
+  };
+  visit(graph.root);
+  return ordered;
+}
+
+/** Describe local execution without storing artifacts or starting cloud work. */
+export function planLocalPlayExecution(
+  graph: LocalPlayGraph,
+  input: { runIdFile?: string | null } = {},
+) {
+  const imports = importedNodes(graph).map((node) => ({
+    name: node.playName!,
+    artifactHash: node.artifact.artifactHash,
+    graphHash: node.artifact.graphHash,
+  }));
+  return {
+    command: 'plays run',
+    root: {
+      name: graph.root.playName,
+      artifactHash: graph.root.artifact.artifactHash,
+      publication: 'unpublished' as const,
+    },
+    importedPlays: imports.map((node) => ({
+      ...node,
+      publication: 'pinned' as const,
+    })),
+    effects: {
+      cloudMutations: imports.length
+        ? [
+            'store_imported_execution_artifacts',
+            'stage_files_if_present',
+            'register_unpublished_root_revision',
+            'start_run',
+          ]
+        : [
+            'stage_files_if_present',
+            'register_unpublished_root_revision',
+            'start_run',
+          ],
+      localWrites: input.runIdFile
+        ? ['bundle_cache', 'run_identity_file']
+        : ['bundle_cache'],
+      creditSpending: 'tool_calls_may_spend' as const,
+      recovery: 'inspect_or_resume_original_run_id' as const,
+    },
+  };
+}
+
+/** Store immutable imported execution content without changing draft or live revisions. */
+export async function pinLocalPlayImports(
+  client: Pick<DeeplineClient, 'registerPlayArtifact'>,
+  graph: LocalPlayGraph,
+): Promise<LocalPlayGraph> {
+  const imports = importedNodes(graph);
+  if (imports.length === 0) return graph;
+  // Validate the entire graph before the first storage request.
+  for (const node of [...imports, graph.root]) {
+    if (!node.compilerManifest)
+      throw new Error(`Missing compiler manifest for ${node.filePath}.`);
+  }
+  const nodes = new Map(graph.nodes);
+  const stored = new Map<
+    string,
+    NonNullable<
+      BundledPlayFileSuccess['artifact']['importedPlayArtifacts']
+    >[string]
+  >();
+  const withPins = (node: BundledPlayFileSuccess): BundledPlayFileSuccess => {
+    const closure = new Map<
+      string,
+      NonNullable<
+        BundledPlayFileSuccess['artifact']['importedPlayArtifacts']
+      >[string]
+    >();
+    for (const dependency of node.importedPlayDependencies) {
+      const child = nodes.get(dependency.filePath)!;
+      const pointer = stored.get(dependency.filePath);
+      if (!pointer)
+        throw new Error(`Imported Play ${dependency.filePath} was not stored.`);
+      for (const [name, pin] of Object.entries(
+        child.artifact.importedPlayArtifacts ?? {},
+      ))
+        closure.set(name, pin);
+      closure.set(child.playName!, pointer);
+    }
+    return {
+      ...node,
+      artifact: {
+        ...node.artifact,
+        ...(closure.size
+          ? { importedPlayArtifacts: Object.fromEntries(closure) }
+          : {}),
+      },
+    };
+  };
+  // Children are stored before parents so every pointer refers to immutable content.
+  for (const original of imports) {
+    const node = withPins(original);
+    const result = await client.registerPlayArtifact({
+      name: node.playName!,
+      sourceCode: node.sourceCode,
+      sourceFiles: node.sourceFiles,
+      description: node.playDescription ?? undefined,
+      artifact: node.artifact,
+      compilerManifest: node.compilerManifest!,
+      publish: false,
+      artifactOnly: true,
+    });
+    if (
+      typeof result.artifactStorageKey !== 'string' ||
+      !result.artifactStorageKey.trim()
+    )
+      throw new Error(
+        `No immutable artifact identity was returned for ${node.playName}.`,
+      );
+    stored.set(node.filePath, {
+      artifactStorageKey: result.artifactStorageKey,
+      artifactHash: node.artifact.artifactHash,
+      graphHash: node.artifact.graphHash,
+    });
+    nodes.set(node.filePath, node);
+  }
+  const root = withPins(graph.root);
+  nodes.set(root.filePath, root);
+  return { root, nodes };
+}
+
+/** Publish exactly the reviewed import graph; the root is submitted as an unpublished run. */
+export async function publishLocalPlayImports(
+  client: Pick<DeeplineClient, 'registerPlayArtifact'>,
+  graph: LocalPlayGraph,
+): Promise<void> {
+  const nodes = importedNodes(graph);
+  for (const node of nodes) {
+    if (!node.compilerManifest)
+      throw new Error(`Missing compiler manifest for ${node.filePath}.`);
+  }
+  for (const node of nodes) {
+    await client.registerPlayArtifact({
+      name: node.playName!,
+      sourceCode: node.sourceCode,
+      sourceFiles: node.sourceFiles,
+      description: node.playDescription ?? undefined,
+      artifact: node.artifact,
+      compilerManifest: node.compilerManifest!,
+      publish: true,
+    });
+  }
+}

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.325',
+  version: '0.3.326',
   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/sdk/src/tool-calls.ts

@@ -26,7 +26,7 @@ const EXECUTE_RESPONSE_INTENT_HEADER = 'x-deepline-execute-response-intent';
 const RAW_V2_EXECUTE_RESPONSE_CONTRACT = RAW_V2_TOOL_RESPONSE_CONTRACT;
 const DEFAULT_EXECUTION_RECOVERY_TIMEOUT_MS = 15 * 60 * 1_000;
 
-function validateExecutionIdempotencyKey(key: string): void {
+export function validateExecutionIdempotencyKey(key: string): void {
   if (
     typeof key !== 'string' ||
     key.length < 1 ||

package/dist/bundling-sources/shared_libs/play-runtime/tool-result.ts

@@ -614,13 +614,79 @@ function normalizeRelativePath(path: string): string {
     .replace(/^\./, '');
 }
 
+/**
+ * Keys that carry the dialable number inside a provider's phone object, in
+ * preference order (Apollo `sanitized_number`, Wiza/Lusha/Forager `number`,
+ * Enformion `phoneNumber`, Datagma `display_international`, ...).
+ */
+const PHONE_OBJECT_VALUE_KEYS = [
+  'sanitized_number',
+  'number',
+  'phone',
+  'phone_number',
+  'phoneNumber',
+  'display_international',
+  'displayInternational',
+  'international',
+  'value',
+  'raw_number',
+  'raw',
+  'sanitized',
+] as const;
+
+/** Shortest real national number; anything shorter is a flag or a mask. */
+const PHONE_TARGET_MIN_DIGITS = 7;
+
+/**
+ * The `phone` getter is typed as one string. Providers put the number inside
+ * objects (`{ number, type }`) and arrays, and put availability flags under
+ * the same keys (`mobile_phone: true`, `has_direct_phone: "Yes"`, masked
+ * `"120******"`). Resolve to the first dialable string, or null when the
+ * value carries no phone number at all.
+ */
+function phoneTargetValue(value: unknown): string | null {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return phoneTargetValue(String(value));
+  }
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    const digits = trimmed.replace(/\D/g, '').length;
+    return digits >= PHONE_TARGET_MIN_DIGITS ? trimmed : null;
+  }
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      const phone = phoneTargetValue(entry);
+      if (phone) return phone;
+    }
+    return null;
+  }
+  if (isRecord(value)) {
+    for (const key of PHONE_OBJECT_VALUE_KEYS) {
+      const phone = phoneTargetValue(value[key]);
+      if (phone) return phone;
+    }
+  }
+  return null;
+}
+
+/** The value a target accepts from a candidate, or undefined to keep looking. */
+function acceptedTargetValue(
+  target: string | undefined,
+  value: unknown,
+): unknown {
+  if (target === 'phone') return phoneTargetValue(value) ?? undefined;
+  return isMeaningfulValue(value) ? value : undefined;
+}
+
 function getFirstMeaningfulValueAtPath(
   root: unknown,
   path: string,
+  target?: string,
 ): ToolResultTargetMetadata | null {
   for (const entry of valuesAtSegments(root, parsePath(path))) {
-    if (isMeaningfulValue(entry.value)) {
-      return { value: entry.value, path: entry.path };
+    const value = acceptedTargetValue(target, entry.value);
+    if (value !== undefined) {
+      return { value, path: entry.path };
     }
   }
   return null;
@@ -663,10 +729,11 @@ function normalizeRows(value: unknown): Record<string, unknown>[] | null {
 function findFirstTargetByPath(
   result: unknown,
   paths: readonly string[] | undefined,
+  target?: string,
 ): ToolResultTargetMetadata | null {
   for (const path of paths ?? []) {
     for (const candidate of candidateResultPaths(path)) {
-      const match = getFirstMeaningfulValueAtPath(result, candidate);
+      const match = getFirstMeaningfulValueAtPath(result, candidate, target);
       if (match) return match;
     }
   }
@@ -756,11 +823,10 @@ function findFirstTargetByKey(
   };
   for (const [key, value] of Object.entries(result)) {
     if (rule.reject?.some((pattern) => pattern.test(key))) continue;
-    if (
-      rule.match.some((pattern) => pattern.test(key)) &&
-      isMeaningfulValue(value)
-    ) {
-      return { value, path: pathToString([...path, key]) };
+    if (!rule.match.some((pattern) => pattern.test(key))) continue;
+    const accepted = acceptedTargetValue(target, value);
+    if (accepted !== undefined) {
+      return { value: accepted, path: pathToString([...path, key]) };
     }
   }
   for (const [key, value] of Object.entries(result)) {
@@ -1038,7 +1104,11 @@ function buildTargets(
       targets[target] = emailStatusTarget;
       continue;
     }
-    const fromExtractor = findFirstTargetByPath(result, descriptor.paths);
+    const fromExtractor = findFirstTargetByPath(
+      result,
+      descriptor.paths,
+      target,
+    );
     if (!fromExtractor) {
       // A declared null is an explicit provider answer, not permission to
       // guess from a similarly named sibling such as `emailDomain`.
@@ -1065,7 +1135,11 @@ function buildTargets(
       target,
       targetGetters?.[target] ?? declaredTargetPaths.get(target) ?? [],
     );
-    const fromMetadata = findFirstTargetByPath(result, targetGetters?.[target]);
+    const fromMetadata = findFirstTargetByPath(
+      result,
+      targetGetters?.[target],
+      target,
+    );
     if (fromMetadata) {
       targets[target] = fromMetadata;
       continue;

package/dist/cli/auth-6STWK6UK.js

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

package/dist/cli/{auth-PIZESRPC.mjs → auth-VON5FFUK.mjs}

@@ -9,11 +9,11 @@ import {
   registerAuthCommands,
   reportSetupCompleted,
   resolvePendingAuthClaimForResume
-} from "./chunk-5FHU7TV4.mjs";
-import "./chunk-AQUNQJ5Y.mjs";
-import "./chunk-YE3O2UHM.mjs";
+} from "./chunk-ZRN6YOF2.mjs";
+import "./chunk-M7CPVMDB.mjs";
+import "./chunk-BR7GGTAE.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-NWBARG3F.mjs";
+import "./chunk-BQJVMKWL.mjs";
 import "./chunk-NXGCO4JB.mjs";
 import "./chunk-WZYKRD7T.mjs";
 import "./chunk-KRD6H754.mjs";

package/dist/cli/{billing-HSL6VTCM.mjs → billing-X6JUEFRE.mjs}

@@ -1,7 +1,7 @@
 import {
   DeeplineClient,
   iterateCursorPages
-} from "./chunk-XIVUB36F.mjs";
+} from "./chunk-KLWBAQ5A.mjs";
 import "./chunk-CBVIJSHF.mjs";
 import {
   createTimestampedName,
@@ -9,13 +9,13 @@ import {
   openInBrowser,
   printCommandEnvelope,
   shouldEmitJson
-} from "./chunk-AQUNQJ5Y.mjs";
+} from "./chunk-M7CPVMDB.mjs";
 import {
   AuthError,
   ConfigError
-} from "./chunk-YE3O2UHM.mjs";
+} from "./chunk-BR7GGTAE.mjs";
 import "./chunk-DLIRSHV6.mjs";
-import "./chunk-NWBARG3F.mjs";
+import "./chunk-BQJVMKWL.mjs";
 import "./chunk-6IKARAYD.mjs";
 import {
   DeeplineError