deepline 0.1.0 → 0.1.2

package/dist/cli/index.mjs

@@ -169,7 +169,7 @@ function resolveConfig(options) {
 }
 
 // src/version.ts
-var SDK_VERSION = "0.1.0";
+var SDK_VERSION = "0.1.2";
 var SDK_API_CONTRACT = "2026-04-plays-v1";
 
 // ../shared_libs/play-runtime/coordinator-headers.ts
@@ -2466,7 +2466,7 @@ function registerOrgCommands(program) {
 // src/cli/commands/play.ts
 import { createHash as createHash3 } from "crypto";
 import {
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   readFileSync as readFileSync3,
   readdirSync,
   realpathSync,
@@ -2479,6 +2479,7 @@ import { Option } from "commander";
 import { tmpdir as tmpdir2 } from "os";
 import { dirname as dirname5, join as join5, resolve as resolve6 } from "path";
 import { fileURLToPath } from "url";
+import { existsSync as existsSync3 } from "fs";
 
 // ../shared_libs/plays/bundling/index.ts
 import { createHash } from "crypto";
@@ -2583,7 +2584,7 @@ function typecheckPlaySource(input, adapter) {
       ...input.importedPlayDependencies.map((dependency) => dependency.filePath)
     ])
   );
-  const sdkTypesPath = adapter.sdkEntryFile;
+  const sdkTypesPath = adapter.sdkTypesEntryFile ?? adapter.sdkEntryFile;
   const program = ts.createProgram(rootNames, {
     target: ts.ScriptTarget.ES2023,
     // SDK source uses fetch/RequestInit/URL and node-aware config helpers.
@@ -3681,24 +3682,24 @@ async function discoverPackagedLocalFiles(entryFile) {
 
 // src/plays/bundle-play-file.ts
 var PLAY_BUNDLE_CACHE_VERSION2 = 24;
-var SDK_SOURCE_ROOT = resolve6(dirname5(fileURLToPath(import.meta.url)), "..");
-var PROJECT_ROOT = resolve6(SDK_SOURCE_ROOT, "..", "..");
-var SDK_PACKAGE_JSON = resolve6(SDK_SOURCE_ROOT, "..", "package.json");
-var SDK_ENTRY_FILE = resolve6(SDK_SOURCE_ROOT, "index.ts");
-var SDK_WORKERS_ENTRY_FILE = resolve6(SDK_SOURCE_ROOT, "worker-play-entry.ts");
-var WORKERS_HARNESS_ENTRY_FILE = resolve6(
-  PROJECT_ROOT,
-  "apps",
-  "play-runner-workers",
-  "src",
-  "entry.ts"
+var MODULE_DIR = dirname5(fileURLToPath(import.meta.url));
+var SDK_PACKAGE_ROOT = resolve6(MODULE_DIR, "..", "..");
+var SOURCE_REPO_ROOT = resolve6(SDK_PACKAGE_ROOT, "..");
+var HAS_SOURCE_BUNDLING_SOURCES = existsSync3(
+  resolve6(SOURCE_REPO_ROOT, "apps", "play-runner-workers", "src", "entry.ts")
 );
-var WORKERS_HARNESS_FILES_DIR = resolve6(
-  PROJECT_ROOT,
-  "apps",
-  "play-runner-workers",
-  "src"
+var PACKAGED_REPO_ROOT = resolve6(SDK_PACKAGE_ROOT, "dist", "repo");
+var HAS_PACKAGED_BUNDLING_SOURCES = existsSync3(
+  resolve6(PACKAGED_REPO_ROOT, "apps", "play-runner-workers", "src", "entry.ts")
 );
+var PROJECT_ROOT = HAS_SOURCE_BUNDLING_SOURCES ? SOURCE_REPO_ROOT : HAS_PACKAGED_BUNDLING_SOURCES ? PACKAGED_REPO_ROOT : resolve6(SDK_PACKAGE_ROOT, "..");
+var SDK_SOURCE_ROOT = HAS_SOURCE_BUNDLING_SOURCES ? resolve6(SOURCE_REPO_ROOT, "sdk", "src") : HAS_PACKAGED_BUNDLING_SOURCES ? resolve6(PACKAGED_REPO_ROOT, "sdk", "src") : resolve6(SDK_PACKAGE_ROOT, "src");
+var SDK_PACKAGE_JSON = resolve6(SDK_PACKAGE_ROOT, "package.json");
+var SDK_ENTRY_FILE = resolve6(SDK_SOURCE_ROOT, "index.ts");
+var SDK_TYPES_ENTRY_FILE = resolve6(SDK_PACKAGE_ROOT, "dist", "index.d.ts");
+var SDK_WORKERS_ENTRY_FILE = resolve6(SDK_SOURCE_ROOT, "worker-play-entry.ts");
+var WORKERS_HARNESS_ENTRY_FILE = resolve6(PROJECT_ROOT, "apps", "play-runner-workers", "src", "entry.ts");
+var WORKERS_HARNESS_FILES_DIR = resolve6(PROJECT_ROOT, "apps", "play-runner-workers", "src");
 var hasWarnedAboutNonDevelopmentBundling = false;
 function warnAboutNonDevelopmentBundling(filePath) {
   if (hasWarnedAboutNonDevelopmentBundling) {
@@ -3727,6 +3728,7 @@ function createSdkPlayBundlingAdapter() {
     sdkSourceRoot: SDK_SOURCE_ROOT,
     sdkPackageJson: SDK_PACKAGE_JSON,
     sdkEntryFile: SDK_ENTRY_FILE,
+    sdkTypesEntryFile: existsSync3(SDK_TYPES_ENTRY_FILE) ? SDK_TYPES_ENTRY_FILE : SDK_ENTRY_FILE,
     sdkWorkersEntryFile: SDK_WORKERS_ENTRY_FILE,
     workersHarnessEntryFile: WORKERS_HARNESS_ENTRY_FILE,
     workersHarnessFilesDir: WORKERS_HARNESS_FILES_DIR,
@@ -3871,6 +3873,54 @@ 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 parseReferencedPlayTarget(target) {
   const trimmed = target.trim();
@@ -3926,7 +3976,7 @@ function materializeRemotePlaySource(input) {
     return null;
   }
   const outputPath = input.outPath ?? defaultMaterializedPlayPath(input.playName);
-  if (existsSync3(outputPath)) {
+  if (existsSync4(outputPath)) {
     const existingSource = readFileSync3(outputPath, "utf-8");
     if (existingSource === input.sourceCode) {
       return { path: outputPath, status: "unchanged", created: false };
@@ -3977,7 +4027,7 @@ function extractPlayName(code, filePath) {
   throw buildMissingDefinePlayError(filePath);
 }
 function isFileTarget(target) {
-  return existsSync3(resolve7(target));
+  return existsSync4(resolve7(target));
 }
 function looksLikeFilePath(target) {
   if (target.trim().toLowerCase().startsWith("prebuilt/")) {
@@ -4294,6 +4344,10 @@ function buildPlayDashboardUrl(baseUrl, playName) {
   const encodedPlayName = encodeURIComponent(playName);
   return `${trimmedBase}/dashboard/plays/${encodedPlayName}`;
 }
+function getDashboardUrlFromLiveEvent(event) {
+  const dashboardUrl = getEventPayload(event).dashboardUrl;
+  return typeof dashboardUrl === "string" && dashboardUrl.trim() ? dashboardUrl.trim() : null;
+}
 function printPlayLogLines(input) {
   for (const line of input.lines) {
     if (input.emitLogs) {
@@ -4404,18 +4458,33 @@ async function startAndWaitForPlayCompletionByStream(input) {
     },
     Math.max(1, input.waitTimeoutMs)
   );
+  recordCliTrace({
+    phase: "cli.start_stream_request",
+    playName: input.playName
+  });
   try {
+    let eventCount = 0;
     for await (const event of input.client.startPlayRunStream(input.request, {
       signal: controller.signal
     })) {
+      eventCount += 1;
+      if (eventCount === 1) {
+        recordCliTrace({
+          phase: "cli.start_stream_first_event",
+          ms: Date.now() - startedAt,
+          playName: input.playName,
+          eventType: event.type
+        });
+      }
       const eventRunId = getEventPayload(event).runId;
       if (typeof eventRunId === "string" && eventRunId && eventRunId !== "pending") {
         lastKnownWorkflowId = eventRunId;
       }
       const workflowId = lastKnownWorkflowId || "pending";
       if (workflowId !== "pending" && !emittedDashboardUrl) {
+        const dashboardUrl = getDashboardUrlFromLiveEvent(event) ?? buildPlayDashboardUrl(input.client.baseUrl, input.playName);
         input.progress.phase(
-          `loading play on ${buildPlayDashboardUrl(input.client.baseUrl, input.playName)}`
+          `loading play on ${dashboardUrl}`
         );
         emittedDashboardUrl = true;
       }
@@ -4440,6 +4509,14 @@ async function startAndWaitForPlayCompletionByStream(input) {
       });
       const finalStatus = getFinalStatusFromLiveEvent(event);
       if (finalStatus) {
+        recordCliTrace({
+          phase: "cli.start_stream_final_event",
+          ms: Date.now() - startedAt,
+          playName: input.playName,
+          runId: finalStatus.runId,
+          status: finalStatus.status,
+          eventCount
+        });
         return finalStatus;
       }
     }
@@ -5103,12 +5180,34 @@ async function handleFileBackedRun(options) {
   const client = new DeeplineClient();
   const progress = getActiveCliProgress() ?? createCliProgress(!options.jsonOutput);
   const absolutePlayPath = resolve7(options.target.path);
+  recordCliTrace({
+    phase: "cli.play_run_file_start",
+    playPath: absolutePlayPath,
+    watch: options.watch,
+    hasCsv: Boolean(options.csvPath),
+    force: options.force
+  });
   progress.phase("compiling play");
+  const readSourceStartedAt = Date.now();
   const sourceCode = readFileSync3(absolutePlayPath, "utf-8");
+  recordCliTrace({
+    phase: "cli.read_play_source",
+    ms: Date.now() - readSourceStartedAt,
+    bytes: sourceCode.length,
+    playPath: absolutePlayPath
+  });
   let graph;
   try {
-    graph = await collectBundledPlayGraph(absolutePlayPath);
-    await compileBundledPlayGraphManifests(client, graph);
+    graph = await traceCliSpan(
+      "cli.bundle_play_graph",
+      { playPath: absolutePlayPath },
+      () => collectBundledPlayGraph(absolutePlayPath)
+    );
+    await traceCliSpan(
+      "cli.compile_play_manifest",
+      { playPath: absolutePlayPath, nodeCount: graph.nodes.size },
+      () => compileBundledPlayGraphManifests(client, graph)
+    );
     progress.phase("compiled play");
   } catch (error) {
     progress.fail();
@@ -5119,17 +5218,32 @@ async function handleFileBackedRun(options) {
   const playName = bundleResult.playName ?? extractPlayName(sourceCode, absolutePlayPath);
   try {
     progress.phase("publishing imported plays");
-    await publishImportedPlayDependencies(client, graph);
+    await traceCliSpan(
+      "cli.publish_imported_plays",
+      { playName, nodeCount: graph.nodes.size },
+      () => 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 prepareFilesStartedAt = Date.now();
   const packagedFileUploads = bundleResult.packagedFiles.map(
     (file) => stageFile(file.logicalPath, file.absolutePath)
   );
   const inputFileUpload = options.csvPath ? stageFile(basename3(options.csvPath), options.csvPath) : packagedFileUploads[0] ?? null;
+  if (options.csvPath && typeof runtimeInput.file !== "string" && typeof runtimeInput.csv !== "string") {
+    runtimeInput.file = basename3(options.csvPath);
+  }
+  recordCliTrace({
+    phase: "cli.prepare_input_files",
+    ms: Date.now() - prepareFilesStartedAt,
+    playName,
+    packagedFileCount: packagedFileUploads.length,
+    hasInputFile: Boolean(inputFileUpload)
+  });
   const startRequest = {
     name: playName,
     sourceCode: bundleResult.sourceCode,
@@ -5142,27 +5256,49 @@ async function handleFileBackedRun(options) {
   };
   if (options.watch) {
     progress.phase("starting run");
-    const finalStatus = await startAndWaitForPlayCompletionByStream({
-      client,
-      request: startRequest,
+    const finalStatus = await traceCliSpan(
+      "cli.start_and_watch",
+      { playName },
+      () => startAndWaitForPlayCompletionByStream({
+        client,
+        request: startRequest,
+        playName,
+        jsonOutput: options.jsonOutput,
+        emitLogs: options.emitLogs,
+        waitTimeoutMs: options.waitTimeoutMs,
+        progress
+      })
+    );
+    const exportStartedAt = Date.now();
+    const exportedPath = exportPlayStatusRows(finalStatus, options.outPath);
+    recordCliTrace({
+      phase: "cli.export_rows",
+      ms: Date.now() - exportStartedAt,
       playName,
-      jsonOutput: options.jsonOutput,
-      emitLogs: options.emitLogs,
-      waitTimeoutMs: options.waitTimeoutMs,
-      progress
+      exported: Boolean(exportedPath)
     });
-    const exportedPath = exportPlayStatusRows(finalStatus, options.outPath);
     if (finalStatus.status === "completed") {
       progress.complete();
     } else {
       progress.fail();
     }
+    recordCliTrace({
+      phase: "cli.write_play_result",
+      playName,
+      status: finalStatus.status,
+      runId: finalStatus.runId
+    });
     writePlayResult(finalStatus, options.jsonOutput, { exportedPath });
     return finalStatus.status === "completed" ? 0 : 1;
   }
   progress.phase("starting run");
-  const started = await client.startPlayRun(startRequest);
-  const dashboardUrl = buildPlayDashboardUrl(client.baseUrl, playName);
+  const started = await traceCliSpan(
+    "cli.start_run",
+    { playName },
+    () => client.startPlayRun(startRequest)
+  );
+  const fallbackDashboardUrl = buildPlayDashboardUrl(client.baseUrl, playName);
+  const dashboardUrl = started.dashboardUrl ?? fallbackDashboardUrl;
   progress.phase(`loading play on ${dashboardUrl}`);
   progress.complete();
   writeStartedPlayRun({
@@ -5170,7 +5306,7 @@ async function handleFileBackedRun(options) {
     playName,
     status: started.status,
     statusUrl: started.statusUrl,
-    dashboardUrl: started.dashboardUrl ?? dashboardUrl,
+    dashboardUrl,
     jsonOutput: options.jsonOutput
   });
   return 0;
@@ -5242,10 +5378,11 @@ async function handleNamedRun(options) {
   }
   progress.phase("starting run");
   const started = await client.startPlayRun(startRequest);
-  const dashboardUrl = buildPlayDashboardUrl(
+  const fallbackDashboardUrl = buildPlayDashboardUrl(
     client.baseUrl,
     options.target.name
   );
+  const dashboardUrl = started.dashboardUrl ?? fallbackDashboardUrl;
   progress.phase(`loading play on ${dashboardUrl}`);
   progress.complete();
   writeStartedPlayRun({
@@ -5253,7 +5390,7 @@ async function handleNamedRun(options) {
     playName: started.name ?? options.target.name,
     status: started.status,
     statusUrl: started.statusUrl,
-    dashboardUrl: started.dashboardUrl ?? dashboardUrl,
+    dashboardUrl,
     jsonOutput: options.jsonOutput
   });
   return 0;
@@ -5267,7 +5404,7 @@ async function handlePlayRun(args) {
     const resolved = resolve7(options.target.path);
     console.error(`File not found: ${resolved}`);
     const dir = dirname6(resolved);
-    if (existsSync3(dir)) {
+    if (existsSync4(dir)) {
       const base = basename3(resolved);
       try {
         const siblings = readdirSync(dir).filter(
@@ -6742,6 +6879,11 @@ function shouldPrintStartupPhase() {
   return (command === "play" || command === "plays") && subcommand === "run";
 }
 async function main() {
+  const mainStartedAt = Date.now();
+  recordCliTrace({
+    phase: "cli.main_start",
+    argv: process.argv.slice(2)
+  });
   const printStartupPhase = shouldPrintStartupPhase();
   const progress = printStartupPhase ? createCliProgress(true) : null;
   if (printStartupPhase) {
@@ -6771,7 +6913,12 @@ Output:
     if (printStartupPhase) {
       progress?.phase("checking sdk compatibility");
     }
-    await enforceSdkCompatibility(autoDetectBaseUrl().replace(/\/$/, ""));
+    const baseUrl = autoDetectBaseUrl().replace(/\/$/, "");
+    await traceCliSpan(
+      "cli.sdk_compatibility",
+      { baseUrl },
+      () => enforceSdkCompatibility(baseUrl)
+    );
   });
   registerAuthCommands(program);
   registerToolsCommands(program);
@@ -6799,7 +6946,18 @@ Output:
   });
   try {
     await program.parseAsync(process.argv);
+    recordCliTrace({
+      phase: "cli.main_total",
+      ms: Date.now() - mainStartedAt,
+      ok: true
+    });
   } catch (error) {
+    recordCliTrace({
+      phase: "cli.main_total",
+      ms: Date.now() - mainStartedAt,
+      ok: false,
+      error: error instanceof Error ? error.message : String(error)
+    });
     if (process.argv.includes("--json")) {
       printJsonError(error);
     } else if (error instanceof Error) {