deepline 0.3.293 → 0.3.295

package/dist/cli/chunk-6O5YZOVN.mjs

@@ -0,0 +1,890 @@
+import {
+  HttpClient,
+  detectAgentRuntime,
+  resolveCliCommandContext,
+  resolveConfig
+} from "./chunk-EACVZI6N.mjs";
+import {
+  DeeplineError
+} from "./chunk-NXGCO4JB.mjs";
+
+// src/cli/json-fields.ts
+var RUN_FIELDS = new Set(
+  "id playName status dashboardUrl acceptedAt updatedAt startedAt finishedAt durationMs revisionId recovery error activity work".split(
+    " "
+  )
+);
+var ROOTS = {
+  describe: "name playKey reference displayName description pinned toolCategories tags origin ownerType canEdit canClone aliases inputSchema outputSchema staticPipeline csvInput rowOutputSchema runCommand examples cloneEditStarter currentPublishedVersion liveVersion triggerStatus triggerMetadata isDraftDirty latestRunId runtimeLimit activeScheduledPlays command_context",
+  check: "kind target checked scope name exportName valid stage issues inputSchema outputSchema recognized triggers runtimeLimit limits featureFlags sourceHash artifactHash graphHash toolGetterHints exports actions diagnostics reference origin ownerType activeScheduledPlays command_context",
+  run: "schemaVersion kind run datasets actions apiVersion dashboardUrl progress rowOutcomes steps errors error warnings result resultState execution command_context diagnostics",
+  get: "schemaVersion kind run runStatus steps failures errorDetails rowOutcomes warnings failedLogs datasets result resultState actions diagnostics command_context",
+  config: "runId contract command_context",
+  export: "runId datasets csv_path json_path format source rowCount columns notice metadata_path actions command_context"
+};
+function parseJsonFields(args, surface) {
+  const normalized = [];
+  let fields;
+  const allowed = new Set(ROOTS[surface].split(" "));
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg !== "--json" && !arg.startsWith("--json=")) {
+      normalized.push(arg);
+      continue;
+    }
+    normalized.push("--json");
+    const value = arg.startsWith("--json=") ? arg.slice(7) : args[i + 1] && !args[i + 1].startsWith("-") ? args[++i] : void 0;
+    if (value === void 0) continue;
+    const paths = value.split(",").map((path) => path.trim());
+    for (const path of paths) {
+      const parts = path.split(".");
+      if (parts.some(
+        (part) => !/^[a-zA-Z_][a-zA-Z_0-9]*$/.test(part) || ["__proto__", "prototype", "constructor"].includes(part)
+      ) || !allowed.has(parts[0])) {
+        throw new DeeplineError(
+          `Unknown --json field '${path}'. Available roots: ${[...allowed].join(", ")}.`,
+          void 0,
+          "INVALID_ARGUMENT"
+        );
+      }
+      if (parts[0] === "run" && parts[1] && !RUN_FIELDS.has(parts[1])) {
+        const hint = parts[1] === "url" ? " Use run.dashboardUrl." : parts[1] === "stats" ? " Dataset summaries are in datasets; run timing is in run.durationMs." : "";
+        throw new DeeplineError(
+          `Unknown --json run field '${parts[1]}'. Available: ${[...RUN_FIELDS].join(", ")}.${hint}`,
+          void 0,
+          "INVALID_ARGUMENT"
+        );
+      }
+      if (parts[0] === "diagnostics" && !args.includes("--full")) {
+        const target = args[0] && !args[0].startsWith("-") ? args[0] : "<target>";
+        const command = surface === "get" ? "runs get" : `plays ${surface}`;
+        const quotedTarget = `'${target.replace(/'/g, "'\\''")}'`;
+        throw new DeeplineError(
+          `--json diagnostics requires --full. For inspection, use: deepline ${surface === "run" ? "runs get <run-id>" : `${command} ${quotedTarget}`} --full --json ${path}`,
+          void 0,
+          "INVALID_ARGUMENT"
+        );
+      }
+    }
+    fields = [...fields ?? [], ...paths];
+  }
+  if (fields && normalized.includes("--input") && surface === "get") {
+    throw new DeeplineError(
+      "--json fields selects the run response, not --input. Use bare --json with --input.",
+      void 0,
+      "INVALID_ARGUMENT"
+    );
+  }
+  return { args: normalized, fields };
+}
+function selectJsonFields(value, fields) {
+  if (!fields) return value;
+  function project(source, paths) {
+    if (paths.some((path) => path.length === 0)) return source;
+    if (source === null) return null;
+    if (Array.isArray(source))
+      return source.map((item) => project(item, paths));
+    if (typeof source !== "object" || source === void 0) return void 0;
+    const groups = /* @__PURE__ */ new Map();
+    for (const [key, ...rest] of paths)
+      groups.set(key, [...groups.get(key) ?? [], rest]);
+    return Object.fromEntries(
+      [...groups].flatMap(([key, tails]) => {
+        if (!Object.hasOwn(source, key)) return [];
+        const child = project(source[key], tails);
+        return child === void 0 ? [] : [[key, child]];
+      })
+    );
+  }
+  return project(
+    value,
+    fields.map((path) => path.split("."))
+  );
+}
+function jsonFieldArgs(value) {
+  return typeof value === "string" ? [`--json=${value}`] : value ? ["--json"] : [];
+}
+function describeArgs(target, options) {
+  let fields = options.json;
+  if (!target && typeof fields === "string") {
+    target = fields;
+    fields = true;
+  }
+  return [
+    ...target ? [target] : [],
+    ...options.compact ? ["--compact"] : [],
+    ...jsonFieldArgs(fields)
+  ];
+}
+
+// src/cli/utils.ts
+import { createHash } from "crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { mkdir, writeFile } from "fs/promises";
+import { homedir, tmpdir, userInfo } from "os";
+import { dirname, join, resolve } from "path";
+import * as childProcess from "child_process";
+import { parse } from "csv-parse/sync";
+import { stringify } from "csv-stringify/sync";
+var BROWSER_OPEN_COOLDOWN_MS = 3e4;
+var SAME_URL_BROWSER_OPEN_COOLDOWN_MS = 5 * 6e4;
+var defaultBrowserCommandRunner = childProcess;
+function getAuthedHttpClient() {
+  const config = resolveConfig();
+  return { config, http: new HttpClient(config) };
+}
+function stableOsUserId() {
+  try {
+    const info = userInfo();
+    if (typeof info.uid === "number") return `uid-${info.uid}`;
+    if (info.username) return `user-${info.username}`;
+  } catch {
+  }
+  return "unknown-user";
+}
+function defaultBrowserOpenStateDir() {
+  return join(tmpdir(), `deepline-${stableOsUserId()}`, "runtime", "state");
+}
+function browserOpenStateFile(stateDir = defaultBrowserOpenStateDir()) {
+  return join(stateDir, "browser-open.json");
+}
+function normalizeBrowserOpenTarget(raw) {
+  return String(raw || "").trim();
+}
+function browserOpenTargetKey(raw) {
+  const normalized = normalizeBrowserOpenTarget(raw);
+  return normalized ? createHash("sha256").update(normalized).digest("hex") : "";
+}
+function claimBrowserOpen(now = Date.now(), stateDir, targetUrl) {
+  const statePath = browserOpenStateFile(stateDir);
+  const lockPath = `${statePath}.lock`;
+  const targetKey = browserOpenTargetKey(targetUrl);
+  let locked = false;
+  try {
+    mkdirSync(dirname(statePath), { recursive: true, mode: 448 });
+    try {
+      mkdirSync(lockPath, { mode: 448 });
+      locked = true;
+    } catch {
+      return false;
+    }
+    let lastOpenedAt = 0;
+    if (existsSync(statePath)) {
+      const payload = JSON.parse(readFileSync(statePath, "utf-8"));
+      const value = payload.lastOpenedAt ?? payload.last_opened_at ?? payload.lastFocusedAt ?? payload.last_focused_at;
+      if (typeof value === "number" && Number.isFinite(value)) {
+        lastOpenedAt = value;
+      }
+      const targetValue = payload.targetKey ?? payload.target_key ?? payload.targetHash ?? payload.target_hash;
+      const lastTargetKey = typeof targetValue === "string" ? targetValue.trim() : "";
+      const cooldownMs = targetKey && targetKey === lastTargetKey ? SAME_URL_BROWSER_OPEN_COOLDOWN_MS : BROWSER_OPEN_COOLDOWN_MS;
+      if (lastOpenedAt > now) {
+        lastOpenedAt = 0;
+      }
+      if (now - lastOpenedAt < cooldownMs) {
+        return false;
+      }
+    }
+    writeFileSync(
+      statePath,
+      JSON.stringify({
+        lastOpenedAt: now,
+        ...targetKey ? { targetKey } : {}
+      }),
+      { encoding: "utf-8", mode: 384 }
+    );
+    return true;
+  } catch {
+    return true;
+  } finally {
+    if (locked) {
+      rmSync(lockPath, { recursive: true, force: true });
+    }
+  }
+}
+function extractUrlHost(raw) {
+  try {
+    const parsed = new URL(raw.includes("://") ? raw : `https://${raw}`);
+    return parsed.port ? `${parsed.hostname.toLowerCase()}:${parsed.port}` : parsed.hostname.toLowerCase();
+  } catch {
+    return "";
+  }
+}
+function browserAppNameFromBundleId(bundleId) {
+  const names = {
+    "com.google.chrome": "Google Chrome",
+    "com.google.chrome.canary": "Google Chrome Canary",
+    "com.microsoft.edgemac": "Microsoft Edge",
+    "com.brave.browser": "Brave Browser",
+    "com.operasoftware.opera": "Opera",
+    "com.operasoftware.operagx": "Opera GX",
+    "com.vivaldi.vivaldi": "Vivaldi",
+    "company.thebrowser.browser": "Arc",
+    "com.apple.safari": "Safari"
+  };
+  return names[bundleId.toLowerCase()] ?? "";
+}
+function currentOsUsername() {
+  try {
+    return userInfo().username || "";
+  } catch {
+    return "";
+  }
+}
+function readMacosUserHome(runner = defaultBrowserCommandRunner) {
+  const username = currentOsUsername();
+  if (process.platform === "darwin" && username) {
+    try {
+      const output = runner.execFileSync(
+        "dscl",
+        [".", "-read", `/Users/${username}`, "NFSHomeDirectory"],
+        { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
+      );
+      const match = String(output).match(/NFSHomeDirectory:\s*(.+)\s*$/m);
+      const home = match?.[1]?.trim();
+      if (home) return home;
+    } catch {
+    }
+  }
+  return homedir();
+}
+function readDefaultMacBrowserBundleId(runner = defaultBrowserCommandRunner) {
+  try {
+    const output = runner.execFileSync(
+      "plutil",
+      [
+        "-convert",
+        "json",
+        "-o",
+        "-",
+        `${readMacosUserHome(runner)}/Library/Preferences/com.apple.LaunchServices/com.apple.launchservices.secure.plist`
+      ],
+      { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
+    );
+    const payload = JSON.parse(String(output));
+    const handlers = Array.isArray(payload.LSHandlers) ? payload.LSHandlers : [];
+    const pickBundle = (scheme) => {
+      for (const handler of handlers) {
+        if (!handler || typeof handler !== "object") continue;
+        if (String(handler.LSHandlerURLScheme ?? "").toLowerCase() !== scheme) {
+          continue;
+        }
+        const bundle = String(
+          handler.LSHandlerRoleAll ?? handler.LSHandlerRoleViewer ?? handler.LSHandlerRoleEditor ?? ""
+        ).trim();
+        if (bundle) return bundle;
+      }
+      return "";
+    };
+    return pickBundle("https") || pickBundle("http");
+  } catch {
+    return "";
+  }
+}
+function browserStrategyForBundleId(bundleId) {
+  const normalized = bundleId.toLowerCase();
+  if ((/* @__PURE__ */ new Set([
+    "com.google.chrome",
+    "com.google.chrome.canary",
+    "com.microsoft.edgemac",
+    "com.brave.browser",
+    "com.operasoftware.opera",
+    "com.operasoftware.operagx",
+    "com.vivaldi.vivaldi",
+    "company.thebrowser.browser"
+  ])).has(normalized)) {
+    return "chromium";
+  }
+  return normalized === "com.apple.safari" ? "safari" : "fallback";
+}
+function runAppleScript(script, args, runner = defaultBrowserCommandRunner) {
+  const result = runner.spawnSync("osascript", ["-", ...args], {
+    input: script,
+    encoding: "utf-8",
+    stdio: ["pipe", "ignore", "ignore"],
+    timeout: 5e3
+  });
+  return result.status === 0;
+}
+function retargetChromiumMacos(appName, targetUrl, allowFocus, runner = defaultBrowserCommandRunner) {
+  const host = extractUrlHost(targetUrl);
+  if (!host) return false;
+  const escapedAppName = appName.replace(/"/g, '\\"');
+  const activateBlock = allowFocus ? "    activate\n" : "";
+  const foundTabBlock = allowFocus ? "          set active tab index of w to i\n          set index of w to 1\n          set URL of t to targetUrl\n" : "          set URL of t to targetUrl\n";
+  const newTabBlock = allowFocus ? "      tell window 1\n        make new tab with properties {URL:targetUrl}\n        set active tab index to (count of tabs)\n        set index to 1\n      end tell\n" : "      tell window 1\n        make new tab with properties {URL:targetUrl}\n      end tell\n";
+  const script = `
+on run argv
+  set targetUrl to item 1 of argv
+  set targetHost to item 2 of argv
+  tell application "${escapedAppName}"
+${activateBlock}    if (count of windows) is 0 then
+      make new window
+    end if
+    set foundTab to false
+    repeat with w in windows
+      set tabCount to count of tabs of w
+      repeat with i from 1 to tabCount
+        set t to tab i of w
+        if (URL of t) contains targetHost then
+${foundTabBlock}          set foundTab to true
+          exit repeat
+        end if
+      end repeat
+      if foundTab then exit repeat
+    end repeat
+    if not foundTab then
+${newTabBlock}    end if
+  end tell
+end run
+`;
+  return runAppleScript(script, [targetUrl, host], runner);
+}
+function retargetSafariMacos(appName, targetUrl, allowFocus, runner = defaultBrowserCommandRunner) {
+  const host = extractUrlHost(targetUrl);
+  if (!host) return false;
+  const escapedAppName = appName.replace(/"/g, '\\"');
+  const activateBlock = allowFocus ? "    activate\n" : "";
+  const foundTabBlock = allowFocus ? "          set current tab of w to t\n          set index of w to 1\n          set URL of t to targetUrl\n" : "          set URL of t to targetUrl\n";
+  const newTabBlock = allowFocus ? "      tell window 1\n        set current tab to (make new tab with properties {URL:targetUrl})\n        set index to 1\n      end tell\n" : "      tell window 1\n        make new tab with properties {URL:targetUrl}\n      end tell\n";
+  const script = `
+on run argv
+  set targetUrl to item 1 of argv
+  set targetHost to item 2 of argv
+  tell application "${escapedAppName}"
+${activateBlock}    if (count of windows) is 0 then
+      make new document
+    end if
+    set foundTab to false
+    repeat with w in windows
+      set tabCount to count of tabs of w
+      repeat with i from 1 to tabCount
+        set t to tab i of w
+        if (URL of t) contains targetHost then
+${foundTabBlock}          set foundTab to true
+          exit repeat
+        end if
+      end repeat
+      if foundTab then exit repeat
+    end repeat
+    if not foundTab then
+${newTabBlock}    end if
+  end tell
+end run
+`;
+  return runAppleScript(script, [targetUrl, host], runner);
+}
+function hasOnlyHeadlessMacosBrowserInstances(appName, runner = defaultBrowserCommandRunner) {
+  try {
+    const output = runner.execFileSync("ps", ["-axo", "args="], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const executableSuffix = `/Contents/MacOS/${appName}`;
+    const lines = String(output).split(/\r?\n/).map((line) => line.trim()).filter((line) => {
+      const executableIndex = line.indexOf(executableSuffix);
+      if (executableIndex < 0 || !line.includes(".app/Contents/MacOS/")) {
+        return false;
+      }
+      const rest = line.slice(executableIndex + executableSuffix.length);
+      return rest === "" || /^\s+-/.test(rest);
+    });
+    if (lines.length === 0) return false;
+    return lines.every(
+      (line) => line.includes("--headless") || line.includes("--no-startup-window")
+    );
+  } catch {
+    return false;
+  }
+}
+function openNewVisibleMacosBrowserInstance(appName, targetUrl, runner = defaultBrowserCommandRunner) {
+  try {
+    runner.execFileSync(
+      "open",
+      ["-na", appName, "--args", "--new-window", targetUrl],
+      {
+        stdio: "ignore"
+      }
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+function openUrlMacos(targetUrl, allowFocus, runner = defaultBrowserCommandRunner) {
+  const defaultBundleId = readDefaultMacBrowserBundleId(runner);
+  const appName = defaultBundleId ? browserAppNameFromBundleId(defaultBundleId) : "";
+  const strategy = browserStrategyForBundleId(defaultBundleId);
+  if (allowFocus && appName && strategy === "chromium" && hasOnlyHeadlessMacosBrowserInstances(appName, runner) && openNewVisibleMacosBrowserInstance(appName, targetUrl, runner)) {
+    return true;
+  }
+  if (appName && strategy === "chromium" && retargetChromiumMacos(appName, targetUrl, allowFocus, runner)) {
+    return true;
+  }
+  if (appName && strategy === "safari" && retargetSafariMacos(appName, targetUrl, allowFocus, runner)) {
+    return true;
+  }
+  try {
+    runner.execFileSync("open", [...allowFocus ? [] : ["-g"], targetUrl], {
+      stdio: "ignore"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function browserOpeningDisabled() {
+  const value = String(process.env.DEEPLINE_NO_BROWSER ?? "").trim().toLowerCase();
+  return value === "1" || value === "true" || value === "yes" || value === "on";
+}
+function openInBrowser(url, options = {}) {
+  try {
+    if (browserOpeningDisabled()) return "failed";
+    const targetUrl = String(url || "").trim();
+    if (!targetUrl) return "failed";
+    if (options.deduplicate !== false && !claimBrowserOpen(Date.now(), void 0, targetUrl)) {
+      return "suppressed";
+    }
+    const allowFocus = true;
+    if (process.platform === "darwin") {
+      return openUrlMacos(targetUrl, allowFocus) ? "opened" : "failed";
+    }
+    if (!allowFocus) return "failed";
+    if (process.platform === "win32") {
+      childProcess.execFileSync("cmd.exe", ["/c", "start", "", targetUrl], {
+        stdio: "ignore"
+      });
+      return "opened";
+    }
+    childProcess.execFileSync("xdg-open", [targetUrl], { stdio: "ignore" });
+    return "opened";
+  } catch {
+    return "failed";
+  }
+}
+function sleep(ms) {
+  return new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
+}
+function collectLocalEnvInfo() {
+  const homeDir = process.env.HOME?.trim() || homedir();
+  const info = {
+    os: `${process.platform} ${process.arch}`,
+    node_version: process.version,
+    home_dir: homeDir,
+    agent_runtime: detectAgentRuntime()
+  };
+  const env = process.env;
+  const optional = {
+    claude_code_remote: env.CLAUDE_CODE_REMOTE,
+    deepline_plugin_mode: env.DEEPLINE_PLUGIN_MODE
+  };
+  for (const [key, value] of Object.entries(optional)) {
+    if (value?.trim()) info[key] = value.trim();
+  }
+  if (env.CLAUDE_PROJECT_DIR?.trim()) {
+    info.claude_project_dir_present = "true";
+  }
+  if (env.DEEPLINE_PLUGIN_ROOT?.trim()) {
+    info.deepline_plugin_root_present = "true";
+  }
+  if (env.DEEPLINE_PLUGIN_SKILLS_DIR?.trim()) {
+    info.deepline_plugin_skills_dir_present = "true";
+  }
+  if (info.home_dir === "/sessions" || info.home_dir.startsWith("/sessions/")) {
+    info.home_scope = "sessions";
+  }
+  return info;
+}
+function readCsvRows(csvPath) {
+  const raw = readFileSync(resolve(csvPath), "utf-8");
+  return parse(raw, {
+    // `csv-parse` otherwise treats a BOM before an opening quote as a field
+    // value, then rejects the quote as invalid. A UTF-8 BOM is a valid file
+    // prefix and must not become part of the first column name either.
+    bom: true,
+    columns: true,
+    skip_empty_lines: true
+  });
+}
+function csvStringFromRows(rows, columns) {
+  const effectiveColumns = columns?.length ? columns : Object.keys(rows[0] ?? {});
+  if (!effectiveColumns.length) {
+    return stringify(
+      rows.map(() => ({})),
+      { header: true }
+    );
+  }
+  const records = rows.map(
+    (row) => effectiveColumns.map(
+      (column) => csvSafeCell(
+        Object.prototype.hasOwnProperty.call(row, column) ? row[column] : void 0
+      )
+    )
+  );
+  return stringify(records, {
+    header: true,
+    cast: {
+      boolean: (value) => value ? "true" : "false",
+      object: (value) => {
+        const cell = csvSafeCell(value);
+        return typeof cell === "string" ? cell : null;
+      }
+    },
+    ...effectiveColumns.length ? { columns: effectiveColumns } : {}
+  });
+}
+function csvSafeCell(value) {
+  if (value === void 0) {
+    return null;
+  }
+  if (value === null) {
+    return null;
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (typeof value === "symbol" || typeof value === "function") {
+    return null;
+  }
+  if (typeof value !== "object") {
+    return String(value);
+  }
+  return csvSafeJsonString(value);
+}
+function csvSafeJsonReplacer(_key, nested) {
+  if (typeof nested === "bigint") {
+    return nested.toString();
+  }
+  if (nested === void 0 || typeof nested === "symbol" || typeof nested === "function") {
+    return null;
+  }
+  return nested;
+}
+function csvSafeJsonString(value) {
+  try {
+    const serialized = JSON.stringify(value, csvSafeJsonReplacer);
+    return serialized ?? null;
+  } catch {
+    return String(value);
+  }
+}
+function parseMaybeJsonObject(value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) {
+    return value;
+  }
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    return value;
+  }
+}
+function failureMessageFromRecord(value) {
+  const status = typeof value.status === "string" ? value.status.trim().toLowerCase() : "";
+  const directError = typeof value.error === "string" ? value.error.trim() : typeof value.last_error === "string" ? value.last_error.trim() : "";
+  const result = value.result && typeof value.result === "object" && !Array.isArray(value.result) ? value.result : null;
+  const resultError = typeof result?.error === "string" ? result.error.trim() : typeof result?.message === "string" ? result.message.trim() : "";
+  if (!directError && !resultError && status !== "error" && status !== "failed") {
+    return null;
+  }
+  return directError || resultError || `Column status: ${status}`;
+}
+function shouldPreserveJsonStringColumn(columns, key) {
+  if (!columns) {
+    return false;
+  }
+  if (columns.has(key)) {
+    return true;
+  }
+  const normalizedKey = key.toLowerCase().replace(/[^a-z0-9]/g, "");
+  return normalizedKey ? columns.has(normalizedKey) : false;
+}
+function flattenObjectColumns(row, options = {}) {
+  const flattened = {};
+  for (const [key, rawValue] of Object.entries(row)) {
+    const value = parseMaybeJsonObject(rawValue);
+    const parsedFromString = typeof rawValue === "string" && value !== rawValue;
+    if (key === "_metadata") {
+      flattened[key] = value && typeof value === "object" ? csvSafeJsonString(value) : value;
+      continue;
+    }
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      const record = value;
+      if (options.objectColumns === "json") {
+        flattened[key] = csvSafeJsonString(record);
+        continue;
+      }
+      const hasMatchedEnvelope = Object.prototype.hasOwnProperty.call(record, "matched_result") || Object.prototype.hasOwnProperty.call(record, "matchedResult");
+      if (hasMatchedEnvelope) {
+        flattened[key] = csvSafeJsonString(record);
+        continue;
+      }
+      if (parsedFromString && shouldPreserveJsonStringColumn(options.preserveJsonStringColumns, key)) {
+        flattened[key] = rawValue;
+        continue;
+      } else {
+        const failureMessage = failureMessageFromRecord(record);
+        if (failureMessage) {
+          flattened[key] = failureMessage;
+          continue;
+        } else if (Object.prototype.hasOwnProperty.call(record, "result")) {
+          flattened[key] = csvSafeJsonString(record);
+          continue;
+        }
+      }
+      for (const [nestedKey, nestedValue] of Object.entries(record)) {
+        flattened[`${key}.${nestedKey}`] = nestedValue && typeof nestedValue === "object" ? csvSafeJsonString(nestedValue) : nestedValue;
+      }
+      continue;
+    }
+    flattened[key] = Array.isArray(value) ? csvSafeJsonString(value) : value;
+  }
+  return flattened;
+}
+function recordRows(value) {
+  return value.filter(
+    (row) => Boolean(row) && typeof row === "object" && !Array.isArray(row)
+  );
+}
+function dataExportRows(rows, options = {}) {
+  return rows.map((row) => flattenObjectColumns(row, options));
+}
+function dataExportColumns(rows, preferredColumns = []) {
+  const discoveredColumns = [
+    ...new Set(rows.flatMap((row) => Object.keys(row)))
+  ];
+  if (rows.length === 0) {
+    return [...new Set(preferredColumns.filter(Boolean))];
+  }
+  const discovered = new Set(discoveredColumns);
+  const columns = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const column of preferredColumns) {
+    if (!column) {
+      continue;
+    }
+    const expandedColumns = discovered.has(column) ? [column] : discoveredColumns.filter(
+      (discoveredColumn) => discoveredColumn.startsWith(`${column}.`)
+    );
+    for (const expandedColumn of expandedColumns) {
+      if (seen.has(expandedColumn)) {
+        continue;
+      }
+      seen.add(expandedColumn);
+      columns.push(expandedColumn);
+    }
+  }
+  for (const column of discoveredColumns) {
+    if (seen.has(column)) {
+      continue;
+    }
+    seen.add(column);
+    columns.push(column);
+  }
+  return columns;
+}
+function dataExportCsvString(rows, preferredColumns = []) {
+  const flattenedRows = dataExportRows(rows);
+  return csvStringFromRows(
+    flattenedRows,
+    dataExportColumns(flattenedRows, preferredColumns)
+  );
+}
+function markdownCell(value) {
+  if (value === null || value === void 0) {
+    return "";
+  }
+  const text = typeof value === "object" ? JSON.stringify(value) : String(value);
+  return text.replace(/\|/g, "\\|").replace(/\r?\n/g, "<br>");
+}
+function markdownTableFromRows(rows, preferredColumns = []) {
+  const flattenedRows = dataExportRows(rows);
+  const columns = dataExportColumns(flattenedRows, preferredColumns);
+  const header = `| ${columns.map(markdownCell).join(" | ")} |`;
+  const separator = `| ${columns.map(() => "---").join(" | ")} |`;
+  const body = flattenedRows.map(
+    (row) => `| ${columns.map((column) => markdownCell(row[column])).join(" | ")} |`
+  );
+  return `${[header, separator, ...body].join("\n")}
+`;
+}
+function withAgentCommandContext(value) {
+  const valueRecord = value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+  return detectAgentRuntime() !== "unknown" && valueRecord && !Object.prototype.hasOwnProperty.call(valueRecord, "command_context") ? {
+    ...valueRecord,
+    command_context: resolveCliCommandContext()
+  } : value;
+}
+function printJson(value, fields) {
+  process.stdout.write(
+    `${JSON.stringify(selectJsonFields(withAgentCommandContext(value), fields), null, 2)}
+`
+  );
+}
+function printCompactJson(value) {
+  process.stdout.write(`${JSON.stringify(withAgentCommandContext(value))}
+`);
+}
+function errorToJsonPayload(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const maybeRecord = error && typeof error === "object" ? error : null;
+  const code = typeof maybeRecord?.code === "string" ? maybeRecord.code : error instanceof SyntaxError ? "INVALID_JSON" : "CLI_ERROR";
+  const details = {};
+  const exitCode = typeof maybeRecord?.exitCode === "number" ? maybeRecord.exitCode : void 0;
+  if (typeof maybeRecord?.statusCode === "number") {
+    details.statusCode = maybeRecord.statusCode;
+  }
+  if (typeof maybeRecord?.status === "number") {
+    details.status = maybeRecord.status;
+  }
+  if (typeof maybeRecord?.requestId === "string" || maybeRecord?.requestId === null) {
+    details.requestId = maybeRecord.requestId;
+  }
+  if (typeof maybeRecord?.retryable === "boolean") {
+    details.retryable = maybeRecord.retryable;
+  }
+  if (maybeRecord?.publicDetails && typeof maybeRecord.publicDetails === "object" && !Array.isArray(maybeRecord.publicDetails)) {
+    details.publicDetails = maybeRecord.publicDetails;
+  }
+  if (maybeRecord?.details && typeof maybeRecord.details === "object" && !Array.isArray(maybeRecord.details)) {
+    details.details = maybeRecord.details;
+  }
+  if (maybeRecord?.guidance && typeof maybeRecord.guidance === "object" && !Array.isArray(maybeRecord.guidance)) {
+    details.guidance = maybeRecord.guidance;
+  }
+  const providerConcurrency = providerConcurrencyDiagnostic(maybeRecord);
+  if (providerConcurrency) {
+    details.providerConcurrency = providerConcurrency;
+  }
+  if (typeof maybeRecord?.cause === "string") {
+    details.cause = maybeRecord.cause;
+  }
+  return {
+    ok: false,
+    ...exitCode !== void 0 ? { exitCode } : {},
+    error: {
+      message,
+      code,
+      ...Object.keys(details).length > 0 ? { details } : {}
+    }
+  };
+}
+function formatProviderConcurrencyDiagnostic(error) {
+  const value = error && typeof error === "object" ? error : null;
+  const diagnostic = providerConcurrencyDiagnostic(value);
+  if (!diagnostic) return null;
+  const count = diagnostic.inFlightProviderRequestsAt429;
+  const concurrency = count > 1 ? `${count - 1} other same-provider request${count === 2 ? "" : "s"} overlapped the failed request` : "no other same-provider request was active";
+  return `Provider concurrency at the 429: ${count} active request${count === 1 ? "" : "s"} in this Play execution, including the failed request; ${concurrency}. Other Play executions and direct CLI/API calls are not included.`;
+}
+function providerConcurrencyDiagnostic(value) {
+  if (!value || value.origin !== "provider" || value.statusCode !== 429 && value.status !== 429) {
+    return null;
+  }
+  const publicDetails = value.publicDetails;
+  if (!publicDetails || typeof publicDetails !== "object" || Array.isArray(publicDetails)) {
+    return null;
+  }
+  const details = publicDetails;
+  const count = details.inFlightProviderRequestsAt429;
+  if (details.providerConcurrencyScope !== "same_provider_in_play_execution" || details.includesFailedRequest !== true || typeof count !== "number" || !Number.isInteger(count) || count < 1) {
+    return null;
+  }
+  return {
+    scope: "same_provider_in_play_execution",
+    inFlightProviderRequestsAt429: count,
+    includesFailedRequest: true
+  };
+}
+function printJsonError(error) {
+  printJson(errorToJsonPayload(error));
+}
+function shouldEmitJson(explicitJson = false) {
+  return explicitJson || !process.stdout.isTTY;
+}
+function argsWantJson(args) {
+  return shouldEmitJson(args.includes("--json"));
+}
+function createTimestampedName(prefix, extension) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  return `${prefix}-${timestamp}.${extension}`;
+}
+function clip(value, maxLength) {
+  return value.length > maxLength ? `${value.slice(0, maxLength - 1)}\u2026` : value;
+}
+
+// src/cli/command-envelope.ts
+function renderSections(render) {
+  const lines = [];
+  for (const section of render?.sections ?? []) {
+    if (!section.title || section.lines.length === 0) continue;
+    lines.push(section.title);
+    lines.push(...section.lines.map((line) => `  ${line}`));
+  }
+  for (const action of render?.actions ?? []) {
+    if (!action.label || !action.command) continue;
+    lines.push(`${action.label}: ${action.command}`);
+  }
+  return lines;
+}
+function renderCommandEnvelopeText(envelope) {
+  const lines = renderSections(envelope.render);
+  if (lines.length > 0) {
+    return `${lines.join("\n")}
+`;
+  }
+  return `${JSON.stringify(envelope, null, 2)}
+`;
+}
+function printCommandEnvelope(envelope, options = {}) {
+  const jsonOutput = typeof options.json === "boolean" ? options.json : shouldEmitJson();
+  if (jsonOutput) {
+    printJson(envelope, options.fields);
+    return;
+  }
+  process.stdout.write(options.text ?? renderCommandEnvelopeText(envelope));
+}
+
+export {
+  parseJsonFields,
+  jsonFieldArgs,
+  describeArgs,
+  getAuthedHttpClient,
+  openInBrowser,
+  sleep,
+  collectLocalEnvInfo,
+  readCsvRows,
+  csvStringFromRows,
+  csvSafeJsonString,
+  recordRows,
+  dataExportRows,
+  dataExportColumns,
+  dataExportCsvString,
+  markdownTableFromRows,
+  printJson,
+  printCompactJson,
+  errorToJsonPayload,
+  formatProviderConcurrencyDiagnostic,
+  printJsonError,
+  shouldEmitJson,
+  argsWantJson,
+  createTimestampedName,
+  clip,
+  renderCommandEnvelopeText,
+  printCommandEnvelope
+};