deepline 0.3.294 → 0.3.295

package/dist/cli/chunk-CBVIJSHF.mjs

@@ -0,0 +1,560 @@
+import {
+  apiErrorCodeFromResponse,
+  apiErrorMessage
+} from "./chunk-DLIRSHV6.mjs";
+import {
+  DeeplineError
+} from "./chunk-NXGCO4JB.mjs";
+
+// ../play-runtime/run-lifecycle-policy.ts
+var TERMINAL_PLAY_RUN_STATUSES = /* @__PURE__ */ new Set([
+  "completed",
+  "failed",
+  "cancelled",
+  "terminated",
+  "timed_out"
+]);
+function normalizePlayRunLifecycleStatus(value) {
+  const normalized = String(value ?? "").trim().toLowerCase();
+  switch (normalized) {
+    case "queued":
+    case "pending":
+      return "queued";
+    case "running":
+    case "started":
+      return "running";
+    case "waiting":
+      return "waiting";
+    case "completed":
+    case "complete":
+    case "succeeded":
+      return "completed";
+    case "failed":
+    case "error":
+      return "failed";
+    case "cancelled":
+    case "canceled":
+      return "cancelled";
+    case "terminated":
+      return "terminated";
+    case "timed_out":
+    case "timeout":
+      return "timed_out";
+    default:
+      return "unknown";
+  }
+}
+function isTerminalPlayRunLifecycleStatus(status) {
+  return TERMINAL_PLAY_RUN_STATUSES.has(
+    normalizePlayRunLifecycleStatus(status)
+  );
+}
+function decodePlayRunPublicStatus(value) {
+  const status = normalizePlayRunLifecycleStatus(value);
+  switch (status) {
+    case "queued":
+    case "running":
+    case "waiting":
+    case "completed":
+    case "failed":
+    case "cancelled":
+      return status;
+    case "terminated":
+    case "timed_out":
+      return "cancelled";
+    case "unknown":
+      return null;
+  }
+}
+
+// src/plays/run-request.ts
+var PLAY_RUN_START_PATH = "/api/v2/plays/run";
+var PLAY_RUN_START_STREAM_PATH = `${PLAY_RUN_START_PATH}?stream=true`;
+var PLAY_FILES_STAGE_PATH = "/api/v2/plays/files/stage";
+var PLAY_FILES_STAGE_MINT_PATH = `${PLAY_FILES_STAGE_PATH}/mint`;
+function buildPlayRunStartBody(request) {
+  return {
+    ...request.name ? { name: request.name } : {},
+    ...request.revisionId ? { revisionId: request.revisionId } : {},
+    ...request.artifactStorageKey ? { artifactStorageKey: request.artifactStorageKey } : {},
+    ...request.sourceCode ? { sourceCode: request.sourceCode } : {},
+    ...request.sourceFiles ? { sourceFiles: request.sourceFiles } : {},
+    ...request.description ? { description: request.description } : {},
+    ..."staticPipeline" in request ? { staticPipeline: request.staticPipeline } : {},
+    ...request.artifactHash ? { artifactHash: request.artifactHash } : {},
+    ...request.graphHash ? { graphHash: request.graphHash } : {},
+    ...request.runtimeArtifact ? { runtimeArtifact: request.runtimeArtifact } : {},
+    ...request.compilerManifest ? { compilerManifest: request.compilerManifest } : {},
+    ...request.inputFileUpload ? { inputFileUpload: request.inputFileUpload } : {},
+    ...request.packagedFileUploads?.length ? { packagedFileUploads: request.packagedFileUploads } : {},
+    ...request.input ? { input: request.input } : {},
+    ...request.inputFile ? { inputFile: request.inputFile } : {},
+    ...request.packagedFiles?.length ? { packagedFiles: request.packagedFiles } : {},
+    ...request.force ? { force: true } : {},
+    ...request.forceToolRefresh === true ? { forceToolRefresh: true } : {},
+    ...typeof request.maxConcurrentExternalCalls === "number" ? { maxConcurrentExternalCalls: request.maxConcurrentExternalCalls } : {},
+    ...typeof request.maxConcurrentRows === "number" ? { maxConcurrentRows: request.maxConcurrentRows } : {},
+    ...typeof request.waitForCompletionMs === "number" ? { waitForCompletionMs: request.waitForCompletionMs } : {},
+    // Profile selection is the API's job, not the caller's. The server
+    // defaults to absurd; callers normally omit this field.
+    ...request.profile ? { profile: request.profile } : {},
+    ...request.integrationMode ? { integrationMode: request.integrationMode } : {},
+    ...request.fixtureBehavior ? { fixtureBehavior: request.fixtureBehavior } : {},
+    ...request.runtime ? { runtime: request.runtime } : {},
+    ...request.testPolicyOverrides ? { testPolicyOverrides: request.testPolicyOverrides } : {}
+  };
+}
+async function startPlayRun(http, request, headers) {
+  const response = await http.post(
+    PLAY_RUN_START_PATH,
+    buildPlayRunStartBody(request),
+    headers,
+    { maxRetries: 0, exactUrlOnly: true }
+  );
+  return normalizePlayRunStart(response);
+}
+function isPlayRunPackage(value) {
+  return Boolean(
+    value && typeof value === "object" && !Array.isArray(value) && value.kind === "play_run" && value.run && typeof value.run?.id === "string"
+  );
+}
+function normalizePlayRunStart(raw) {
+  const runPackage = isPlayRunPackage(raw) ? raw : isPlayRunPackage(raw.package) ? raw.package : null;
+  if (!runPackage) {
+    const workflowId = typeof raw.workflowId === "string" && raw.workflowId ? raw.workflowId : typeof raw.runId === "string" ? raw.runId : "";
+    return {
+      ...raw,
+      workflowId
+    };
+  }
+  const status = typeof runPackage.run.status === "string" ? runPackage.run.status : "running";
+  return {
+    workflowId: runPackage.run.id,
+    name: runPackage.run.playName,
+    status,
+    ...runPackage.run.dashboardUrl ? { dashboardUrl: runPackage.run.dashboardUrl } : {},
+    ...isTerminalPlayRunLifecycleStatus(status) ? { finalStatus: runPackage } : {},
+    package: runPackage
+  };
+}
+function buildNamedPlayRunRequest(input) {
+  return {
+    name: input.name,
+    ...input.revisionId ? { revisionId: input.revisionId } : {},
+    ...Object.keys(input.runtimeInput).length > 0 ? { input: input.runtimeInput } : {},
+    ...input.stagedFileInputs.inputFile ? { inputFile: input.stagedFileInputs.inputFile } : {},
+    ...input.stagedFileInputs.packagedFiles.length ? { packagedFiles: input.stagedFileInputs.packagedFiles } : {},
+    ...input.extra
+  };
+}
+var CSV_DATA_INPUT_KEY = "csv";
+function schemaMetadata(schema, key) {
+  if (!schema || typeof schema !== "object" || Array.isArray(schema))
+    return null;
+  const value = schema[key];
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function stringMetadata(metadata, key) {
+  const value = metadata?.[key];
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function inputFieldFromCsvArg(csvArg) {
+  if (typeof csvArg !== "string") return null;
+  const match = /^\(?\s*input\.([A-Za-z_$][\w$]*)\s*\)?(?:\s*\?\?[\s\S]+)?$/.exec(
+    csvArg.trim()
+  );
+  return match?.[1] ?? null;
+}
+function fileInputBindingsFromPlaySchema(inputSchema) {
+  const csvInput = schemaMetadata(inputSchema, "csvInput");
+  if (!csvInput) return [];
+  return [
+    {
+      inputPath: stringMetadata(csvInput, "inputField") ?? CSV_DATA_INPUT_KEY
+    }
+  ];
+}
+function fileInputBindingsFromStaticPipeline(staticPipeline) {
+  if (!staticPipeline || typeof staticPipeline !== "object" || Array.isArray(staticPipeline)) {
+    return [];
+  }
+  const inputField = inputFieldFromCsvArg(
+    staticPipeline.csvArg
+  );
+  return inputField ? [{ inputPath: inputField }] : [];
+}
+function playRunFileInputBindings(play) {
+  return [
+    ...fileInputBindingsFromPlaySchema(play.inputSchema),
+    ...fileInputBindingsFromStaticPipeline(play.staticPipeline)
+  ];
+}
+function getDottedInputValue(input, path) {
+  const parts = path.split(".").map((part) => part.trim()).filter(Boolean);
+  let cursor = input;
+  for (const part of parts) {
+    if (!cursor || typeof cursor !== "object" || Array.isArray(cursor)) {
+      return void 0;
+    }
+    cursor = cursor[part];
+  }
+  return cursor;
+}
+function setDottedInputValue(input, path, value) {
+  const parts = path.split(".").map((part) => part.trim()).filter(Boolean);
+  if (parts.length === 0) {
+    throw new Error(`Invalid play input flag path: ${path}`);
+  }
+  let cursor = input;
+  for (const part of parts.slice(0, -1)) {
+    const existing = cursor[part];
+    if (existing !== void 0 && (!existing || typeof existing !== "object" || Array.isArray(existing))) {
+      throw new Error(
+        `Cannot set --${path}; input.${part} is already a non-object value.`
+      );
+    }
+    if (!existing) {
+      cursor[part] = {};
+    }
+    cursor = cursor[part];
+  }
+  cursor[parts[parts.length - 1]] = value;
+}
+var webStagedFileCodec = {
+  async sha256Hex(bytes) {
+    const digest = await globalThis.crypto.subtle.digest(
+      "SHA-256",
+      bytes
+    );
+    return Array.from(
+      new Uint8Array(digest),
+      (byte) => byte.toString(16).padStart(2, "0")
+    ).join("");
+  },
+  base64(bytes) {
+    let binary = "";
+    for (let offset = 0; offset < bytes.length; offset += 32768) {
+      binary += String.fromCharCode(...bytes.subarray(offset, offset + 32768));
+    }
+    return btoa(binary);
+  }
+};
+function stagedFileContentType(logicalPath) {
+  const lower = logicalPath.toLowerCase();
+  return lower.endsWith(".csv") ? "text/csv" : lower.endsWith(".json") ? "application/json" : "application/octet-stream";
+}
+async function createStagedFileUpload(logicalPath, bytes, codec = webStagedFileCodec) {
+  return {
+    logicalPath,
+    contentBase64: codec.base64(bytes),
+    contentHash: await codec.sha256Hex(bytes),
+    contentType: stagedFileContentType(logicalPath),
+    bytes: bytes.byteLength
+  };
+}
+var STAGE_LEGACY_MULTIPART_MAX_BYTES = 4e6;
+var STAGE_DIRECT_UPLOAD_MAX_ATTEMPTS = 3;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function stagedUploadIdentity(logicalPath, contentHash) {
+  return `${contentHash}:${logicalPath}`;
+}
+function isStagedUploadMintUnsupported(error) {
+  return error instanceof DeeplineError && error.statusCode === 404;
+}
+function isStagedUploadDirectEgressDenied(error) {
+  return error instanceof DeeplineError && error.code === "STAGED_FILE_UPLOAD_EGRESS_DENIED";
+}
+function formatMegabytes(bytes) {
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function decodeBase64Bytes(value) {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  return bytes;
+}
+async function uploadStagedFileToPresignedUrl(input) {
+  const arrayBuffer = input.body.buffer.slice(
+    input.body.byteOffset,
+    input.body.byteOffset + input.body.byteLength
+  );
+  let lastError;
+  for (let attempt = 1; attempt <= STAGE_DIRECT_UPLOAD_MAX_ATTEMPTS; attempt += 1) {
+    try {
+      const response = await fetch(input.url, {
+        method: "PUT",
+        headers: input.headers,
+        body: new Blob([arrayBuffer])
+      });
+      if (response.ok) {
+        return;
+      }
+      const text = await response.text().catch(() => "");
+      const egressDenied = response.status === 403 && response.headers.get("x-deny-reason")?.trim().toLowerCase() === "host_not_allowed";
+      lastError = new DeeplineError(
+        `Direct storage upload of ${input.logicalPath} failed: ${response.status} ${text.slice(0, 200)}`,
+        response.status,
+        egressDenied ? "STAGED_FILE_UPLOAD_EGRESS_DENIED" : "STAGED_FILE_UPLOAD_FAILED",
+        { logicalPath: input.logicalPath }
+      );
+      if (response.status < 500 && response.status !== 429) {
+        break;
+      }
+    } catch (error) {
+      lastError = error instanceof TypeError ? new DeeplineError(
+        `Direct storage upload of ${input.logicalPath} could not reach the storage endpoint: ${error.message}`,
+        void 0,
+        "STAGED_FILE_UPLOAD_EGRESS_DENIED",
+        { logicalPath: input.logicalPath }
+      ) : error;
+    }
+    if (attempt < STAGE_DIRECT_UPLOAD_MAX_ATTEMPTS) {
+      await sleep(250 * attempt);
+    }
+  }
+  throw lastError instanceof Error ? lastError : new DeeplineError(
+    `Direct storage upload of ${input.logicalPath} failed.`,
+    void 0,
+    "STAGED_FILE_UPLOAD_FAILED",
+    { logicalPath: input.logicalPath }
+  );
+}
+async function mintStagedPlayFileUploads(http, files) {
+  const response = await http.post(PLAY_FILES_STAGE_MINT_PATH, { files });
+  return response.uploads ?? [];
+}
+async function stagePlayFilesViaMultipart(http, files, reason = "mint-unsupported") {
+  for (const file of files) {
+    if (file.bytes > STAGE_LEGACY_MULTIPART_MAX_BYTES) {
+      const reasonMessage = reason === "direct-egress-denied" ? "direct storage is blocked by this environment's network egress policy" : "the connected Deepline server does not support direct-to-storage uploads";
+      throw new DeeplineError(
+        `Cannot stage ${file.logicalPath} (${formatMegabytes(file.bytes)}): ${reasonMessage}, and this file exceeds the ~4.5MB request-body limit the legacy upload path is subject to.`,
+        413,
+        "STAGED_FILE_TOO_LARGE_FOR_LEGACY_UPLOAD",
+        {
+          logicalPath: file.logicalPath,
+          bytes: file.bytes,
+          maxBytes: STAGE_LEGACY_MULTIPART_MAX_BYTES
+        }
+      );
+    }
+  }
+  const buildFormData = () => {
+    const formData = new FormData();
+    formData.set(
+      "metadata",
+      JSON.stringify({
+        files: files.map((file, index) => ({
+          index,
+          logicalPath: file.logicalPath,
+          contentHash: file.contentHash,
+          contentType: file.contentType,
+          bytes: file.bytes
+        }))
+      })
+    );
+    for (const [index, file] of files.entries()) {
+      const bytes = decodeBase64Bytes(file.contentBase64);
+      const body = bytes.buffer.slice(
+        bytes.byteOffset,
+        bytes.byteOffset + bytes.byteLength
+      );
+      formData.set(
+        `file:${index}`,
+        new Blob([body], { type: file.contentType }),
+        file.logicalPath
+      );
+    }
+    return formData;
+  };
+  const response = await http.postFormData(PLAY_FILES_STAGE_PATH, buildFormData);
+  return response.files;
+}
+async function stagePlayFiles(http, files) {
+  let uploads;
+  try {
+    uploads = await mintStagedPlayFileUploads(
+      http,
+      files.map((file) => ({
+        logicalPath: file.logicalPath,
+        contentHash: file.contentHash,
+        contentType: file.contentType,
+        bytes: file.bytes
+      }))
+    );
+  } catch (error) {
+    if (isStagedUploadMintUnsupported(error)) {
+      return stagePlayFilesViaMultipart(http, files);
+    }
+    throw error;
+  }
+  const uploadByIdentity = /* @__PURE__ */ new Map();
+  for (const upload of uploads) {
+    uploadByIdentity.set(
+      stagedUploadIdentity(upload.logicalPath, upload.contentHash),
+      upload
+    );
+  }
+  const directResults = await Promise.all(
+    files.map(async (file) => {
+      const upload = uploadByIdentity.get(
+        stagedUploadIdentity(file.logicalPath, file.contentHash)
+      );
+      if (!upload) {
+        throw new DeeplineError(
+          `The staging server did not return an upload target for ${file.logicalPath}.`,
+          void 0,
+          "STAGED_FILE_MINT_INCOMPLETE"
+        );
+      }
+      if (upload.alreadyStaged || !upload.uploadUrl) {
+        return { ref: upload.ref };
+      }
+      try {
+        await uploadStagedFileToPresignedUrl({
+          url: upload.uploadUrl,
+          headers: upload.uploadHeaders ?? {
+            "content-type": file.contentType
+          },
+          body: decodeBase64Bytes(file.contentBase64),
+          logicalPath: file.logicalPath
+        });
+        return { ref: upload.ref };
+      } catch (error) {
+        if (isStagedUploadDirectEgressDenied(error)) {
+          return { fallbackFile: file };
+        }
+        throw error;
+      }
+    })
+  );
+  return await Promise.all(
+    directResults.map(async (result) => {
+      if ("fallbackFile" in result) {
+        const [ref] = await stagePlayFilesViaMultipart(
+          http,
+          [result.fallbackFile],
+          "direct-egress-denied"
+        );
+        if (!ref) {
+          throw new DeeplineError(
+            `The staging server did not return an upload target for ${result.fallbackFile.logicalPath}.`,
+            void 0,
+            "STAGED_FILE_MINT_INCOMPLETE"
+          );
+        }
+        return ref;
+      }
+      return result.ref;
+    })
+  );
+}
+async function stageFileInputs(input) {
+  const uniqueBindings = [
+    ...new Map(
+      input.bindings.map((binding) => [binding.inputPath, binding])
+    ).values()
+  ];
+  const localFiles = uniqueBindings.flatMap((binding) => {
+    const file = input.resolveLocalFile(
+      getDottedInputValue(input.runtimeInput, binding.inputPath),
+      binding
+    );
+    return file ? [{ binding, file }] : [];
+  });
+  if (localFiles.length === 0) {
+    return { inputFile: null, packagedFiles: [] };
+  }
+  input.onStaging?.(localFiles.length);
+  const uploads = await Promise.all(
+    localFiles.map(
+      async ({ file }) => createStagedFileUpload(file.logicalPath, await file.read(), input.codec)
+    )
+  );
+  const staged = await input.stage(uploads);
+  for (const [index, { binding, file }] of localFiles.entries()) {
+    setDottedInputValue(
+      input.runtimeInput,
+      binding.inputPath,
+      file.logicalPath
+    );
+    const stagedFile = staged[index];
+    if (stagedFile && stagedFile.logicalPath !== file.logicalPath) {
+      setDottedInputValue(
+        input.runtimeInput,
+        binding.inputPath,
+        stagedFile.logicalPath
+      );
+    }
+  }
+  return {
+    inputFile: staged[0] ?? null,
+    packagedFiles: staged.slice(1)
+  };
+}
+function createSessionPlayRunHttp(fetchImpl = (...args) => fetch(...args)) {
+  const send = async (path, init) => {
+    const response = await fetchImpl(path, {
+      ...init,
+      credentials: "include"
+    });
+    const text = await response.text();
+    let parsed = text;
+    try {
+      parsed = text ? JSON.parse(text) : null;
+    } catch {
+    }
+    if (!response.ok) {
+      throw new DeeplineError(
+        apiErrorMessage(parsed, response.status),
+        response.status,
+        apiErrorCodeFromResponse(parsed),
+        { response: parsed }
+      );
+    }
+    return parsed;
+  };
+  return {
+    post: (path, body, headers) => send(path, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...headers },
+      body: JSON.stringify(body)
+    }),
+    postFormData: (path, formData) => send(path, {
+      method: "POST",
+      body: typeof formData === "function" ? formData() : formData
+    })
+  };
+}
+
+export {
+  isTerminalPlayRunLifecycleStatus,
+  decodePlayRunPublicStatus,
+  PLAY_RUN_START_PATH,
+  PLAY_RUN_START_STREAM_PATH,
+  PLAY_FILES_STAGE_PATH,
+  PLAY_FILES_STAGE_MINT_PATH,
+  buildPlayRunStartBody,
+  startPlayRun,
+  isPlayRunPackage,
+  normalizePlayRunStart,
+  buildNamedPlayRunRequest,
+  CSV_DATA_INPUT_KEY,
+  fileInputBindingsFromPlaySchema,
+  fileInputBindingsFromStaticPipeline,
+  playRunFileInputBindings,
+  getDottedInputValue,
+  setDottedInputValue,
+  webStagedFileCodec,
+  stagedFileContentType,
+  createStagedFileUpload,
+  STAGE_LEGACY_MULTIPART_MAX_BYTES,
+  mintStagedPlayFileUploads,
+  stagePlayFiles,
+  stageFileInputs,
+  createSessionPlayRunHttp
+};