deepline 0.3.408 → 0.3.410

package/dist/cli/{chunk-GSK6NHVM.js → chunk-WU4U6VSB.js}

@@ -1,6 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
 
-var _chunk7P5AA3SNjs = require('./chunk-7P5AA3SN.js');
+var _chunkPPDBRJRWjs = require('./chunk-PPDBRJRW.js');
 
 // node_modules/csv-parse/dist/esm/sync.js
 var global$1 = typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {};
@@ -3000,7 +3000,7 @@ function parseCsvDataInput(source, content, options = {}) {
       } : {}
     });
   } catch (error) {
-    throw new (0, _chunk7P5AA3SNjs.DeeplineError)(
+    throw new (0, _chunkPPDBRJRWjs.DeeplineError)(
       `Input ${source.inputPath} could not be parsed as CSV (${source.value}): ${error instanceof Error ? error.message : String(error)}. This usually means an unclosed quote or ragged quoting. No run was created.`,
       void 0,
       "PLAY_INPUT_FILE_PREFLIGHT",
@@ -3008,7 +3008,7 @@ function parseCsvDataInput(source, content, options = {}) {
     );
   }
   if (records.length === 0) {
-    throw new (0, _chunk7P5AA3SNjs.DeeplineError)(
+    throw new (0, _chunkPPDBRJRWjs.DeeplineError)(
       `${source.value} is empty: it has no header row and no data rows. No run was created.`,
       void 0,
       "PLAY_INPUT_FILE_PREFLIGHT",
@@ -3023,7 +3023,7 @@ function parseCsvDataInput(source, content, options = {}) {
     if (name.length === 0) continue;
     const prior = seen.get(name);
     if (prior) {
-      throw new (0, _chunk7P5AA3SNjs.DeeplineError)(
+      throw new (0, _chunkPPDBRJRWjs.DeeplineError)(
         `Input ${source.inputPath} (${source.value}) has a duplicate CSV header "${name}" (columns ${prior.index + 1} and ${i + 1}). The second column would silently overwrite the first. Rename one of them. No run was created.`,
         void 0,
         "PLAY_INPUT_FILE_PREFLIGHT",
@@ -3039,7 +3039,7 @@ function parseCsvDataInput(source, content, options = {}) {
     seen.set(name, { index: i, raw });
   }
   if (records.length - 1 < 1) {
-    throw new (0, _chunk7P5AA3SNjs.DeeplineError)(
+    throw new (0, _chunkPPDBRJRWjs.DeeplineError)(
       `${source.value} has a header row but no data rows. No run was created.`,
       void 0,
       "PLAY_INPUT_FILE_PREFLIGHT",

package/dist/cli/chunk-XHLKJOTN.mjs

@@ -0,0 +1,313 @@
+import {
+  canAutomaticallyApplyUpdatePlan,
+  compareUpdateVersions,
+  resolveUpdatePlan,
+  runAutomaticUpdatePlan,
+  shouldRunCliAutoUpdate
+} from "./chunk-QL22Y56M.mjs";
+import {
+  isCiEnvironment
+} from "./chunk-XIHWSXSV.mjs";
+import {
+  addJsonNotice,
+  isJsonOutputMode
+} from "./chunk-5V5Y37BC.mjs";
+import {
+  SDK_VERSION,
+  resolveApiKeyForBaseUrl
+} from "./chunk-RFB25DSQ.mjs";
+
+// src/cli/compatibility-catalog.ts
+var readers = /* @__PURE__ */ new WeakMap();
+function registerCompatibilityCatalog(command, read) {
+  readers.set(command, read);
+}
+function compatibilityCatalog(command) {
+  return readers.get(command)?.();
+}
+
+// src/cli/self-update.ts
+import { spawn } from "child_process";
+var AUTO_UPDATE_TELEMETRY_TIMEOUT_MS = 2e3;
+var TRUSTED_AUTO_UPDATE_ORIGIN = "https://code.deepline.com";
+function trustedAutoUpdateRegistryUrl(baseUrl) {
+  try {
+    const url = new URL(baseUrl);
+    if (url.origin !== TRUSTED_AUTO_UPDATE_ORIGIN) return null;
+    return new URL("/api/v2/npm/", url.origin).toString();
+  } catch {
+    return null;
+  }
+}
+async function reportAutoUpdateEvent(input) {
+  let apiKey = "";
+  try {
+    apiKey = resolveApiKeyForBaseUrl(input.baseUrl);
+  } catch {
+    return;
+  }
+  if (!apiKey) return;
+  const controller = new AbortController();
+  const timeout = setTimeout(
+    () => controller.abort(),
+    AUTO_UPDATE_TELEMETRY_TIMEOUT_MS
+  );
+  try {
+    await fetch(new URL("/api/v2/telemetry/auto-update", input.baseUrl), {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+        "User-Agent": `deepline-ts-sdk/${SDK_VERSION}`,
+        "X-Deepline-Client-Family": "sdk",
+        "X-Deepline-CLI-Family": "sdk",
+        "X-Deepline-CLI-Version": SDK_VERSION,
+        "X-Deepline-SDK-Version": SDK_VERSION
+      },
+      body: JSON.stringify({
+        event: input.event,
+        current_version: input.response.current?.trim() || SDK_VERSION,
+        target_version: input.response.latest,
+        reason: input.response.auto_update?.reason,
+        command: input.response.command ?? null,
+        install_kind: input.installKind,
+        ...input.exitCode === void 0 ? {} : { exit_code: input.exitCode }
+      }),
+      signal: controller.signal
+    });
+  } catch {
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function envTruthy(name) {
+  const value = process.env[name]?.trim().toLowerCase();
+  return value === "1" || value === "true" || value === "yes";
+}
+function shouldSkipSelfUpdate(policy) {
+  return policy === "off" || envTruthy("DEEPLINE_SKIP_SELF_UPDATE") || envTruthy("DEEPLINE_NO_AUTO_UPDATE") || envTruthy("DEEPLINE_SKIP_SDK_AUTO_UPDATE") || envTruthy("DEEPLINE_DISABLE_AUTO_UPDATE") || !shouldRunCliAutoUpdate() || isCiEnvironment();
+}
+function isDowngradeAutoUpdateResponse(response) {
+  const target = response?.latest?.trim();
+  const current = response?.current?.trim() || SDK_VERSION;
+  if (!target) return false;
+  return compareUpdateVersions(target, current) < 0;
+}
+function relaunchCurrentCommand(plan, runtime = {}) {
+  return new Promise((resolve) => {
+    const command = plan.kind === "python-sidecar" ? plan.sidecarPath : runtime.execPath ?? process.execPath;
+    const argv = runtime.argv ?? process.argv;
+    const args = plan.kind === "python-sidecar" ? argv.slice(2) : argv.slice(1);
+    const platform = runtime.platform ?? process.platform;
+    const child = spawn(command, args, {
+      stdio: "inherit",
+      // The Node executable is a native binary and must be spawned directly;
+      // passing `C:\Program Files\...\node.exe` through cmd.exe splits it
+      // at the first space. The Python-sidecar launcher is a `.cmd` file on
+      // Windows and still needs the shell dispatch it has always used.
+      shell: plan.kind === "python-sidecar" && platform === "win32",
+      env: {
+        ...process.env,
+        DEEPLINE_NO_AUTO_UPDATE: "1"
+      }
+    });
+    child.on("error", (error) => {
+      process.stderr.write(
+        `Deepline SDK/CLI updated, but relaunch failed: ${error.message}
+`
+      );
+      resolve(1);
+    });
+    child.on("close", (code) => resolve(code ?? 1));
+  });
+}
+var deferredAutoUpdate = null;
+function hasDeferredAutoUpdate() {
+  return deferredAutoUpdate !== null;
+}
+async function runDeferredAutoUpdate() {
+  const apply = deferredAutoUpdate;
+  deferredAutoUpdate = null;
+  try {
+    await apply?.();
+  } catch (error) {
+    process.stderr.write(
+      `Deepline SDK/CLI auto-update failed: ${error instanceof Error ? error.message : String(error)}
+`
+    );
+  }
+}
+async function maybeAutoUpdateAndRelaunch(response, baseUrl, policy = "configured") {
+  const autoUpdate = response?.auto_update;
+  if (!response || !autoUpdate?.should_auto_update || shouldSkipSelfUpdate(policy)) {
+    return false;
+  }
+  if (isDowngradeAutoUpdateResponse(response)) {
+    const target = response.latest;
+    const current = response.current?.trim() || SDK_VERSION;
+    process.stderr.write(
+      `Deepline SDK/CLI auto-update refused: server advertised older ${target} than current ${current}. Continuing without mutating the CLI.
+`
+    );
+    return false;
+  }
+  const packageSpec = response.latest ? `deepline@${response.latest}` : void 0;
+  const plan = resolveUpdatePlan({
+    packageSpec,
+    requireVerifiedNpmOwnership: true,
+    npmFallbackRegistryUrl: trustedAutoUpdateRegistryUrl(baseUrl)
+  });
+  if (!canAutomaticallyApplyUpdatePlan(plan)) {
+    return false;
+  }
+  if (!autoUpdate.required && autoUpdate.reason !== "rollback_forced") {
+    deferredAutoUpdate = async () => {
+      await applyAutoUpdate(response, baseUrl, plan, "next_command");
+    };
+    if (isJsonOutputMode()) {
+      const target = response.latest?.trim();
+      addJsonNotice({
+        code: "sdk_update_queued",
+        message: `Deepline SDK/CLI update${target ? ` to ${target}` : ""} is queued after this command; the next command will use it if installation succeeds.`
+      });
+    }
+    return false;
+  }
+  if (!await applyAutoUpdate(response, baseUrl, plan, "rerun")) return false;
+  const exitCode = await relaunchCurrentCommand(plan);
+  process.exit(exitCode);
+  return true;
+}
+async function applyAutoUpdate(response, baseUrl, plan, takesEffect) {
+  if (!canAutomaticallyApplyUpdatePlan(plan)) return false;
+  const autoUpdate = response.auto_update;
+  const label = autoUpdate?.reason === "rollback_forced" ? "has a server rollback pending and needs the latest rollback-aware CLI" : autoUpdate?.reason === "deprecated" ? "is deprecated and will update automatically" : autoUpdate?.required ? "requires an update" : "has an update available and will update automatically";
+  process.stderr.write(
+    `Deepline SDK/CLI ${label}; running ${plan.manualCommand}
+`
+  );
+  void reportAutoUpdateEvent({
+    baseUrl,
+    response,
+    event: "started",
+    installKind: plan.kind
+  });
+  const updateResult = await runAutomaticUpdatePlan(plan);
+  if (updateResult.status === "skipped_previous_failure") {
+    void reportAutoUpdateEvent({
+      baseUrl,
+      response,
+      event: "skipped_previous_failure",
+      installKind: plan.kind,
+      exitCode: updateResult.exitCode
+    });
+    return false;
+  }
+  if (updateResult.exitCode !== 0) {
+    void reportAutoUpdateEvent({
+      baseUrl,
+      response,
+      event: "failed",
+      installKind: plan.kind,
+      exitCode: updateResult.exitCode
+    });
+    if (autoUpdate?.required) {
+      throw new Error(
+        `Automatic Deepline SDK/CLI update failed with exit code ${updateResult.exitCode}. ${response.message}`
+      );
+    }
+    process.stderr.write(
+      `Deepline SDK/CLI auto-update failed with exit code ${updateResult.exitCode}; continuing with ${response.current ?? "current version"}.
+`
+    );
+    return false;
+  }
+  void reportAutoUpdateEvent({
+    baseUrl,
+    response,
+    event: "succeeded",
+    installKind: plan.kind,
+    exitCode: 0
+  });
+  const updateSummary = response.update_summary ? `
+What changed in ${response.update_summary.version}: ${response.update_summary.summary}` : "";
+  process.stderr.write(
+    `${takesEffect === "rerun" ? "Deepline SDK/CLI updated; rerunning command." : `Deepline SDK/CLI updated to ${response.latest}; the next command uses it.`}${updateSummary}
+`
+  );
+  return true;
+}
+
+// src/cli/tool-execute-observability.ts
+import { randomUUID } from "crypto";
+var TOOL_EXECUTE_PROGRESS_INTERVAL_MS = 15e3;
+var activeToolExecuteCommand = null;
+function progressLine(line) {
+  if (!isJsonOutputMode()) console.error(line);
+}
+function beginToolExecuteCommand() {
+  if (activeToolExecuteCommand) return activeToolExecuteCommand.invocationId;
+  const invocationId = randomUUID();
+  activeToolExecuteCommand = {
+    invocationId,
+    startedAt: performance.now()
+  };
+  progressLine(`[tools execute ${invocationId}] started`);
+  return invocationId;
+}
+function getToolExecuteInvocationId() {
+  return activeToolExecuteCommand?.invocationId ?? null;
+}
+async function runToolExecuteStage(stage, action) {
+  const command = activeToolExecuteCommand;
+  if (!command) return action();
+  const startedAt = performance.now();
+  const elapsedMs = () => Math.round(performance.now() - startedAt);
+  progressLine(`[tools execute ${command.invocationId}] ${stage} started`);
+  const progressTimer = setInterval(() => {
+    progressLine(
+      `[tools execute ${command.invocationId}] ${stage} still running (${elapsedMs()}ms)`
+    );
+  }, TOOL_EXECUTE_PROGRESS_INTERVAL_MS);
+  progressTimer.unref?.();
+  try {
+    const result = await action();
+    if (result === false) {
+      progressLine(
+        `[tools execute ${command.invocationId}] ${stage} failed after ${elapsedMs()}ms`
+      );
+    } else {
+      progressLine(
+        `[tools execute ${command.invocationId}] ${stage} completed in ${elapsedMs()}ms`
+      );
+    }
+    return result;
+  } catch (error) {
+    progressLine(
+      `[tools execute ${command.invocationId}] ${stage} failed after ${elapsedMs()}ms`
+    );
+    throw error;
+  } finally {
+    clearInterval(progressTimer);
+  }
+}
+function finishToolExecuteCommand() {
+  const command = activeToolExecuteCommand;
+  if (!command) return;
+  progressLine(
+    `[tools execute ${command.invocationId}] finished in ${Math.round(performance.now() - command.startedAt)}ms`
+  );
+  activeToolExecuteCommand = null;
+}
+
+export {
+  registerCompatibilityCatalog,
+  compatibilityCatalog,
+  hasDeferredAutoUpdate,
+  runDeferredAutoUpdate,
+  maybeAutoUpdateAndRelaunch,
+  beginToolExecuteCommand,
+  getToolExecuteInvocationId,
+  runToolExecuteStage,
+  finishToolExecuteCommand
+};