deepline 0.1.20 → 0.1.21

package/dist/cli/index.js

@@ -266,7 +266,7 @@ function saveProjectDeeplineEnvValues(baseUrl, values, startDir = projectEnvStar
 }
 
 // src/version.ts
-var SDK_VERSION = "0.1.20";
+var SDK_VERSION = "0.1.21";
 var SDK_API_CONTRACT = "2026-05-runs-v2";
 
 // ../shared_libs/play-runtime/coordinator-headers.ts
@@ -349,7 +349,7 @@ var HttpClient = class {
           const response = await fetch(candidateUrl, {
             method,
             headers,
-            body: options?.body !== void 0 ? JSON.stringify(options.body) : void 0,
+            body: options?.formData !== void 0 ? options.formData : options?.body !== void 0 ? JSON.stringify(options.body) : void 0,
             signal: controller.signal
           });
           clearTimeout(timeoutId);
@@ -468,6 +468,13 @@ var HttpClient = class {
       headers
     });
   }
+  async postFormData(path, formData, headers) {
+    return this.request(path, {
+      method: "POST",
+      formData,
+      headers
+    });
+  }
   /**
    * Send a DELETE request.
    *
@@ -576,6 +583,14 @@ function mapLegacyTemporalStatus(status) {
       return "running";
   }
 }
+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;
+}
 var DeeplineClient = class {
   http;
   config;
@@ -1027,9 +1042,34 @@ var DeeplineClient = class {
    * ```
    */
   async stagePlayFiles(files) {
-    const response = await this.http.post(
+    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
+      );
+    }
+    const response = await this.http.postFormData(
       "/api/v2/plays/files/stage",
-      { files }
+      formData
     );
     return response.files;
   }
@@ -1058,9 +1098,14 @@ var DeeplineClient = class {
    * console.log(`Logs: ${status.progress?.logs.length ?? 0} lines`);
    * ```
    */
-  async getPlayStatus(workflowId) {
+  async getPlayStatus(workflowId, options) {
+    const params = new URLSearchParams();
+    if (options?.billing === false) {
+      params.set("billing", "false");
+    }
+    const query = params.size > 0 ? `?${params.toString()}` : "";
     const response = await this.http.get(
-      `/api/v2/plays/run/${encodeURIComponent(workflowId)}`
+      `/api/v2/plays/run/${encodeURIComponent(workflowId)}${query}`
     );
     return normalizePlayStatus(response);
   }
@@ -4362,7 +4407,77 @@ function createCliProgress(enabled) {
   return progress;
 }
 
+// src/cli/trace.ts
+var cliTraceStartedAt = Date.now();
+function isTruthyEnv(value) {
+  return value === "1" || value === "true" || value === "yes";
+}
+function isCliTraceEnabled() {
+  return isTruthyEnv(process.env.DEEPLINE_CLI_TRACE);
+}
+function recordCliTrace(event) {
+  if (!isCliTraceEnabled()) {
+    return;
+  }
+  const now = Date.now();
+  const payload = {
+    ts: now,
+    source: "cli",
+    sinceStartMs: now - cliTraceStartedAt,
+    ...event
+  };
+  process.stderr.write(`[cli-trace] ${JSON.stringify(payload)}
+`);
+}
+async function traceCliSpan(phase, fields, run) {
+  if (!isCliTraceEnabled()) {
+    return run();
+  }
+  const startedAt = Date.now();
+  try {
+    const result = await run();
+    recordCliTrace({
+      phase,
+      ms: Date.now() - startedAt,
+      ok: true,
+      ...fields
+    });
+    return result;
+  } catch (error) {
+    recordCliTrace({
+      phase,
+      ms: Date.now() - startedAt,
+      ok: false,
+      error: error instanceof Error ? error.message : String(error),
+      ...fields
+    });
+    throw error;
+  }
+}
+
 // src/cli/commands/play.ts
+function traceCliSync(phase, fields, run) {
+  const startedAt = Date.now();
+  try {
+    const result = run();
+    recordCliTrace({
+      phase,
+      ms: Date.now() - startedAt,
+      ok: true,
+      ...fields
+    });
+    return result;
+  } catch (error) {
+    recordCliTrace({
+      phase,
+      ms: Date.now() - startedAt,
+      ok: false,
+      error: error instanceof Error ? error.message : String(error),
+      ...fields
+    });
+    throw error;
+  }
+}
 function parseReferencedPlayTarget(target) {
   const trimmed = target.trim();
   const slashIndex = trimmed.indexOf("/");
@@ -4601,6 +4716,23 @@ function isLocalFilePathValue(value) {
   if (/^[a-z][a-z0-9+.-]*:\/\//i.test(value.trim())) return false;
   return (0, import_node_fs6.existsSync)((0, import_node_path8.resolve)(value));
 }
+function inputContainsLocalFilePath(value) {
+  if (isLocalFilePathValue(value)) {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    return value.some((entry) => inputContainsLocalFilePath(entry));
+  }
+  if (value && typeof value === "object") {
+    return Object.values(value).some(
+      (entry) => inputContainsLocalFilePath(entry)
+    );
+  }
+  return false;
+}
+function namedRunNeedsPlayDefinition(input) {
+  return input.revisionSelector === "latest" || getDottedInputValue(input.runtimeInput, "csv") != null || inputContainsLocalFilePath(input.runtimeInput);
+}
 async function stageFileInputArgs(input) {
   const uniqueBindings = [
     ...new Map(input.bindings.map((binding) => [binding.inputPath, binding])).values()
@@ -4913,6 +5045,8 @@ async function startAndWaitForPlayCompletionByStream(input) {
   let timedOut = false;
   let emittedDashboardUrl = false;
   let lastKnownWorkflowId = "";
+  let eventCount = 0;
+  let firstRunIdMs = null;
   let lastPhase = null;
   const timeout = input.waitTimeoutMs === null ? null : setTimeout(
     () => {
@@ -4925,9 +5059,11 @@ async function startAndWaitForPlayCompletionByStream(input) {
     for await (const event of input.client.startPlayRunStream(input.request, {
       signal: controller.signal
     })) {
+      eventCount += 1;
       const eventRunId = getEventPayload(event).runId;
       if (typeof eventRunId === "string" && eventRunId && eventRunId !== "pending") {
         lastKnownWorkflowId = eventRunId;
+        firstRunIdMs ??= Date.now() - startedAt;
       }
       const workflowId = lastKnownWorkflowId || "pending";
       if (workflowId !== "pending" && !emittedDashboardUrl) {
@@ -4965,6 +5101,16 @@ async function startAndWaitForPlayCompletionByStream(input) {
       });
       const finalStatus = getFinalStatusFromLiveEvent(event);
       if (finalStatus) {
+        recordCliTrace({
+          phase: "cli.play_start_stream_terminal",
+          ms: Date.now() - startedAt,
+          ok: true,
+          playName: input.playName,
+          workflowId: finalStatus.runId || lastKnownWorkflowId || null,
+          eventCount,
+          firstRunIdMs,
+          lastPhase
+        });
         return finalStatus;
       }
     }
@@ -4988,6 +5134,17 @@ async function startAndWaitForPlayCompletionByStream(input) {
 `
         );
       }
+      recordCliTrace({
+        phase: "cli.play_start_stream_fallback",
+        ms: Date.now() - startedAt,
+        ok: false,
+        playName: input.playName,
+        workflowId: lastKnownWorkflowId,
+        eventCount,
+        firstRunIdMs,
+        lastPhase,
+        reason
+      });
       return waitForPlayCompletionByPolling({
         client: input.client,
         workflowId: lastKnownWorkflowId,
@@ -5012,6 +5169,17 @@ async function startAndWaitForPlayCompletionByStream(input) {
         `[play watch] start stream ended after run ${lastKnownWorkflowId}; falling back to polling`
       );
     }
+    recordCliTrace({
+      phase: "cli.play_start_stream_fallback",
+      ms: Date.now() - startedAt,
+      ok: false,
+      playName: input.playName,
+      workflowId: lastKnownWorkflowId,
+      eventCount,
+      firstRunIdMs,
+      lastPhase,
+      reason: "stream ended before terminal event"
+    });
     return waitForPlayCompletionByPolling({
       client: input.client,
       workflowId: lastKnownWorkflowId,
@@ -5086,10 +5254,11 @@ async function waitForPlayCompletionByPolling(input) {
       progress: input.progress
     });
     if (TERMINAL_PLAY_STATUSES2.has(status.status)) {
-      return status.result !== void 0 ? status : await input.client.getPlayStatus(input.workflowId);
+      return status.result !== void 0 ? status : await input.client.getPlayStatus(input.workflowId, { billing: false });
     }
     const authoritativeStatus = await input.client.getPlayStatus(
-      input.workflowId
+      input.workflowId,
+      { billing: false }
     );
     if (TERMINAL_PLAY_STATUSES2.has(authoritativeStatus.status)) {
       return authoritativeStatus;
@@ -5844,11 +6013,24 @@ async function handleFileBackedRun(options) {
   const progress = getActiveCliProgress() ?? createCliProgress(!options.jsonOutput);
   const absolutePlayPath = (0, import_node_path8.resolve)(options.target.path);
   progress.phase("compiling play");
-  const sourceCode = (0, import_node_fs6.readFileSync)(absolutePlayPath, "utf-8");
+  const sourceCode = traceCliSync(
+    "cli.play_file_read_source",
+    { targetKind: "file" },
+    () => (0, import_node_fs6.readFileSync)(absolutePlayPath, "utf-8")
+  );
+  const runtimeInput = options.input ? { ...options.input } : {};
   let graph;
   try {
-    graph = await collectBundledPlayGraph(absolutePlayPath);
-    await compileBundledPlayGraphManifests(client, graph);
+    graph = await traceCliSpan(
+      "cli.play_file_bundle_graph",
+      { targetKind: "file" },
+      () => collectBundledPlayGraph(absolutePlayPath)
+    );
+    await traceCliSpan(
+      "cli.play_file_compile_manifests",
+      { targetKind: "file" },
+      () => compileBundledPlayGraphManifests(client, graph)
+    );
     progress.phase("compiled play");
   } catch (error) {
     progress.fail();
@@ -5859,36 +6041,47 @@ async function handleFileBackedRun(options) {
   const playName = bundleResult.playName ?? extractPlayName(sourceCode, absolutePlayPath);
   try {
     progress.phase("publishing imported plays");
-    await publishImportedPlayDependencies(client, graph);
+    await traceCliSpan(
+      "cli.play_file_publish_imports",
+      { targetKind: "file" },
+      () => publishImportedPlayDependencies(client, graph)
+    );
   } catch (error) {
     progress.fail();
     console.error(error instanceof Error ? error.message : String(error));
     return 1;
   }
-  const runtimeInput = options.input ? { ...options.input } : {};
   const packagedFileUploads = bundleResult.packagedFiles.map(
     (file) => stageFile(file.logicalPath, file.absolutePath)
   );
+  const compilerManifest = requireCompilerManifest(bundleResult);
   const fileInputBindings = fileInputBindingsFromStaticPipeline(
-    requireCompilerManifest(bundleResult).staticPipeline
+    compilerManifest.staticPipeline
   );
   applyCsvShortcutInput({
     runtimeInput,
     bindings: fileInputBindings,
     fallbackInputPath: "file"
   });
-  const stagedFileInputs = await stageFileInputArgs({
-    client,
-    runtimeInput,
-    bindings: fileInputBindings,
-    progress
-  });
+  const stagedFileInputs = await traceCliSpan(
+    "cli.play_stage_inputs",
+    {
+      targetKind: "file",
+      bindingCount: fileInputBindings.length
+    },
+    () => stageFileInputArgs({
+      client,
+      runtimeInput,
+      bindings: fileInputBindings,
+      progress
+    })
+  );
   const startRequest = {
     name: playName,
     sourceCode: bundleResult.sourceCode,
     sourceFiles: bundleResult.sourceFiles,
     runtimeArtifact: bundleResult.artifact,
-    compilerManifest: requireCompilerManifest(bundleResult),
+    compilerManifest,
     packagedFileUploads,
     ...Object.keys(runtimeInput).length > 0 ? { input: runtimeInput } : {},
     ...stagedFileInputs.inputFile ? { inputFile: stagedFileInputs.inputFile } : {},
@@ -5897,26 +6090,42 @@ async function handleFileBackedRun(options) {
   };
   if (options.watch) {
     progress.phase("starting run");
-    const finalStatus = await startAndWaitForPlayCompletionByStream({
-      client,
-      request: startRequest,
-      playName,
-      jsonOutput: options.jsonOutput,
-      emitLogs: options.emitLogs,
-      waitTimeoutMs: options.waitTimeoutMs,
-      progress
-    });
-    const exportedPath = exportPlayStatusRows(finalStatus, options.outPath);
+    const finalStatus = await traceCliSpan(
+      "cli.play_start_watch",
+      { targetKind: "file", playName },
+      () => startAndWaitForPlayCompletionByStream({
+        client,
+        request: startRequest,
+        playName,
+        jsonOutput: options.jsonOutput,
+        emitLogs: options.emitLogs,
+        waitTimeoutMs: options.waitTimeoutMs,
+        progress
+      })
+    );
+    const exportedPath = traceCliSync(
+      "cli.play_export_rows",
+      { targetKind: "file", playName },
+      () => exportPlayStatusRows(finalStatus, options.outPath)
+    );
     if (finalStatus.status === "completed") {
       progress.complete();
     } else {
       progress.fail();
     }
-    writePlayResult(finalStatus, options.jsonOutput, { exportedPath });
+    traceCliSync(
+      "cli.play_write_result",
+      { targetKind: "file", playName },
+      () => writePlayResult(finalStatus, options.jsonOutput, { exportedPath })
+    );
     return finalStatus.status === "completed" ? 0 : 1;
   }
   progress.phase("starting run");
-  const started = await client.startPlayRun(startRequest);
+  const started = await traceCliSpan(
+    "cli.play_start_unwatched",
+    { targetKind: "file", playName },
+    () => client.startPlayRun(startRequest)
+  );
   const dashboardUrl = buildPlayDashboardUrl(client.baseUrl, playName);
   progress.phase(`loading play on ${dashboardUrl}`);
   progress.complete();
@@ -5951,32 +6160,67 @@ async function handleNamedRun(options) {
   }
   const client = new DeeplineClient();
   const progress = getActiveCliProgress() ?? createCliProgress(!options.jsonOutput);
-  progress.phase("loading play definition");
-  const playDetail = await assertCanonicalNamedPlayReference(client, options.target.name);
-  progress.phase("selecting revision");
-  const selectedRevisionId = await resolveNamedRunRevisionId({
-    client,
-    playName: options.target.name,
-    revisionId: options.revisionId,
-    selector: options.revisionSelector
-  });
+  const playName = options.target.name;
   const runtimeInput = options.input ? { ...options.input } : {};
-  const fileInputBindings = [
+  const needsPlayDefinition = namedRunNeedsPlayDefinition({
+    runtimeInput,
+    revisionSelector: options.revisionSelector
+  });
+  const playDetail = needsPlayDefinition ? await (async () => {
+    progress.phase("loading play definition");
+    return traceCliSpan(
+      "cli.play_load_definition",
+      { targetKind: "name", playName, skipped: false },
+      () => assertCanonicalNamedPlayReference(client, playName)
+    );
+  })() : (recordCliTrace({
+    phase: "cli.play_load_definition",
+    ms: 0,
+    ok: true,
+    targetKind: "name",
+    playName,
+    skipped: true
+  }), null);
+  progress.phase("selecting revision");
+  const selectedRevisionId = await traceCliSpan(
+    "cli.play_select_revision",
+    {
+      targetKind: "name",
+      playName,
+      selector: options.revisionSelector,
+      hasExplicitRevisionId: Boolean(options.revisionId)
+    },
+    () => resolveNamedRunRevisionId({
+      client,
+      playName,
+      revisionId: options.revisionId,
+      selector: options.revisionSelector
+    })
+  );
+  const fileInputBindings = playDetail ? [
     ...fileInputBindingsFromPlaySchema(playDetail.play.inputSchema),
     ...fileInputBindingsFromStaticPipeline(playDetail.play.staticPipeline)
-  ];
+  ] : [];
   applyCsvShortcutInput({
     runtimeInput,
     bindings: fileInputBindings
   });
-  const stagedFileInputs = await stageFileInputArgs({
-    client,
-    runtimeInput,
-    bindings: fileInputBindings,
-    progress
-  });
+  const stagedFileInputs = await traceCliSpan(
+    "cli.play_stage_inputs",
+    {
+      targetKind: "name",
+      playName,
+      bindingCount: fileInputBindings.length
+    },
+    () => stageFileInputArgs({
+      client,
+      runtimeInput,
+      bindings: fileInputBindings,
+      progress
+    })
+  );
   const startRequest = {
-    name: options.target.name,
+    name: playName,
     ...selectedRevisionId ? { revisionId: selectedRevisionId } : {},
     ...Object.keys(runtimeInput).length > 0 ? { input: runtimeInput } : {},
     ...stagedFileInputs.inputFile ? { inputFile: stagedFileInputs.inputFile } : {},
@@ -5985,35 +6229,51 @@ async function handleNamedRun(options) {
   };
   if (options.watch) {
     progress.phase("starting run");
-    const finalStatus = await startAndWaitForPlayCompletionByStream({
-      client,
-      request: startRequest,
-      playName: options.target.name,
-      jsonOutput: options.jsonOutput,
-      emitLogs: options.emitLogs,
-      waitTimeoutMs: options.waitTimeoutMs,
-      progress
-    });
-    const exportedPath = exportPlayStatusRows(finalStatus, options.outPath);
+    const finalStatus = await traceCliSpan(
+      "cli.play_start_watch",
+      { targetKind: "name", playName },
+      () => startAndWaitForPlayCompletionByStream({
+        client,
+        request: startRequest,
+        playName,
+        jsonOutput: options.jsonOutput,
+        emitLogs: options.emitLogs,
+        waitTimeoutMs: options.waitTimeoutMs,
+        progress
+      })
+    );
+    const exportedPath = traceCliSync(
+      "cli.play_export_rows",
+      { targetKind: "name", playName },
+      () => exportPlayStatusRows(finalStatus, options.outPath)
+    );
     if (finalStatus.status === "completed") {
       progress.complete();
     } else {
       progress.fail();
     }
-    writePlayResult(finalStatus, options.jsonOutput, { exportedPath });
+    traceCliSync(
+      "cli.play_write_result",
+      { targetKind: "name", playName },
+      () => writePlayResult(finalStatus, options.jsonOutput, { exportedPath })
+    );
     return finalStatus.status === "completed" ? 0 : 1;
   }
   progress.phase("starting run");
-  const started = await client.startPlayRun(startRequest);
+  const started = await traceCliSpan(
+    "cli.play_start_unwatched",
+    { targetKind: "name", playName },
+    () => client.startPlayRun(startRequest)
+  );
   const dashboardUrl = buildPlayDashboardUrl(
     client.baseUrl,
-    options.target.name
+    playName
   );
   progress.phase(`loading play on ${dashboardUrl}`);
   progress.complete();
   writeStartedPlayRun({
     runId: started.workflowId,
-    playName: started.name ?? options.target.name,
+    playName: started.name ?? playName,
     status: started.status,
     statusUrl: started.statusUrl,
     dashboardUrl: started.dashboardUrl ?? dashboardUrl,
@@ -7876,54 +8136,6 @@ async function syncSdkSkillsIfNeeded(baseUrl) {
   writeSdkSkillsStatusLine("SDK skills are up to date.");
 }
 
-// src/cli/trace.ts
-var cliTraceStartedAt = Date.now();
-function isTruthyEnv(value) {
-  return value === "1" || value === "true" || value === "yes";
-}
-function isCliTraceEnabled() {
-  return isTruthyEnv(process.env.DEEPLINE_CLI_TRACE);
-}
-function recordCliTrace(event) {
-  if (!isCliTraceEnabled()) {
-    return;
-  }
-  const now = Date.now();
-  const payload = {
-    ts: now,
-    source: "cli",
-    sinceStartMs: now - cliTraceStartedAt,
-    ...event
-  };
-  process.stderr.write(`[cli-trace] ${JSON.stringify(payload)}
-`);
-}
-async function traceCliSpan(phase, fields, run) {
-  if (!isCliTraceEnabled()) {
-    return run();
-  }
-  const startedAt = Date.now();
-  try {
-    const result = await run();
-    recordCliTrace({
-      phase,
-      ms: Date.now() - startedAt,
-      ok: true,
-      ...fields
-    });
-    return result;
-  } catch (error) {
-    recordCliTrace({
-      phase,
-      ms: Date.now() - startedAt,
-      ok: false,
-      error: error instanceof Error ? error.message : String(error),
-      ...fields
-    });
-    throw error;
-  }
-}
-
 // src/cli/index.ts
 function shouldPrintStartupPhase() {
   if (process.argv.includes("--json")) {
@@ -7934,6 +8146,12 @@ function shouldPrintStartupPhase() {
   const subcommand = args[1];
   return (command === "play" || command === "plays") && subcommand === "run";
 }
+function shouldDeferSkillsSyncForCommand() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  const subcommand = args[1];
+  return (command === "play" || command === "plays") && subcommand === "run" && args.includes("--json");
+}
 async function main() {
   const mainStartedAt = Date.now();
   recordCliTrace({
@@ -7978,11 +8196,13 @@ Output:
     if (printStartupPhase) {
       progress?.phase("checking sdk skills");
     }
-    await traceCliSpan(
-      "cli.sdk_skills_sync",
-      { baseUrl },
-      () => syncSdkSkillsIfNeeded(baseUrl)
-    );
+    if (!shouldDeferSkillsSyncForCommand()) {
+      await traceCliSpan(
+        "cli.sdk_skills_sync",
+        { baseUrl },
+        () => syncSdkSkillsIfNeeded(baseUrl)
+      );
+    }
   });
   registerAuthCommands(program);
   registerToolsCommands(program);