deepline 0.3.409 → 0.3.410

package/dist/cli/chunk-5TUGWDEB.js

@@ -0,0 +1,313 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+var _chunkQJI5FIOWjs = require('./chunk-QJI5FIOW.js');
+
+
+var _chunkLTFL4JRNjs = require('./chunk-LTFL4JRN.js');
+
+
+
+var _chunkNF4V5DTYjs = require('./chunk-NF4V5DTY.js');
+
+
+
+var _chunkFVLNYDI4js = require('./chunk-FVLNYDI4.js');
+
+// src/cli/compatibility-catalog.ts
+var readers = /* @__PURE__ */ new WeakMap();
+function registerCompatibilityCatalog(command, read) {
+  readers.set(command, read);
+}
+function compatibilityCatalog(command) {
+  return _optionalChain([readers, 'access', _ => _.get, 'call', _2 => _2(command), 'optionalCall', _3 => _3()]);
+}
+
+// src/cli/self-update.ts
+var _child_process = require('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 (e) {
+    return null;
+  }
+}
+async function reportAutoUpdateEvent(input) {
+  let apiKey = "";
+  try {
+    apiKey = _chunkFVLNYDI4js.resolveApiKeyForBaseUrl.call(void 0, input.baseUrl);
+  } catch (e2) {
+    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/${_chunkFVLNYDI4js.SDK_VERSION}`,
+        "X-Deepline-Client-Family": "sdk",
+        "X-Deepline-CLI-Family": "sdk",
+        "X-Deepline-CLI-Version": _chunkFVLNYDI4js.SDK_VERSION,
+        "X-Deepline-SDK-Version": _chunkFVLNYDI4js.SDK_VERSION
+      },
+      body: JSON.stringify({
+        event: input.event,
+        current_version: _optionalChain([input, 'access', _4 => _4.response, 'access', _5 => _5.current, 'optionalAccess', _6 => _6.trim, 'call', _7 => _7()]) || _chunkFVLNYDI4js.SDK_VERSION,
+        target_version: input.response.latest,
+        reason: _optionalChain([input, 'access', _8 => _8.response, 'access', _9 => _9.auto_update, 'optionalAccess', _10 => _10.reason]),
+        command: _nullishCoalesce(input.response.command, () => ( null)),
+        install_kind: input.installKind,
+        ...input.exitCode === void 0 ? {} : { exit_code: input.exitCode }
+      }),
+      signal: controller.signal
+    });
+  } catch (e3) {
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function envTruthy(name) {
+  const value = _optionalChain([process, 'access', _11 => _11.env, 'access', _12 => _12[name], 'optionalAccess', _13 => _13.trim, 'call', _14 => _14(), 'access', _15 => _15.toLowerCase, 'call', _16 => _16()]);
+  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") || !_chunkQJI5FIOWjs.shouldRunCliAutoUpdate.call(void 0, ) || _chunkLTFL4JRNjs.isCiEnvironment.call(void 0, );
+}
+function isDowngradeAutoUpdateResponse(response) {
+  const target = _optionalChain([response, 'optionalAccess', _17 => _17.latest, 'optionalAccess', _18 => _18.trim, 'call', _19 => _19()]);
+  const current = _optionalChain([response, 'optionalAccess', _20 => _20.current, 'optionalAccess', _21 => _21.trim, 'call', _22 => _22()]) || _chunkFVLNYDI4js.SDK_VERSION;
+  if (!target) return false;
+  return _chunkQJI5FIOWjs.compareUpdateVersions.call(void 0, target, current) < 0;
+}
+function relaunchCurrentCommand(plan, runtime = {}) {
+  return new Promise((resolve) => {
+    const command = plan.kind === "python-sidecar" ? plan.sidecarPath : _nullishCoalesce(runtime.execPath, () => ( process.execPath));
+    const argv = _nullishCoalesce(runtime.argv, () => ( process.argv));
+    const args = plan.kind === "python-sidecar" ? argv.slice(2) : argv.slice(1);
+    const platform = _nullishCoalesce(runtime.platform, () => ( process.platform));
+    const child = _child_process.spawn.call(void 0, 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(_nullishCoalesce(code, () => ( 1))));
+  });
+}
+var deferredAutoUpdate = null;
+function hasDeferredAutoUpdate() {
+  return deferredAutoUpdate !== null;
+}
+async function runDeferredAutoUpdate() {
+  const apply = deferredAutoUpdate;
+  deferredAutoUpdate = null;
+  try {
+    await _optionalChain([apply, 'optionalCall', _23 => _23()]);
+  } 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 = _optionalChain([response, 'optionalAccess', _24 => _24.auto_update]);
+  if (!response || !_optionalChain([autoUpdate, 'optionalAccess', _25 => _25.should_auto_update]) || shouldSkipSelfUpdate(policy)) {
+    return false;
+  }
+  if (isDowngradeAutoUpdateResponse(response)) {
+    const target = response.latest;
+    const current = _optionalChain([response, 'access', _26 => _26.current, 'optionalAccess', _27 => _27.trim, 'call', _28 => _28()]) || _chunkFVLNYDI4js.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 = _chunkQJI5FIOWjs.resolveUpdatePlan.call(void 0, {
+    packageSpec,
+    requireVerifiedNpmOwnership: true,
+    npmFallbackRegistryUrl: trustedAutoUpdateRegistryUrl(baseUrl)
+  });
+  if (!_chunkQJI5FIOWjs.canAutomaticallyApplyUpdatePlan.call(void 0, plan)) {
+    return false;
+  }
+  if (!autoUpdate.required && autoUpdate.reason !== "rollback_forced") {
+    deferredAutoUpdate = async () => {
+      await applyAutoUpdate(response, baseUrl, plan, "next_command");
+    };
+    if (_chunkNF4V5DTYjs.isJsonOutputMode.call(void 0, )) {
+      const target = _optionalChain([response, 'access', _29 => _29.latest, 'optionalAccess', _30 => _30.trim, 'call', _31 => _31()]);
+      _chunkNF4V5DTYjs.addJsonNotice.call(void 0, {
+        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 (!_chunkQJI5FIOWjs.canAutomaticallyApplyUpdatePlan.call(void 0, plan)) return false;
+  const autoUpdate = response.auto_update;
+  const label = _optionalChain([autoUpdate, 'optionalAccess', _32 => _32.reason]) === "rollback_forced" ? "has a server rollback pending and needs the latest rollback-aware CLI" : _optionalChain([autoUpdate, 'optionalAccess', _33 => _33.reason]) === "deprecated" ? "is deprecated and will update automatically" : _optionalChain([autoUpdate, 'optionalAccess', _34 => _34.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 _chunkQJI5FIOWjs.runAutomaticUpdatePlan.call(void 0, 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 (_optionalChain([autoUpdate, 'optionalAccess', _35 => _35.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 ${_nullishCoalesce(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
+var _crypto = require('crypto');
+var TOOL_EXECUTE_PROGRESS_INTERVAL_MS = 15e3;
+var activeToolExecuteCommand = null;
+function progressLine(line) {
+  if (!_chunkNF4V5DTYjs.isJsonOutputMode.call(void 0, )) console.error(line);
+}
+function beginToolExecuteCommand() {
+  if (activeToolExecuteCommand) return activeToolExecuteCommand.invocationId;
+  const invocationId = _crypto.randomUUID.call(void 0, );
+  activeToolExecuteCommand = {
+    invocationId,
+    startedAt: performance.now()
+  };
+  progressLine(`[tools execute ${invocationId}] started`);
+  return invocationId;
+}
+function getToolExecuteInvocationId() {
+  return _nullishCoalesce(_optionalChain([activeToolExecuteCommand, 'optionalAccess', _36 => _36.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);
+  _optionalChain([progressTimer, 'access', _37 => _37.unref, 'optionalCall', _38 => _38()]);
+  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;
+}
+
+
+
+
+
+
+
+
+
+
+
+exports.registerCompatibilityCatalog = registerCompatibilityCatalog; exports.compatibilityCatalog = compatibilityCatalog; exports.hasDeferredAutoUpdate = hasDeferredAutoUpdate; exports.runDeferredAutoUpdate = runDeferredAutoUpdate; exports.maybeAutoUpdateAndRelaunch = maybeAutoUpdateAndRelaunch; exports.beginToolExecuteCommand = beginToolExecuteCommand; exports.getToolExecuteInvocationId = getToolExecuteInvocationId; exports.runToolExecuteStage = runToolExecuteStage; exports.finishToolExecuteCommand = finishToolExecuteCommand;

package/dist/cli/{chunk-DEC3JECC.js → chunk-5UUQAGJS.js}

@@ -49,8 +49,11 @@ var SDK_RELEASE = {
   // getters keep their established compatibility behavior.
   // 0.3.1 deprecated the legacy `deepline enrich` command in favor of Plays.
   // 0.3.90 is the first deliberately versioned SDK release for API v3.
-  version: "0.3.409",
-  updateSummary: "Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release.",
+  version: "0.3.410",
+  updateSummary: {
+    introducedIn: "0.3.90",
+    summary: "Play grep now returns concise results with the matched fields and terms. Automatic CLI updates are enabled by default; use `deepline settings autoupdate off` to opt out, `deepline settings autoupdate on` to re-enable updates, or `deepline settings autoupdate pin <version>` to hold an exact release."
+  },
   packageCapabilities: {
     updatePreferences: 1,
     skillsGuidance: 1

package/dist/cli/{chunk-JRAVVJ3T.mjs → chunk-5V5Y37BC.mjs}

@@ -3,11 +3,11 @@ import {
   detectAgentRuntime,
   resolveCliCommandContext,
   resolveConfig
-} from "./chunk-2PRO2JTX.mjs";
+} from "./chunk-RFB25DSQ.mjs";
 import {
   DeeplineError,
   serializeToolExecutionFailure
-} from "./chunk-NXGCO4JB.mjs";
+} from "./chunk-E4IXDAZI.mjs";
 
 // src/cli/json-fields.ts
 var RUN_FIELDS = new Set(

package/dist/cli/{chunk-PMVFAYL7.mjs → chunk-63ILLN5H.mjs}

@@ -3,7 +3,7 @@ import {
   formatModelDescription,
   publicToolSchemas,
   toolMetadataJsonForDescribe
-} from "./chunk-BZAMOCPA.mjs";
+} from "./chunk-IMZ56EOH.mjs";
 import {
   buildPlayDashboardUrl,
   byokLines,
@@ -16,7 +16,7 @@ import {
 } from "./chunk-IHG7UAHD.mjs";
 import {
   DeeplineError
-} from "./chunk-NXGCO4JB.mjs";
+} from "./chunk-E4IXDAZI.mjs";
 
 // src/cli/tool-features.ts
 var VIEWS = {