deepline 0.1.10 → 0.1.12

package/dist/repo/sdk/src/cli/commands/play.ts

@@ -1,7 +1,6 @@
 import { createHash } from 'node:crypto';
 import {
   existsSync,
-  mkdirSync,
   readFileSync,
   readdirSync,
   realpathSync,
@@ -37,12 +36,10 @@ import {
   getActiveCliProgress,
   type CliProgress,
 } from '../progress.js';
-import { recordCliTrace, traceCliSpan } from '../trace.js';
 import { argsWantJson } from '../utils.js';
 
 type PlayRunCommandOptions = {
   target: { kind: 'file'; path: string } | { kind: 'name'; name: string };
-  csvPath: string | null;
   input: Record<string, unknown> | null;
   revisionId: string | null;
   revisionSelector: 'live' | 'latest' | null;
@@ -55,6 +52,10 @@ type PlayRunCommandOptions = {
   outPath: string | null;
 };
 
+type FileInputBinding = {
+  inputPath: string;
+};
+
 type PlayCheckCommandOptions = {
   target: string;
   jsonOutput: boolean;
@@ -141,81 +142,6 @@ function defaultMaterializedPlayPath(reference: string): string {
   return resolve(`${safeName || 'play'}.play.ts`);
 }
 
-function sanitizeGeneratedPlayName(value: string): string {
-  return (
-    value
-      .trim()
-      .toLowerCase()
-      .replace(/^prebuilt\//, '')
-      .replace(/[^a-z0-9-]/g, '-')
-      .replace(/-+/g, '-')
-      .replace(/^-|-$/g, '') || 'play'
-  );
-}
-
-function buildGeneratedCsvWrapperSource(input: {
-  wrapperName: string;
-  playRef: string;
-}): string {
-  return `import { definePlay } from 'deepline';
-
-export default definePlay(
-  ${JSON.stringify(input.wrapperName)},
-  async (ctx, input: Record<string, unknown> & { file: string }) => {
-    const rows = await ctx.csv<Record<string, unknown>>(input.file);
-    const constants = Object.fromEntries(
-      Object.entries(input).filter(([key]) => key !== 'file'),
-    );
-
-    const mappedRows = await ctx
-      .map('csv_rows', rows, {
-        key: (row, index) =>
-          String(
-            row.id ??
-              row.lead_id ??
-              row.email ??
-              row.linkedin_url ??
-              row.domain ??
-              index,
-          ),
-      })
-      .step('result', (row, rowCtx) =>
-        rowCtx.runPlay(
-          'row_play',
-          ${JSON.stringify(input.playRef)},
-          {
-            ...constants,
-            ...row,
-          },
-          {
-            description: 'Run the source play for this CSV row.',
-          },
-        ),
-      )
-      .run({ description: 'Run the source play once per CSV row.' });
-
-    return { rows: mappedRows };
-  },
-);
-`;
-}
-
-function writeGeneratedCsvWrapperPlay(playRef: string): string {
-  const baseName = sanitizeGeneratedPlayName(
-    parseReferencedPlayTarget(playRef).unqualifiedPlayName,
-  );
-  const wrapperName = `${baseName}-csv`;
-  const outputDir = resolve('.deepline', 'generated');
-  const outputPath = join(outputDir, `${wrapperName}.play.ts`);
-  mkdirSync(outputDir, { recursive: true });
-  writeFileSync(
-    outputPath,
-    buildGeneratedCsvWrapperSource({ wrapperName, playRef }),
-    'utf-8',
-  );
-  return outputPath;
-}
-
 type MaterializedRemotePlaySource = {
   path: string;
   status: 'created' | 'updated' | 'unchanged';
@@ -308,8 +234,15 @@ function looksLikeFilePath(target: string): boolean {
   if (target.trim().toLowerCase().startsWith('prebuilt/')) {
     return false;
   }
+  if (
+    target.startsWith('./') ||
+    target.startsWith('../') ||
+    target.startsWith('/') ||
+    target.startsWith('~/')
+  ) {
+    return true;
+  }
   return (
-    target.includes('/') ||
     target.includes('\\') ||
     /\.(ts|js|mjs|play\.ts)$/.test(target)
   );
@@ -334,6 +267,187 @@ function parseJsonInput(raw: string): Record<string, unknown> {
   return parsed as Record<string, unknown>;
 }
 
+function parseInputFieldFlag(
+  rawFlag: string,
+  nextArg: string | undefined,
+): { path: string; value: string } {
+  const flag = rawFlag.slice(2);
+  const equalsIndex = flag.indexOf('=');
+  if (equalsIndex > 0) {
+    const path = flag.slice(0, equalsIndex).trim();
+    const value = flag.slice(equalsIndex + 1);
+    if (!path) {
+      throw new Error(`Invalid play input flag: ${rawFlag}`);
+    }
+    return { path, value };
+  }
+  if (!nextArg || nextArg.startsWith('--')) {
+    throw new Error(`Play input flag ${rawFlag} requires a value.`);
+  }
+  return { path: flag, value: nextArg };
+}
+
+function parseInputFlagValue(raw: string): unknown {
+  const trimmed = raw.trim();
+  if (!trimmed) return '';
+  if (
+    trimmed === 'true' ||
+    trimmed === 'false' ||
+    trimmed === 'null' ||
+    trimmed.startsWith('{') ||
+    trimmed.startsWith('[') ||
+    /^-?\d+(\.\d+)?$/.test(trimmed)
+  ) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return raw;
+    }
+  }
+  return raw;
+}
+
+function getDottedInputValue(
+  input: Record<string, unknown>,
+  path: string,
+): unknown {
+  const parts = path.split('.').map((part) => part.trim()).filter(Boolean);
+  let cursor: unknown = input;
+  for (const part of parts) {
+    if (!cursor || typeof cursor !== 'object' || Array.isArray(cursor)) {
+      return undefined;
+    }
+    cursor = (cursor as Record<string, unknown>)[part];
+  }
+  return cursor;
+}
+
+function setDottedInputValue(
+  input: Record<string, unknown>,
+  path: string,
+  value: unknown,
+): void {
+  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: Record<string, unknown> = input;
+  for (const part of parts.slice(0, -1)) {
+    const existing = cursor[part];
+    if (
+      existing !== undefined &&
+      (!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] as Record<string, unknown>;
+  }
+  cursor[parts[parts.length - 1]!] = value;
+}
+
+function schemaMetadata(
+  schema: Record<string, unknown> | null | undefined,
+  key: string,
+): Record<string, unknown> | null {
+  if (!schema || typeof schema !== 'object' || Array.isArray(schema)) return null;
+  const value = schema[key];
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : null;
+}
+
+function stringMetadata(
+  metadata: Record<string, unknown> | null | undefined,
+  key: string,
+): string | null {
+  const value = metadata?.[key];
+  return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function inputFieldFromCsvArg(csvArg: unknown): string | null {
+  if (typeof csvArg !== 'string') return null;
+  const match = /^input\.([A-Za-z_$][\w$]*)$/.exec(csvArg.trim());
+  return match?.[1] ?? null;
+}
+
+function fileInputBindingsFromPlaySchema(
+  inputSchema: Record<string, unknown> | null | undefined,
+): FileInputBinding[] {
+  const csvInput = schemaMetadata(inputSchema, 'csvInput');
+  if (!csvInput) return [];
+  return [
+    {
+      inputPath: stringMetadata(csvInput, 'inputField') ?? 'csv',
+    },
+  ];
+}
+
+function fileInputBindingsFromStaticPipeline(
+  staticPipeline: unknown,
+): FileInputBinding[] {
+  if (!staticPipeline || typeof staticPipeline !== 'object' || Array.isArray(staticPipeline)) {
+    return [];
+  }
+  const inputField = inputFieldFromCsvArg(
+    (staticPipeline as Record<string, unknown>).csvArg,
+  );
+  return inputField ? [{ inputPath: inputField }] : [];
+}
+
+function isLocalFilePathValue(value: unknown): value is string {
+  if (typeof value !== 'string' || !value.trim()) return false;
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(value.trim())) return false;
+  return existsSync(resolve(value));
+}
+
+async function stageFileInputArgs(input: {
+  client: DeeplineClient;
+  runtimeInput: Record<string, unknown>;
+  bindings: FileInputBinding[];
+  progress: CliProgress;
+}): Promise<{
+  inputFile: PlayStagedFileRef | null;
+  packagedFiles: PlayStagedFileRef[];
+}> {
+  const uniqueBindings = [
+    ...new Map(input.bindings.map((binding) => [binding.inputPath, binding])).values(),
+  ];
+  const localFiles = uniqueBindings.flatMap((binding) => {
+    const value = getDottedInputValue(input.runtimeInput, binding.inputPath);
+    if (!isLocalFilePathValue(value)) return [];
+    const absolutePath = resolve(value);
+    return [{ binding, absolutePath, logicalPath: basename(absolutePath) }];
+  });
+
+  if (localFiles.length === 0) {
+    return { inputFile: null, packagedFiles: [] };
+  }
+
+  input.progress.phase(
+    localFiles.length === 1 ? 'staging input file' : 'staging input files',
+  );
+  const staged = await input.client.stagePlayFiles(
+    localFiles.map((file) => stageFile(file.logicalPath, file.absolutePath)),
+  );
+  for (const [index, file] of localFiles.entries()) {
+    setDottedInputValue(input.runtimeInput, file.binding.inputPath, file.logicalPath);
+    const stagedFile = staged[index];
+    if (stagedFile && stagedFile.logicalPath !== file.logicalPath) {
+      setDottedInputValue(input.runtimeInput, file.binding.inputPath, stagedFile.logicalPath);
+    }
+  }
+
+  return {
+    inputFile: staged[0] ?? null,
+    packagedFiles: staged.slice(1),
+  };
+}
+
 function stageFile(logicalPath: string, absolutePath: string) {
   const buffer = readFileSync(absolutePath);
   return {
@@ -937,24 +1051,10 @@ 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' &&
@@ -1002,14 +1102,6 @@ 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;
       }
     }
@@ -1488,7 +1580,6 @@ function buildRunNextCommands(runId: string): Record<string, string> {
   return {
     exportCsv: `deepline runs export ${runId} --out output.csv`,
     status: `deepline runs status ${runId} --json`,
-    fullStatus: `deepline runs status ${runId} --json --full`,
     logs: `deepline runs logs ${runId}`,
   };
 }
@@ -1542,13 +1633,30 @@ function compactPlayStatus(
     ...(result !== undefined ? { result } : {}),
     ...(status.resultView ? { resultView: status.resultView } : {}),
     ...(datasetStats ? { dataset_stats: datasetStats } : {}),
-    ...(rowsInfo ? { previewRows: rowsInfo.rows.slice(0, 10) } : {}),
+    ...(rowsInfo ? { previewRows: rowsInfo.rows.slice(0, 5) } : {}),
     ...(billing ? { billing } : {}),
     ...(status.run ? { run: status.run } : {}),
     next: buildRunNextCommands(status.runId),
   };
 }
 
+function enrichPlayStatusWithDatasetStats(
+  status: PlayStatus,
+): PlayStatus & { dataset_stats?: DatasetStats } {
+  const rowsInfo = extractCanonicalRowsInfo(status);
+  if (!rowsInfo?.complete) {
+    return status;
+  }
+  return {
+    ...status,
+    dataset_stats: buildDatasetStats(
+      rowsInfo.rows,
+      rowsInfo.totalRows,
+      rowsInfo.columns,
+    ),
+  };
+}
+
 function formatDatasetStatsLines(datasetStats: DatasetStats | null): string[] {
   if (!datasetStats) {
     return [];
@@ -1559,17 +1667,17 @@ function formatDatasetStatsLines(datasetStats: DatasetStats | null): string[] {
     12,
   )) {
     const topValues = stat.top_values
-      ? `, ${Object.entries(stat.top_values)
+      ? `, top_values=${Object.entries(stat.top_values)
           .slice(0, 3)
           .map(([value, count]) => `${value}=${count}`)
           .join(', ')}`
       : '';
     const sample =
       stat.sample_value !== undefined
-        ? `, sample=${JSON.stringify(stat.sample_value)}`
+        ? `, sample_value=${JSON.stringify(stat.sample_value)}`
         : '';
     lines.push(
-      `    ${column}: ${stat.non_empty}, unique=${stat.unique}${topValues}${sample}`,
+      `    ${column}: non_empty=${stat.non_empty}, unique=${stat.unique}${topValues}${sample}`,
     );
   }
   return lines;
@@ -1583,7 +1691,9 @@ function writePlayResult(
   if (jsonOutput) {
     process.stdout.write(
       `${JSON.stringify(
-        options?.fullJson ? status : compactPlayStatus(status, options),
+        options?.fullJson
+          ? enrichPlayStatusWithDatasetStats(status)
+          : compactPlayStatus(status, options),
       )}\n`,
     );
     return;
@@ -1833,13 +1943,12 @@ function writeStartedPlayRun(input: {
 
 function parsePlayRunOptions(args: string[]): PlayRunCommandOptions {
   const usage =
-    "Usage: deepline plays run <play-name> [--input '{...}'] [--csv file.csv] [--live|--latest|--revision-id <id>] [--watch] [--out output.csv] [--tail-timeout-ms 30000] [--force]\n" +
-    "       deepline plays run <play-file.ts> [--input '{...}'] [--csv file.csv] [--watch] [--out output.csv] [--tail-timeout-ms 30000] [--force]\n" +
-    "       deepline plays run --file <play-file.ts> [--input '{...}'] [--csv file.csv] [--watch] [--out output.csv] [--tail-timeout-ms 30000] [--force]\n" +
-    "       deepline plays run --name <name> [--input '{...}'] [--csv file.csv] [--live|--latest|--revision-id <id>] [--watch] [--out output.csv] [--tail-timeout-ms 30000] [--force] [--json]";
+    "Usage: deepline plays run <play-name> [--input '{...}'] [--watch] [--out output.csv] [--tail-timeout-ms 30000] [--force] [--<input> value]\n" +
+    "       deepline plays run <play-file.ts> [--input '{...}'] [--watch] [--out output.csv] [--tail-timeout-ms 30000] [--force] [--<input> value]\n" +
+    "       deepline plays run --file <play-file.ts> [--input '{...}'] [--watch] [--out output.csv] [--tail-timeout-ms 30000] [--force] [--<input> value]\n" +
+    "       deepline plays run --name <name> [--input '{...}'] [--live|--latest|--revision-id <id>] [--watch] [--out output.csv] [--tail-timeout-ms 30000] [--force] [--json] [--<input> value]";
   let filePath: string | null = null;
   let playName: string | null = null;
-  let csvPath: string | null = null;
   let input: Record<string, unknown> | null = null;
   let revisionId: string | null = null;
   let revisionSelector: 'live' | 'latest' | null = null;
@@ -1861,10 +1970,6 @@ function parsePlayRunOptions(args: string[]): PlayRunCommandOptions {
       playName = parseReferencedPlayTarget(args[++index]!).playName;
       continue;
     }
-    if (arg === '--csv' && args[index + 1]) {
-      csvPath = resolve(args[++index]!);
-      continue;
-    }
     if ((arg === '--input' || arg === '-i') && args[index + 1]) {
       input = parseJsonInput(args[++index]!);
       continue;
@@ -1927,7 +2032,13 @@ function parsePlayRunOptions(args: string[]): PlayRunCommandOptions {
       continue;
     }
     if (arg.startsWith('--')) {
-      throw new Error(`Unexpected flag: ${arg}\n${usage}`);
+      const { path, value } = parseInputFieldFlag(arg, args[index + 1]);
+      input ??= {};
+      setDottedInputValue(input, path, parseInputFlagValue(value));
+      if (!arg.includes('=')) {
+        index += 1;
+      }
+      continue;
     }
     if (!arg.startsWith('--') && !filePath && !playName) {
       if (isFileTarget(arg) || looksLikeFilePath(arg)) {
@@ -1967,7 +2078,6 @@ function parsePlayRunOptions(args: string[]): PlayRunCommandOptions {
     target: filePath
       ? { kind: 'file', path: filePath }
       : { kind: 'name', name: playName! },
-    csvPath,
     input,
     revisionId,
     revisionSelector,
@@ -2055,37 +2165,15 @@ async function handleFileBackedRun(
   const progress =
     getActiveCliProgress() ?? createCliProgress(!options.jsonOutput);
   const absolutePlayPath = resolve(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 = readFileSync(absolutePlayPath, 'utf-8');
-  recordCliTrace({
-    phase: 'cli.read_play_source',
-    ms: Date.now() - readSourceStartedAt,
-    bytes: sourceCode.length,
-    playPath: absolutePlayPath,
-  });
   let graph: {
     root: BundledPlayFileSuccess;
     nodes: Map<string, BundledPlayFileSuccess>;
   };
   try {
-    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),
-    );
+    graph = await collectBundledPlayGraph(absolutePlayPath);
+    await compileBundledPlayGraphManifests(client, graph);
     progress.phase('compiled play');
   } catch (error) {
     progress.fail();
@@ -2099,11 +2187,7 @@ async function handleFileBackedRun(
 
   try {
     progress.phase('publishing imported plays');
-    await traceCliSpan(
-      'cli.publish_imported_plays',
-      { playName, nodeCount: graph.nodes.size },
-      () => publishImportedPlayDependencies(client, graph),
-    );
+    await publishImportedPlayDependencies(client, graph);
   } catch (error) {
     progress.fail();
     console.error(error instanceof Error ? error.message : String(error));
@@ -2111,26 +2195,16 @@ async function handleFileBackedRun(
   }
 
   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(basename(options.csvPath), options.csvPath)
-    : (packagedFileUploads[0] ?? null);
-  if (
-    options.csvPath &&
-    typeof runtimeInput.file !== 'string' &&
-    typeof runtimeInput.csv !== 'string'
-  ) {
-    runtimeInput.file = basename(options.csvPath);
-  }
-  recordCliTrace({
-    phase: 'cli.prepare_input_files',
-    ms: Date.now() - prepareFilesStartedAt,
-    playName,
-    packagedFileCount: packagedFileUploads.length,
-    hasInputFile: Boolean(inputFileUpload),
+  const stagedFileInputs = await stageFileInputArgs({
+    client,
+    runtimeInput,
+    bindings: fileInputBindingsFromStaticPipeline(
+      requireCompilerManifest(bundleResult).staticPipeline,
+    ),
+    progress,
   });
 
   const startRequest = {
@@ -2138,59 +2212,41 @@ async function handleFileBackedRun(
     sourceCode: bundleResult.sourceCode,
     runtimeArtifact: bundleResult.artifact,
     compilerManifest: requireCompilerManifest(bundleResult),
-    inputFileUpload,
     packagedFileUploads,
     ...(Object.keys(runtimeInput).length > 0 ? { input: runtimeInput } : {}),
+    ...(stagedFileInputs.inputFile
+      ? { inputFile: stagedFileInputs.inputFile }
+      : {}),
+    ...(stagedFileInputs.packagedFiles.length
+      ? { packagedFiles: stagedFileInputs.packagedFiles }
+      : {}),
     ...(options.force ? { force: true } : {}),
   };
 
   if (options.watch) {
     progress.phase('starting run');
-    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,
+    const finalStatus = await startAndWaitForPlayCompletionByStream({
+      client,
+      request: startRequest,
       playName,
-      exported: Boolean(exportedPath),
+      jsonOutput: options.jsonOutput,
+      emitLogs: options.emitLogs,
+      waitTimeoutMs: options.waitTimeoutMs,
+      progress,
     });
+    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 traceCliSpan(
-    'cli.start_run',
-    { playName },
-    () => client.startPlayRun(startRequest),
-  );
-  const fallbackDashboardUrl = buildPlayDashboardUrl(client.baseUrl, playName);
-  const dashboardUrl = started.dashboardUrl ?? fallbackDashboardUrl;
+  const started = await client.startPlayRun(startRequest);
+  const dashboardUrl = buildPlayDashboardUrl(client.baseUrl, playName);
   progress.phase(`loading play on ${dashboardUrl}`);
   progress.complete();
 
@@ -2199,7 +2255,7 @@ async function handleFileBackedRun(
     playName,
     status: started.status,
     statusUrl: started.statusUrl,
-    dashboardUrl,
+    dashboardUrl: started.dashboardUrl ?? dashboardUrl,
     jsonOutput: options.jsonOutput,
     progress,
   });
@@ -2233,10 +2289,9 @@ async function handleNamedRun(options: PlayRunCommandOptions): Promise<number> {
   const client = new DeeplineClient();
   const progress =
     getActiveCliProgress() ?? createCliProgress(!options.jsonOutput);
-  let stagedInputFile: PlayStagedFileRef | null = null;
 
   progress.phase('loading play definition');
-  await assertCanonicalNamedPlayReference(client, options.target.name);
+  const playDetail = await assertCanonicalNamedPlayReference(client, options.target.name);
   progress.phase('selecting revision');
   const selectedRevisionId = await resolveNamedRunRevisionId({
     client,
@@ -2245,21 +2300,27 @@ async function handleNamedRun(options: PlayRunCommandOptions): Promise<number> {
     selector: options.revisionSelector,
   });
 
-  if (options.csvPath) {
-    progress.phase('staging input file');
-    const [staged] = await client.stagePlayFiles([
-      stageFile(basename(options.csvPath), options.csvPath),
-    ]);
-    stagedInputFile = staged ?? null;
-  }
-
   const runtimeInput = options.input ? { ...options.input } : {};
+  const stagedFileInputs = await stageFileInputArgs({
+    client,
+    runtimeInput,
+    bindings: [
+      ...fileInputBindingsFromPlaySchema(playDetail.play.inputSchema),
+      ...fileInputBindingsFromStaticPipeline(playDetail.play.staticPipeline),
+    ],
+    progress,
+  });
 
   const startRequest = {
     name: options.target.name,
     ...(selectedRevisionId ? { revisionId: selectedRevisionId } : {}),
     ...(Object.keys(runtimeInput).length > 0 ? { input: runtimeInput } : {}),
-    ...(stagedInputFile ? { inputFile: stagedInputFile } : {}),
+    ...(stagedFileInputs.inputFile
+      ? { inputFile: stagedFileInputs.inputFile }
+      : {}),
+    ...(stagedFileInputs.packagedFiles.length
+      ? { packagedFiles: stagedFileInputs.packagedFiles }
+      : {}),
     ...(options.force ? { force: true } : {}),
   };
 
@@ -2274,22 +2335,6 @@ async function handleNamedRun(options: PlayRunCommandOptions): Promise<number> {
       waitTimeoutMs: options.waitTimeoutMs,
       progress,
     });
-    if (finalStatus.status !== 'completed' && options.csvPath) {
-      progress.phase('generating csv wrapper play');
-      const generatedPlayPath = writeGeneratedCsvWrapperPlay(
-        options.target.name,
-      );
-      progress.writeLogLine(
-        `Generated CSV wrapper play: ${generatedPlayPath}`,
-      );
-      progress.phase('running generated csv wrapper play');
-      return handleFileBackedRun({
-        ...options,
-        target: { kind: 'file', path: generatedPlayPath },
-        revisionId: null,
-        revisionSelector: null,
-      });
-    }
     const exportedPath = exportPlayStatusRows(finalStatus, options.outPath);
     if (finalStatus.status === 'completed') {
       progress.complete();
@@ -2302,11 +2347,10 @@ async function handleNamedRun(options: PlayRunCommandOptions): Promise<number> {
 
   progress.phase('starting run');
   const started = await client.startPlayRun(startRequest);
-  const fallbackDashboardUrl = buildPlayDashboardUrl(
+  const dashboardUrl = buildPlayDashboardUrl(
     client.baseUrl,
     options.target.name,
   );
-  const dashboardUrl = started.dashboardUrl ?? fallbackDashboardUrl;
   progress.phase(`loading play on ${dashboardUrl}`);
   progress.complete();
 
@@ -2315,7 +2359,7 @@ async function handleNamedRun(options: PlayRunCommandOptions): Promise<number> {
     playName: started.name ?? options.target.name,
     status: started.status,
     statusUrl: started.statusUrl,
-    dashboardUrl,
+    dashboardUrl: started.dashboardUrl ?? dashboardUrl,
     jsonOutput: options.jsonOutput,
     progress,
   });
@@ -2558,8 +2602,9 @@ export async function handlePlayGet(args: string[]): Promise<number> {
   }
 
   const client = new DeeplineClient();
-  const jsonOutput = argsWantJson(args);
+  const explicitJson = args.includes('--json');
   const sourceOutput = args.includes('--source');
+  const jsonOutput = sourceOutput ? explicitJson : argsWantJson(args);
   let outPath: string | null = null;
   for (let index = 1; index < args.length; index += 1) {
     const arg = args[index]!;
@@ -2580,7 +2625,7 @@ export async function handlePlayGet(args: string[]): Promise<number> {
     detail.play.sourceCode ??
     '';
   const materializedFile =
-    sourceOutput || outPath
+    outPath
       ? materializeRemotePlaySource({
           target,
           playName,
@@ -2628,6 +2673,11 @@ export async function handlePlayGet(args: string[]): Promise<number> {
     return 0;
   }
 
+  if (outPath && loadedMessage) {
+    console.log(loadedMessage);
+    return 0;
+  }
+
   console.log(`Play: ${formatPlayReference(detail.play)}`);
   console.log(
     `Working version: ${detail.play.workingRevision?.version ?? '—'}`,
@@ -2808,6 +2858,20 @@ function printPlayDescription(play: PlayDescription): void {
       console.log(`    ${line}`);
     }
   }
+  if (play.csvInput) {
+    console.log('  CSV input:');
+    const rendered = JSON.stringify(play.csvInput, null, 2);
+    for (const line of rendered.split('\n')) {
+      console.log(`    ${line}`);
+    }
+  }
+  if (play.rowOutputSchema) {
+    console.log('  Row output schema:');
+    const rendered = JSON.stringify(play.rowOutputSchema, null, 2);
+    for (const line of rendered.split('\n')) {
+      console.log(`    ${line}`);
+    }
+  }
   console.log(`  Run: ${play.runCommand}`);
 }
 
@@ -2961,6 +3025,47 @@ export async function handlePlayPublish(args: string[]): Promise<number> {
   return result.success ? 0 : 1;
 }
 
+export async function handlePlayDelete(args: string[]): Promise<number> {
+  const playName = args[0];
+  if (!playName) {
+    console.error('Usage: deepline plays delete <play-name> --yes [--json]');
+    return 1;
+  }
+  const confirmed =
+    args.includes('--yes') || args.includes('-y') || args.includes('--force');
+  if (!confirmed) {
+    console.error(
+      'Refusing to delete without --yes. This deletes the org-owned play, its revisions, trigger bindings, and local run records.',
+    );
+    return 1;
+  }
+
+  const client = new DeeplineClient();
+  let detail: PlayDetail;
+  try {
+    detail = await client.getPlay(parseReferencedPlayTarget(playName).playName);
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+  if (detail.play.ownerType === 'deepline' || detail.play.origin === 'prebuilt') {
+    console.error(`Cannot delete prebuilt play: ${formatPlayReference(detail.play)}`);
+    return 1;
+  }
+
+  const result = await client.deletePlay(
+    parseReferencedPlayTarget(formatPlayReference(detail.play)).playName,
+  );
+  if (argsWantJson(args)) {
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    return result.deleted ? 0 : 1;
+  }
+  process.stdout.write(
+    `Deleted ${result.name}: revisions=${result.deletedRevisionCount}, bindings=${result.deletedBindingCount}, runs=${result.deletedRunCount}\n`,
+  );
+  return result.deleted ? 0 : 1;
+}
+
 export function registerPlayCommands(program: Command): void {
   const play = program
     .command('plays')
@@ -3008,14 +3113,18 @@ Examples:
   play
     .command('run [target]')
     .description('Run a play file or named play.')
+    .allowUnknownOption(true)
+    .allowExcessArguments(true)
     .addHelpText(
       'after',
       `
 Notes:
-  Local play files are bundled locally, then validated and executed in Deepline cloud.
-  Named plays run the stored live cloud revision.
-  Run performs server preflight automatically. Use \`deepline plays check <file>\`
-  to validate without starting a run.
+	  Local play files are bundled locally, then validated and executed in Deepline cloud.
+	  Named plays run the stored live cloud revision.
+	  Unknown --foo and --foo.bar flags are treated as play input args.
+	  File-like input args accept local paths; the CLI stages those files before submit.
+	  Run performs server preflight automatically. Use \`deepline plays check <file>\`
+	  to validate without starting a run.
 
 Examples:
   deepline plays run my.play.ts --input '{"domain":"stripe.com"}' --watch
@@ -3025,7 +3134,6 @@ Examples:
     )
     .option('--file <path>', 'Local play file to run')
     .option('--name <name>', 'Saved play name to run')
-    .option('--csv <path>', 'Attach a CSV file')
     .option('-i, --input <json>', 'Input JSON object or @file path')
     .option('--live', 'Run the current live revision explicitly')
     .option('--latest', 'Run the newest saved revision, even if it is not live')
@@ -3046,12 +3154,26 @@ Examples:
     .option('--tail-timeout-ms <ms>', 'Timeout while tailing')
     .option('--force', 'Supersede any active runs for this play')
     .option('--json', 'Emit JSON output')
-    .action(async (target, options) => {
+    .action(async (target, options, command) => {
+      const passthroughArgs = [...command.args];
+      const explicitTarget = options.file || options.name;
+      const targetIsInputFlag = typeof target === 'string' && target.startsWith('--');
+      const effectiveTarget = explicitTarget || targetIsInputFlag ? null : target;
+      if (
+        explicitTarget &&
+        typeof target === 'string' &&
+        !targetIsInputFlag &&
+        !passthroughArgs.includes(target)
+      ) {
+        passthroughArgs.push(target);
+      }
+      if (effectiveTarget && passthroughArgs[0] === effectiveTarget) {
+        passthroughArgs.shift();
+      }
       process.exitCode = await handlePlayRun([
-        ...(target ? [target] : []),
+        ...(effectiveTarget ? [effectiveTarget] : []),
         ...(options.file ? ['--file', options.file] : []),
         ...(options.name ? ['--name', options.name] : []),
-        ...(options.csv ? ['--csv', options.csv] : []),
         ...(options.input ? ['--input', options.input] : []),
         ...(options.live ? ['--live'] : []),
         ...(options.latest ? ['--latest'] : []),
@@ -3067,6 +3189,7 @@ Examples:
           : []),
         ...(options.force ? ['--force'] : []),
         ...(options.json ? ['--json'] : []),
+        ...passthroughArgs,
       ]);
     });
 
@@ -3084,15 +3207,13 @@ Notes:
 Examples:
   deepline plays get person-linkedin-to-email
   deepline plays get person-linkedin-to-email --json | jq '.play.liveRevision'
+  deepline plays get prebuilt/name-and-domain-to-email-waterfall-batch --source > email-waterfall.play.ts
+  deepline plays get prebuilt/name-and-domain-to-email-waterfall-batch --source --out ./email-waterfall.play.ts
 `,
     )
     .option('--json', 'Emit JSON output. Also automatic when stdout is piped')
-    .addOption(
-      new Option('--source', 'Materialize or print the source code').hideHelp(),
-    )
-    .addOption(
-      new Option('--out <path>', 'Write source to a specific path').hideHelp(),
-    )
+    .option('--source', 'Print raw source code; combine with --out to write a file')
+    .option('--out <path>', 'Write source to a specific path')
     .action(async (target, options) => {
       process.exitCode = await handlePlayGet([
         target,
@@ -3200,7 +3321,7 @@ Examples:
     .option('--run-id <runId>', 'Run id to inspect')
     .option('--name <name>', 'Inspect the latest run for a named play')
     .option('--json', 'Emit JSON output')
-    .option('--full', 'With --json, emit the full raw status payload')
+    .option('--full', 'Debug only: with --json, emit the raw status payload')
     .action(async (options) => {
       process.exitCode = await handlePlayStatus([
         ...(options.runId ? ['--run-id', options.runId] : []),
@@ -3254,6 +3375,19 @@ Examples:
       ]);
     });
 
+  play
+    .command('delete <target>')
+    .description('Delete an org-owned play and its saved revisions/runs.')
+    .option('-y, --yes', 'Confirm deletion')
+    .option('--json', 'Emit JSON output. Also automatic when stdout is piped')
+    .action(async (target, options) => {
+      process.exitCode = await handlePlayDelete([
+        target,
+        ...(options.yes ? ['--yes'] : []),
+        ...(options.json ? ['--json'] : []),
+      ]);
+    });
+
   const runs = program
     .command('runs')
     .description('Inspect and export play runs.')
@@ -3271,7 +3405,7 @@ Examples:
     .command('status <runId>')
     .description('Show compact status for a play run.')
     .option('--json', 'Emit JSON output. Also automatic when stdout is piped')
-    .option('--full', 'With --json, emit the full raw status payload')
+    .option('--full', 'Debug only: with --json, emit the raw status payload')
     .action(async (runId, options) => {
       process.exitCode = await handleRunStatus([
         runId,