claude-code-best 1.0.3

package/dist/chunk-daeav7vb.js

@@ -0,0 +1,418 @@
+// @bun
+import {
+  init_sideQuestion,
+  runSideQuestion
+} from "./chunk-rq1kckze.js";
+import {
+  ScrollBox_default,
+  init_ScrollBox
+} from "./chunk-jjsx6t78.js";
+import {
+  Markdown,
+  SpinnerGlyph,
+  asSystemPrompt,
+  createAbortController,
+  getLastCacheSafeParams,
+  getMessagesAfterCompactBoundary,
+  getSystemContext,
+  getSystemPrompt,
+  getUserContext,
+  init_Markdown,
+  init_SpinnerGlyph,
+  init_abortController,
+  init_context,
+  init_forkedAgent,
+  init_messages1 as init_messages,
+  init_prompts1 as init_prompts,
+  init_systemPromptType
+} from "./chunk-g9q2cznf.js";
+import"./chunk-q1e6pzwh.js";
+import"./chunk-201dvaa3.js";
+import"./chunk-248szg6m.js";
+import"./chunk-t0rgmccj.js";
+import"./chunk-def1dc97.js";
+import"./chunk-9egdc8n4.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-b0105v1f.js";
+import"./chunk-hgtf13es.js";
+import"./chunk-3be7ka25.js";
+import"./chunk-rcdpvnxh.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-45kxdsp8.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-madfgr3n.js";
+import"./chunk-pmzbyaat.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-ha0xq3e9.js";
+import"./chunk-hfzj1m07.js";
+import {
+  init_modalContext,
+  init_useTerminalSize,
+  useModalOrTerminalSize,
+  useTerminalSize
+} from "./chunk-pvvew193.js";
+import {
+  ThemedBox_default,
+  ThemedText,
+  init_dist,
+  init_ink,
+  require_compiler_runtime,
+  useInterval
+} from "./chunk-8d5eyjse.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-g338npwr.js";
+import"./chunk-2v1br2x0.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-zkmxtgc3.js";
+import"./chunk-m06q12hg.js";
+import"./chunk-grdvmq7q.js";
+import {
+  DOWN_ARROW,
+  UP_ARROW,
+  init_config1 as init_config,
+  init_figures,
+  saveGlobalConfig
+} from "./chunk-7wm1rjfm.js";
+import"./chunk-e3g8q4cn.js";
+import"./chunk-ctw5jwcd.js";
+import"./chunk-vratq94g.js";
+import"./chunk-5hva0tsg.js";
+import"./chunk-0e1xsncc.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-tjaqa99q.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-spqaamnc.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-w2z5pqd3.js";
+import"./chunk-7ymfj7m3.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-cvge4pvp.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-x14dq3v1.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-h0rbjg6x.js";
+import"./chunk-7z8j9qfn.js";
+import"./chunk-hrzerbfw.js";
+import"./chunk-d18z9pna.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-hjhc4cpt.js";
+import"./chunk-vyc0rjyx.js";
+import"./chunk-hx2tr4ep.js";
+import"./chunk-p7g7pf3f.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import {
+  errorMessage,
+  init_errors
+} from "./chunk-nxsh6de2.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-3r24h7t6.js";
+import"./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/btw/btw.tsx
+function BtwSideQuestion(t0) {
+  const $ = import_compiler_runtime.c(25);
+  const {
+    question,
+    context,
+    onDone
+  } = t0;
+  const [response, setResponse] = import_react.useState(null);
+  const [error, setError] = import_react.useState(null);
+  const [frame, setFrame] = import_react.useState(0);
+  const scrollRef = import_react.useRef(null);
+  const {
+    rows
+  } = useModalOrTerminalSize(useTerminalSize());
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = () => setFrame(_temp);
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  useInterval(t1, response || error ? null : 80);
+  let t2;
+  if ($[1] !== onDone) {
+    t2 = function handleKeyDown2(e) {
+      if (e.key === "escape" || e.key === "return" || e.key === " " || e.ctrl && (e.key === "c" || e.key === "d")) {
+        e.preventDefault();
+        onDone(undefined, {
+          display: "skip"
+        });
+        return;
+      }
+      if (e.key === "up" || e.ctrl && e.key === "p") {
+        e.preventDefault();
+        scrollRef.current?.scrollBy(-SCROLL_LINES);
+      }
+      if (e.key === "down" || e.ctrl && e.key === "n") {
+        e.preventDefault();
+        scrollRef.current?.scrollBy(SCROLL_LINES);
+      }
+    };
+    $[1] = onDone;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  const handleKeyDown = t2;
+  let t3;
+  let t4;
+  if ($[3] !== context || $[4] !== question) {
+    t3 = () => {
+      const abortController = createAbortController();
+      const fetchResponse = async function fetchResponse2() {
+        try {
+          const cacheSafeParams = await buildCacheSafeParams(context);
+          const result = await runSideQuestion({
+            question,
+            cacheSafeParams
+          });
+          if (!abortController.signal.aborted) {
+            if (result.response) {
+              setResponse(result.response);
+            } else {
+              setError("No response received");
+            }
+          }
+        } catch (t52) {
+          const err = t52;
+          if (!abortController.signal.aborted) {
+            setError(errorMessage(err) || "Failed to get response");
+          }
+        }
+      };
+      fetchResponse();
+      return () => {
+        abortController.abort();
+      };
+    };
+    t4 = [question, context];
+    $[3] = context;
+    $[4] = question;
+    $[5] = t3;
+    $[6] = t4;
+  } else {
+    t3 = $[5];
+    t4 = $[6];
+  }
+  import_react.useEffect(t3, t4);
+  const maxContentHeight = Math.max(5, rows - CHROME_ROWS - OUTER_CHROME_ROWS);
+  let t5;
+  if ($[7] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      color: "warning",
+      bold: true,
+      children: [
+        "/btw",
+        " "
+      ]
+    }, undefined, true, undefined, this);
+    $[7] = t5;
+  } else {
+    t5 = $[7];
+  }
+  let t6;
+  if ($[8] !== question) {
+    t6 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+      children: [
+        t5,
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          dimColor: true,
+          children: question
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+    $[8] = question;
+    $[9] = t6;
+  } else {
+    t6 = $[9];
+  }
+  let t7;
+  if ($[10] !== error || $[11] !== frame || $[12] !== response) {
+    t7 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ScrollBox_default, {
+      ref: scrollRef,
+      flexDirection: "column",
+      flexGrow: 1,
+      children: error ? /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+        color: "error",
+        children: error
+      }, undefined, false, undefined, this) : response ? /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Markdown, {
+        children: response
+      }, undefined, false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+        children: [
+          /* @__PURE__ */ jsx_dev_runtime.jsxDEV(SpinnerGlyph, {
+            frame,
+            messageColor: "warning"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+            color: "warning",
+            children: "Answering..."
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    }, undefined, false, undefined, this);
+    $[10] = error;
+    $[11] = frame;
+    $[12] = response;
+    $[13] = t7;
+  } else {
+    t7 = $[13];
+  }
+  let t8;
+  if ($[14] !== maxContentHeight || $[15] !== t7) {
+    t8 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+      marginTop: 1,
+      marginLeft: 2,
+      maxHeight: maxContentHeight,
+      children: t7
+    }, undefined, false, undefined, this);
+    $[14] = maxContentHeight;
+    $[15] = t7;
+    $[16] = t8;
+  } else {
+    t8 = $[16];
+  }
+  let t9;
+  if ($[17] !== error || $[18] !== response) {
+    t9 = (response || error) && /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+      marginTop: 1,
+      children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+        dimColor: true,
+        children: [
+          UP_ARROW,
+          "/",
+          DOWN_ARROW,
+          " to scroll \xB7 Space, Enter, or Escape to dismiss"
+        ]
+      }, undefined, true, undefined, this)
+    }, undefined, false, undefined, this);
+    $[17] = error;
+    $[18] = response;
+    $[19] = t9;
+  } else {
+    t9 = $[19];
+  }
+  let t10;
+  if ($[20] !== handleKeyDown || $[21] !== t6 || $[22] !== t8 || $[23] !== t9) {
+    t10 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+      flexDirection: "column",
+      paddingLeft: 2,
+      marginTop: 1,
+      tabIndex: 0,
+      autoFocus: true,
+      onKeyDown: handleKeyDown,
+      children: [
+        t6,
+        t8,
+        t9
+      ]
+    }, undefined, true, undefined, this);
+    $[20] = handleKeyDown;
+    $[21] = t6;
+    $[22] = t8;
+    $[23] = t9;
+    $[24] = t10;
+  } else {
+    t10 = $[24];
+  }
+  return t10;
+}
+function _temp(f) {
+  return f + 1;
+}
+function stripInProgressAssistantMessage(messages) {
+  const last = messages.at(-1);
+  if (last?.type === "assistant" && last.message.stop_reason === null) {
+    return messages.slice(0, -1);
+  }
+  return messages;
+}
+async function buildCacheSafeParams(context) {
+  const forkContextMessages = getMessagesAfterCompactBoundary(stripInProgressAssistantMessage(context.messages));
+  const saved = getLastCacheSafeParams();
+  if (saved) {
+    return {
+      systemPrompt: saved.systemPrompt,
+      userContext: saved.userContext,
+      systemContext: saved.systemContext,
+      toolUseContext: context,
+      forkContextMessages
+    };
+  }
+  const [rawSystemPrompt, userContext, systemContext] = await Promise.all([getSystemPrompt(context.options.tools, context.options.mainLoopModel, [], context.options.mcpClients), getUserContext(), getSystemContext()]);
+  return {
+    systemPrompt: asSystemPrompt(rawSystemPrompt),
+    userContext,
+    systemContext,
+    toolUseContext: context,
+    forkContextMessages
+  };
+}
+async function call(onDone, context, args) {
+  const question = args?.trim();
+  if (!question) {
+    onDone("Usage: /btw <your question>", {
+      display: "system"
+    });
+    return null;
+  }
+  saveGlobalConfig((current) => ({
+    ...current,
+    btwUseCount: current.btwUseCount + 1
+  }));
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(BtwSideQuestion, {
+    question,
+    context,
+    onDone
+  }, undefined, false, undefined, this);
+}
+var import_compiler_runtime, import_react, jsx_dev_runtime, CHROME_ROWS = 5, OUTER_CHROME_ROWS = 6, SCROLL_LINES = 3;
+var init_btw = __esm(() => {
+  init_dist();
+  init_Markdown();
+  init_SpinnerGlyph();
+  init_figures();
+  init_prompts();
+  init_modalContext();
+  init_context();
+  init_useTerminalSize();
+  init_ScrollBox();
+  init_ink();
+  init_abortController();
+  init_config();
+  init_errors();
+  init_forkedAgent();
+  init_messages();
+  init_sideQuestion();
+  init_systemPromptType();
+  import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
+  import_react = __toESM(require_react(), 1);
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+init_btw();
+
+export {
+  call
+};

package/dist/chunk-dd60e5wj.js

@@ -0,0 +1,41 @@
+// @bun
+import {
+  require_src as require_src3
+} from "./chunk-8c32awe2.js";
+import {
+  require_src,
+  require_src1 as require_src2
+} from "./chunk-90wp6wez.js";
+import"./chunk-a8ejc632.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-p2816w9z.js";
+import {
+  __commonJS
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@opentelemetry+exporter-logs-otlp-grpc@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-logs-otlp-grpc/build/src/OTLPLogExporter.js
+var require_OTLPLogExporter = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.OTLPLogExporter = undefined;
+  var otlp_grpc_exporter_base_1 = require_src3();
+  var otlp_transformer_1 = require_src2();
+  var otlp_exporter_base_1 = require_src();
+
+  class OTLPLogExporter extends otlp_exporter_base_1.OTLPExporterBase {
+    constructor(config = {}) {
+      super((0, otlp_grpc_exporter_base_1.createOtlpGrpcExportDelegate)((0, otlp_grpc_exporter_base_1.convertLegacyOtlpGrpcOptions)(config, "LOGS"), otlp_transformer_1.ProtobufLogsSerializer, "LogsExportService", "/opentelemetry.proto.collector.logs.v1.LogsService/Export"));
+    }
+  }
+  exports.OTLPLogExporter = OTLPLogExporter;
+});
+
+// node_modules/.bun/@opentelemetry+exporter-logs-otlp-grpc@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-logs-otlp-grpc/build/src/index.js
+var require_src4 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.OTLPLogExporter = undefined;
+  var OTLPLogExporter_1 = require_OTLPLogExporter();
+  Object.defineProperty(exports, "OTLPLogExporter", { enumerable: true, get: function() {
+    return OTLPLogExporter_1.OTLPLogExporter;
+  } });
+});
+export default require_src4();

package/dist/chunk-def1dc97.js

@@ -0,0 +1,154 @@
+// @bun
+import {
+  checkGate_CACHED_OR_BLOCKING,
+  exports_auth,
+  getFeatureValue_CACHED_MAY_BE_STALE,
+  getSecureStorage,
+  init_auth,
+  init_growthbook,
+  init_secureStorage
+} from "./chunk-7wm1rjfm.js";
+import {
+  getOauthConfig,
+  init_oauth
+} from "./chunk-7ymfj7m3.js";
+import {
+  init_privacyLevel,
+  isEssentialTrafficOnly
+} from "./chunk-p7g7pf3f.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  init_slowOperations,
+  jsonStringify,
+  logForDebugging
+} from "./chunk-nxsh6de2.js";
+import {
+  init_memoize,
+  memoize_default
+} from "./chunk-hqmz36b3.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-xszk7n10.js";
+import {
+  __esm,
+  __toCommonJS
+} from "./chunk-qp2qdcda.js";
+
+// src/bridge/trustedDevice.ts
+import { hostname } from "os";
+function isGateEnabled() {
+  return getFeatureValue_CACHED_MAY_BE_STALE(TRUSTED_DEVICE_GATE, false);
+}
+function getTrustedDeviceToken() {
+  if (!isGateEnabled()) {
+    return;
+  }
+  return readStoredToken();
+}
+function clearTrustedDeviceTokenCache() {
+  readStoredToken.cache?.clear?.();
+}
+function clearTrustedDeviceToken() {
+  if (!isGateEnabled()) {
+    return;
+  }
+  const secureStorage = getSecureStorage();
+  try {
+    const data = secureStorage.read();
+    if (data?.trustedDeviceToken) {
+      delete data.trustedDeviceToken;
+      secureStorage.update(data);
+    }
+  } catch {}
+  readStoredToken.cache?.clear?.();
+}
+async function enrollTrustedDevice() {
+  try {
+    if (!await checkGate_CACHED_OR_BLOCKING(TRUSTED_DEVICE_GATE)) {
+      logForDebugging(`[trusted-device] Gate ${TRUSTED_DEVICE_GATE} is off, skipping enrollment`);
+      return;
+    }
+    if (process.env.CLAUDE_TRUSTED_DEVICE_TOKEN) {
+      logForDebugging("[trusted-device] CLAUDE_TRUSTED_DEVICE_TOKEN env var is set, skipping enrollment (env var takes precedence)");
+      return;
+    }
+    const { getClaudeAIOAuthTokens } = (init_auth(), __toCommonJS(exports_auth));
+    const accessToken = getClaudeAIOAuthTokens()?.accessToken;
+    if (!accessToken) {
+      logForDebugging("[trusted-device] No OAuth token, skipping enrollment");
+      return;
+    }
+    const secureStorage = getSecureStorage();
+    if (isEssentialTrafficOnly()) {
+      logForDebugging("[trusted-device] Essential traffic only, skipping enrollment");
+      return;
+    }
+    const baseUrl = getOauthConfig().BASE_API_URL;
+    let response;
+    try {
+      response = await axios_default.post(`${baseUrl}/api/auth/trusted_devices`, { display_name: `Claude Code on ${hostname()} \xB7 ${process.platform}` }, {
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        timeout: 1e4,
+        validateStatus: (s) => s < 500
+      });
+    } catch (err) {
+      logForDebugging(`[trusted-device] Enrollment request failed: ${errorMessage(err)}`);
+      return;
+    }
+    if (response.status !== 200 && response.status !== 201) {
+      logForDebugging(`[trusted-device] Enrollment failed ${response.status}: ${jsonStringify(response.data).slice(0, 200)}`);
+      return;
+    }
+    const token = response.data?.device_token;
+    if (!token || typeof token !== "string") {
+      logForDebugging("[trusted-device] Enrollment response missing device_token field");
+      return;
+    }
+    try {
+      const storageData = secureStorage.read();
+      if (!storageData) {
+        logForDebugging("[trusted-device] Cannot read storage, skipping token persist");
+        return;
+      }
+      storageData.trustedDeviceToken = token;
+      const result = secureStorage.update(storageData);
+      if (!result.success) {
+        logForDebugging(`[trusted-device] Failed to persist token: ${result.warning ?? "unknown"}`);
+        return;
+      }
+      readStoredToken.cache?.clear?.();
+      logForDebugging(`[trusted-device] Enrolled device_id=${response.data.device_id ?? "unknown"}`);
+    } catch (err) {
+      logForDebugging(`[trusted-device] Storage write failed: ${errorMessage(err)}`);
+    }
+  } catch (err) {
+    logForDebugging(`[trusted-device] Enrollment error: ${errorMessage(err)}`);
+  }
+}
+var TRUSTED_DEVICE_GATE = "tengu_sessions_elevated_auth_enforcement", readStoredToken;
+var init_trustedDevice = __esm(() => {
+  init_axios();
+  init_memoize();
+  init_oauth();
+  init_growthbook();
+  init_debug();
+  init_errors();
+  init_privacyLevel();
+  init_secureStorage();
+  init_slowOperations();
+  readStoredToken = memoize_default(() => {
+    const envToken = process.env.CLAUDE_TRUSTED_DEVICE_TOKEN;
+    if (envToken) {
+      return envToken;
+    }
+    return getSecureStorage().read()?.trustedDeviceToken;
+  });
+});
+
+export { getTrustedDeviceToken, clearTrustedDeviceTokenCache, clearTrustedDeviceToken, enrollTrustedDevice, init_trustedDevice };

package/dist/chunk-dgqrcy74.js

@@ -0,0 +1,48 @@
+// @bun
+import {
+  require_index_node_http,
+  require_src,
+  require_src1 as require_src2
+} from "./chunk-90wp6wez.js";
+import"./chunk-a8ejc632.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-p2816w9z.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@opentelemetry+exporter-trace-otlp-http@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-trace-otlp-http/build/esm/platform/node/OTLPTraceExporter.js
+var import_otlp_exporter_base, import_otlp_transformer, import_node_http, OTLPTraceExporter;
+var init_OTLPTraceExporter = __esm(() => {
+  import_otlp_exporter_base = __toESM(require_src(), 1);
+  import_otlp_transformer = __toESM(require_src2(), 1);
+  import_node_http = __toESM(require_index_node_http(), 1);
+  OTLPTraceExporter = class OTLPTraceExporter extends import_otlp_exporter_base.OTLPExporterBase {
+    constructor(config = {}) {
+      super(import_node_http.createOtlpHttpExportDelegate(import_node_http.convertLegacyHttpOptions(config, "TRACES", "v1/traces", {
+        "Content-Type": "application/json"
+      }), import_otlp_transformer.JsonTraceSerializer));
+    }
+  };
+});
+
+// node_modules/.bun/@opentelemetry+exporter-trace-otlp-http@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-trace-otlp-http/build/esm/platform/node/index.js
+var init_node = __esm(() => {
+  init_OTLPTraceExporter();
+});
+
+// node_modules/.bun/@opentelemetry+exporter-trace-otlp-http@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-trace-otlp-http/build/esm/platform/index.js
+var init_platform = __esm(() => {
+  init_node();
+});
+
+// node_modules/.bun/@opentelemetry+exporter-trace-otlp-http@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-trace-otlp-http/build/esm/index.js
+var init_esm = __esm(() => {
+  init_platform();
+});
+init_esm();
+
+export {
+  OTLPTraceExporter
+};

package/dist/chunk-dnh7jtpb.js

@@ -0,0 +1,37 @@
+// @bun
+import {
+  require_execAsync
+} from "./chunk-3w6s9m5w.js";
+import {
+  require_src
+} from "./chunk-p2816w9z.js";
+import {
+  __commonJS
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@opentelemetry+resources@2.6.1+e40b0dfdd726a224/node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/getMachineId-darwin.js
+var require_getMachineId_darwin = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.getMachineId = undefined;
+  var execAsync_1 = require_execAsync();
+  var api_1 = require_src();
+  async function getMachineId() {
+    try {
+      const result = await (0, execAsync_1.execAsync)('ioreg -rd1 -c "IOPlatformExpertDevice"');
+      const idLine = result.stdout.split(`
+`).find((line) => line.includes("IOPlatformUUID"));
+      if (!idLine) {
+        return;
+      }
+      const parts = idLine.split('" = "');
+      if (parts.length === 2) {
+        return parts[1].slice(0, -1);
+      }
+    } catch (e) {
+      api_1.diag.debug(`error reading machine id: ${e}`);
+    }
+    return;
+  }
+  exports.getMachineId = getMachineId;
+});
+export default require_getMachineId_darwin();