claude-code-best 1.0.3

package/dist/chunk-jfv3zczw.js

@@ -0,0 +1,227 @@
+// @bun
+import {
+  SAFE_ENV_VARS,
+  isProviderManagedEnvVar
+} from "./chunk-x8b7vft8.js";
+import {
+  notifyPermissionModeChanged,
+  notifySessionMetadataChanged
+} from "./chunk-s39js2d3.js";
+import {
+  init_syncCache,
+  isRemoteManagedSettingsEligible
+} from "./chunk-g9q2cznf.js";
+import {
+  clearApiKeyHelperCache,
+  clearAwsCredentialsCache,
+  clearGcpCredentialsCache,
+  getGlobalConfig,
+  getSettingsForSource,
+  getSettings_DEPRECATED,
+  init_PermissionMode,
+  init_auth,
+  init_config1 as init_config,
+  init_constants,
+  init_settings1 as init_settings,
+  isSettingSourceEnabled,
+  permissionModeFromString,
+  saveGlobalConfig,
+  toExternalPermissionMode,
+  updateSettingsForSource
+} from "./chunk-7wm1rjfm.js";
+import {
+  clearCACertsCache,
+  clearMTLSCache,
+  clearProxyCache,
+  configureGlobalAgents,
+  init_caCerts,
+  init_mtls,
+  init_proxy
+} from "./chunk-5hva0tsg.js";
+import {
+  init_log,
+  logError
+} from "./chunk-p7g7pf3f.js";
+import {
+  init_errors,
+  toError
+} from "./chunk-nxsh6de2.js";
+import {
+  init_envUtils,
+  isEnvTruthy
+} from "./chunk-3r24h7t6.js";
+import {
+  init_state,
+  setMainLoopModelOverride
+} from "./chunk-qqfa0dqg.js";
+
+// src/utils/managedEnv.ts
+init_syncCache();
+init_caCerts();
+init_config();
+init_envUtils();
+init_mtls();
+init_proxy();
+init_constants();
+init_settings();
+function withoutSSHTunnelVars(env) {
+  if (!env || !process.env.ANTHROPIC_UNIX_SOCKET)
+    return env || {};
+  const {
+    ANTHROPIC_UNIX_SOCKET: _1,
+    ANTHROPIC_BASE_URL: _2,
+    ANTHROPIC_API_KEY: _3,
+    ANTHROPIC_AUTH_TOKEN: _4,
+    CLAUDE_CODE_OAUTH_TOKEN: _5,
+    ...rest
+  } = env;
+  return rest;
+}
+function withoutHostManagedProviderVars(env) {
+  if (!env)
+    return {};
+  if (!isEnvTruthy(process.env.CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST)) {
+    return env;
+  }
+  const out = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (!isProviderManagedEnvVar(key)) {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+var ccdSpawnEnvKeys;
+function withoutCcdSpawnEnvKeys(env) {
+  if (!env || !ccdSpawnEnvKeys)
+    return env || {};
+  const out = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (!ccdSpawnEnvKeys.has(key))
+      out[key] = value;
+  }
+  return out;
+}
+function filterSettingsEnv(env) {
+  return withoutCcdSpawnEnvKeys(withoutHostManagedProviderVars(withoutSSHTunnelVars(env)));
+}
+var TRUSTED_SETTING_SOURCES = [
+  "userSettings",
+  "flagSettings",
+  "policySettings"
+];
+function applySafeConfigEnvironmentVariables() {
+  if (ccdSpawnEnvKeys === undefined) {
+    ccdSpawnEnvKeys = process.env.CLAUDE_CODE_ENTRYPOINT === "claude-desktop" ? new Set(Object.keys(process.env)) : null;
+  }
+  Object.assign(process.env, filterSettingsEnv(getGlobalConfig().env));
+  for (const source of TRUSTED_SETTING_SOURCES) {
+    if (source === "policySettings")
+      continue;
+    if (!isSettingSourceEnabled(source))
+      continue;
+    Object.assign(process.env, filterSettingsEnv(getSettingsForSource(source)?.env));
+  }
+  isRemoteManagedSettingsEligible();
+  Object.assign(process.env, filterSettingsEnv(getSettingsForSource("policySettings")?.env));
+  const settingsEnv = filterSettingsEnv(getSettings_DEPRECATED()?.env);
+  for (const [key, value] of Object.entries(settingsEnv)) {
+    if (SAFE_ENV_VARS.has(key.toUpperCase())) {
+      process.env[key] = value;
+    }
+  }
+}
+function applyConfigEnvironmentVariables() {
+  Object.assign(process.env, filterSettingsEnv(getGlobalConfig().env));
+  Object.assign(process.env, filterSettingsEnv(getSettings_DEPRECATED()?.env));
+  clearCACertsCache();
+  clearMTLSCache();
+  clearProxyCache();
+  configureGlobalAgents();
+}
+
+// src/state/onChangeAppState.ts
+init_state();
+init_auth();
+init_config();
+init_errors();
+init_log();
+init_PermissionMode();
+init_settings();
+function externalMetadataToAppState(metadata) {
+  return (prev) => ({
+    ...prev,
+    ...typeof metadata.permission_mode === "string" ? {
+      toolPermissionContext: {
+        ...prev.toolPermissionContext,
+        mode: permissionModeFromString(metadata.permission_mode)
+      }
+    } : {},
+    ...typeof metadata.is_ultraplan_mode === "boolean" ? { isUltraplanMode: metadata.is_ultraplan_mode } : {}
+  });
+}
+function onChangeAppState({
+  newState,
+  oldState
+}) {
+  const prevMode = oldState.toolPermissionContext.mode;
+  const newMode = newState.toolPermissionContext.mode;
+  if (prevMode !== newMode) {
+    const prevExternal = toExternalPermissionMode(prevMode);
+    const newExternal = toExternalPermissionMode(newMode);
+    if (prevExternal !== newExternal) {
+      const isUltraplan = newExternal === "plan" && newState.isUltraplanMode && !oldState.isUltraplanMode ? true : null;
+      notifySessionMetadataChanged({
+        permission_mode: newExternal,
+        is_ultraplan_mode: isUltraplan
+      });
+    }
+    notifyPermissionModeChanged(newMode);
+  }
+  if (newState.mainLoopModel !== oldState.mainLoopModel && newState.mainLoopModel === null) {
+    updateSettingsForSource("userSettings", { model: undefined });
+    setMainLoopModelOverride(null);
+  }
+  if (newState.mainLoopModel !== oldState.mainLoopModel && newState.mainLoopModel !== null) {
+    updateSettingsForSource("userSettings", { model: newState.mainLoopModel });
+    setMainLoopModelOverride(newState.mainLoopModel);
+  }
+  if (newState.expandedView !== oldState.expandedView) {
+    const showExpandedTodos = newState.expandedView === "tasks";
+    const showSpinnerTree = newState.expandedView === "teammates";
+    if (getGlobalConfig().showExpandedTodos !== showExpandedTodos || getGlobalConfig().showSpinnerTree !== showSpinnerTree) {
+      saveGlobalConfig((current) => ({
+        ...current,
+        showExpandedTodos,
+        showSpinnerTree
+      }));
+    }
+  }
+  if (newState.verbose !== oldState.verbose && getGlobalConfig().verbose !== newState.verbose) {
+    const verbose = newState.verbose;
+    saveGlobalConfig((current) => ({
+      ...current,
+      verbose
+    }));
+  }
+  if (process.env.USER_TYPE === "ant") {
+    if (newState.tungstenPanelVisible !== oldState.tungstenPanelVisible && newState.tungstenPanelVisible !== undefined && getGlobalConfig().tungstenPanelVisible !== newState.tungstenPanelVisible) {
+      const tungstenPanelVisible = newState.tungstenPanelVisible;
+      saveGlobalConfig((current) => ({ ...current, tungstenPanelVisible }));
+    }
+  }
+  if (newState.settings !== oldState.settings) {
+    try {
+      clearApiKeyHelperCache();
+      clearAwsCredentialsCache();
+      clearGcpCredentialsCache();
+      if (newState.settings.env !== oldState.settings.env) {
+        applyConfigEnvironmentVariables();
+      }
+    } catch (error) {
+      logError(toError(error));
+    }
+  }
+}
+
+export { applySafeConfigEnvironmentVariables, applyConfigEnvironmentVariables, externalMetadataToAppState, onChangeAppState };

package/dist/chunk-jjsx6t78.js

@@ -0,0 +1,169 @@
+// @bun
+import {
+  Box_default,
+  init_Box,
+  init_dom,
+  init_reconciler,
+  markCommitStart,
+  markDirty,
+  scheduleRenderFrom
+} from "./chunk-8d5eyjse.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-g338npwr.js";
+import {
+  init_state,
+  markScrollActivity
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/ink/components/ScrollBox.tsx
+function ScrollBox({
+  children,
+  ref,
+  stickyScroll,
+  ...style
+}) {
+  const domRef = import_react.useRef(null);
+  const [, forceRender] = import_react.useState(0);
+  const listenersRef = import_react.useRef(new Set);
+  const renderQueuedRef = import_react.useRef(false);
+  const notify = () => {
+    for (const l of listenersRef.current)
+      l();
+  };
+  function scrollMutated(el) {
+    markScrollActivity();
+    markDirty(el);
+    markCommitStart();
+    notify();
+    if (renderQueuedRef.current)
+      return;
+    renderQueuedRef.current = true;
+    queueMicrotask(() => {
+      renderQueuedRef.current = false;
+      scheduleRenderFrom(el);
+    });
+  }
+  import_react.useImperativeHandle(ref, () => ({
+    scrollTo(y) {
+      const el = domRef.current;
+      if (!el)
+        return;
+      el.stickyScroll = false;
+      el.pendingScrollDelta = undefined;
+      el.scrollAnchor = undefined;
+      el.scrollTop = Math.max(0, Math.floor(y));
+      scrollMutated(el);
+    },
+    scrollToElement(el, offset = 0) {
+      const box = domRef.current;
+      if (!box)
+        return;
+      box.stickyScroll = false;
+      box.pendingScrollDelta = undefined;
+      box.scrollAnchor = {
+        el,
+        offset
+      };
+      scrollMutated(box);
+    },
+    scrollBy(dy) {
+      const el = domRef.current;
+      if (!el)
+        return;
+      el.stickyScroll = false;
+      el.scrollAnchor = undefined;
+      el.pendingScrollDelta = (el.pendingScrollDelta ?? 0) + Math.floor(dy);
+      scrollMutated(el);
+    },
+    scrollToBottom() {
+      const el = domRef.current;
+      if (!el)
+        return;
+      el.pendingScrollDelta = undefined;
+      el.stickyScroll = true;
+      markDirty(el);
+      notify();
+      forceRender((n) => n + 1);
+    },
+    getScrollTop() {
+      return domRef.current?.scrollTop ?? 0;
+    },
+    getPendingDelta() {
+      return domRef.current?.pendingScrollDelta ?? 0;
+    },
+    getScrollHeight() {
+      return domRef.current?.scrollHeight ?? 0;
+    },
+    getFreshScrollHeight() {
+      const content = domRef.current?.childNodes[0];
+      return content?.yogaNode?.getComputedHeight() ?? domRef.current?.scrollHeight ?? 0;
+    },
+    getViewportHeight() {
+      return domRef.current?.scrollViewportHeight ?? 0;
+    },
+    getViewportTop() {
+      return domRef.current?.scrollViewportTop ?? 0;
+    },
+    isSticky() {
+      const el = domRef.current;
+      if (!el)
+        return false;
+      return el.stickyScroll ?? Boolean(el.attributes["stickyScroll"]);
+    },
+    subscribe(listener) {
+      listenersRef.current.add(listener);
+      return () => listenersRef.current.delete(listener);
+    },
+    setClampBounds(min, max) {
+      const el = domRef.current;
+      if (!el)
+        return;
+      el.scrollClampMin = min;
+      el.scrollClampMax = max;
+    }
+  }), []);
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV("ink-box", {
+    ref: (el) => {
+      domRef.current = el;
+      if (el)
+        el.scrollTop ??= 0;
+    },
+    style: {
+      flexWrap: "nowrap",
+      flexDirection: style.flexDirection ?? "row",
+      flexGrow: style.flexGrow ?? 0,
+      flexShrink: style.flexShrink ?? 1,
+      ...style,
+      overflowX: "scroll",
+      overflowY: "scroll"
+    },
+    ...stickyScroll ? {
+      stickyScroll: true
+    } : {},
+    children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Box_default, {
+      flexDirection: "column",
+      flexGrow: 1,
+      flexShrink: 0,
+      width: "100%",
+      children
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+var import_react, jsx_dev_runtime, ScrollBox_default;
+var init_ScrollBox = __esm(() => {
+  init_state();
+  init_dom();
+  init_reconciler();
+  init_Box();
+  import_react = __toESM(require_react(), 1);
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+  ScrollBox_default = ScrollBox;
+});
+
+export { ScrollBox_default, init_ScrollBox };

package/dist/chunk-jnhkref0.js

@@ -0,0 +1,30 @@
+// @bun
+import {
+  require_src
+} from "./chunk-p2816w9z.js";
+import {
+  __commonJS,
+  __require
+} 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-linux.js
+var require_getMachineId_linux = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.getMachineId = undefined;
+  var fs_1 = __require("fs");
+  var api_1 = require_src();
+  async function getMachineId() {
+    const paths = ["/etc/machine-id", "/var/lib/dbus/machine-id"];
+    for (const path of paths) {
+      try {
+        const result = await fs_1.promises.readFile(path, { encoding: "utf8" });
+        return result.trim();
+      } catch (e) {
+        api_1.diag.debug(`error reading machine id: ${e}`);
+      }
+    }
+    return;
+  }
+  exports.getMachineId = getMachineId;
+});
+export default require_getMachineId_linux();