claude-code-best 1.0.3

package/dist/chunk-1w361mz1.js

@@ -0,0 +1,438 @@
+// @bun
+import {
+  LoadingState,
+  init_LoadingState
+} from "./chunk-tdpvdzbf.js";
+import {
+  flushSessionStorage,
+  gracefulShutdown,
+  init_gracefulShutdown,
+  init_sessionStorage
+} from "./chunk-g9q2cznf.js";
+import {
+  ThemedBox_default,
+  ThemedText,
+  init_ink,
+  require_compiler_runtime,
+  use_input_default
+} from "./chunk-8d5eyjse.js";
+import {
+  gte,
+  init_semver
+} from "./chunk-ps49ymvj.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-g338npwr.js";
+import {
+  init_browser,
+  openBrowser
+} from "./chunk-m06q12hg.js";
+import {
+  init_file,
+  pathExists
+} from "./chunk-7wm1rjfm.js";
+import {
+  require_semver
+} from "./chunk-0vkfrmqm.js";
+import {
+  execFileNoThrow,
+  init_execFileNoThrow
+} from "./chunk-hx2tr4ep.js";
+import {
+  getCwd,
+  init_cwd
+} from "./chunk-8bedvdm1.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  logForDebugging
+} from "./chunk-nxsh6de2.js";
+import {
+  getSessionId,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/desktopDeepLink.ts
+import { readdir } from "fs/promises";
+import { join } from "path";
+function isDevMode() {
+  if (true) {
+    return true;
+  }
+  const pathsToCheck = [process.argv[1] || "", process.execPath || ""];
+  const buildDirs = [
+    "/build-ant/",
+    "/build-ant-native/",
+    "/build-external/",
+    "/build-external-native/"
+  ];
+  return pathsToCheck.some((p) => buildDirs.some((dir) => p.includes(dir)));
+}
+function buildDesktopDeepLink(sessionId) {
+  const protocol = isDevMode() ? "claude-dev" : "claude";
+  const url = new URL(`${protocol}://resume`);
+  url.searchParams.set("session", sessionId);
+  url.searchParams.set("cwd", getCwd());
+  return url.toString();
+}
+async function isDesktopInstalled() {
+  if (isDevMode()) {
+    return true;
+  }
+  const platform = process.platform;
+  if (platform === "darwin") {
+    return pathExists("/Applications/Claude.app");
+  } else if (platform === "linux") {
+    const { code, stdout } = await execFileNoThrow("xdg-mime", [
+      "query",
+      "default",
+      "x-scheme-handler/claude"
+    ]);
+    return code === 0 && stdout.trim().length > 0;
+  } else if (platform === "win32") {
+    const { code } = await execFileNoThrow("reg", [
+      "query",
+      "HKEY_CLASSES_ROOT\\claude",
+      "/ve"
+    ]);
+    return code === 0;
+  }
+  return false;
+}
+async function getDesktopVersion() {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    const { code, stdout } = await execFileNoThrow("defaults", [
+      "read",
+      "/Applications/Claude.app/Contents/Info.plist",
+      "CFBundleShortVersionString"
+    ]);
+    if (code !== 0) {
+      return null;
+    }
+    const version = stdout.trim();
+    return version.length > 0 ? version : null;
+  } else if (platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA;
+    if (!localAppData) {
+      return null;
+    }
+    const installDir = join(localAppData, "AnthropicClaude");
+    try {
+      const entries = await readdir(installDir);
+      const versions = entries.filter((e) => e.startsWith("app-")).map((e) => e.slice(4)).filter((v) => import_semver.coerce(v) !== null).sort((a, b) => {
+        const ca = import_semver.coerce(a);
+        const cb = import_semver.coerce(b);
+        return ca.compare(cb);
+      });
+      return versions.length > 0 ? versions[versions.length - 1] : null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+async function getDesktopInstallStatus() {
+  const installed = await isDesktopInstalled();
+  if (!installed) {
+    return { status: "not-installed" };
+  }
+  let version;
+  try {
+    version = await getDesktopVersion();
+  } catch {
+    return { status: "ready", version: "unknown" };
+  }
+  if (!version) {
+    return { status: "ready", version: "unknown" };
+  }
+  const coerced = import_semver.coerce(version);
+  if (!coerced || !gte(coerced.version, MIN_DESKTOP_VERSION)) {
+    return { status: "version-too-old", version };
+  }
+  return { status: "ready", version };
+}
+async function openDeepLink(deepLinkUrl) {
+  const platform = process.platform;
+  logForDebugging(`Opening deep link: ${deepLinkUrl}`);
+  if (platform === "darwin") {
+    if (isDevMode()) {
+      const { code: code2 } = await execFileNoThrow("osascript", [
+        "-e",
+        `tell application "Electron" to open location "${deepLinkUrl}"`
+      ]);
+      return code2 === 0;
+    }
+    const { code } = await execFileNoThrow("open", [deepLinkUrl]);
+    return code === 0;
+  } else if (platform === "linux") {
+    const { code } = await execFileNoThrow("xdg-open", [deepLinkUrl]);
+    return code === 0;
+  } else if (platform === "win32") {
+    const { code } = await execFileNoThrow("cmd", [
+      "/c",
+      "start",
+      "",
+      deepLinkUrl
+    ]);
+    return code === 0;
+  }
+  return false;
+}
+async function openCurrentSessionInDesktop() {
+  const sessionId = getSessionId();
+  const installed = await isDesktopInstalled();
+  if (!installed) {
+    return {
+      success: false,
+      error: "Claude Desktop is not installed. Install it from https://claude.ai/download"
+    };
+  }
+  const deepLinkUrl = buildDesktopDeepLink(sessionId);
+  const opened = await openDeepLink(deepLinkUrl);
+  if (!opened) {
+    return {
+      success: false,
+      error: "Failed to open Claude Desktop. Please try opening it manually.",
+      deepLinkUrl
+    };
+  }
+  return { success: true, deepLinkUrl };
+}
+var import_semver, MIN_DESKTOP_VERSION = "1.1.2396";
+var init_desktopDeepLink = __esm(() => {
+  init_state();
+  init_cwd();
+  init_debug();
+  init_execFileNoThrow();
+  init_file();
+  init_semver();
+  import_semver = __toESM(require_semver(), 1);
+});
+
+// src/components/DesktopHandoff.tsx
+function getDownloadUrl() {
+  switch (process.platform) {
+    case "win32":
+      return "https://claude.ai/api/desktop/win32/x64/exe/latest/redirect";
+    default:
+      return "https://claude.ai/api/desktop/darwin/universal/dmg/latest/redirect";
+  }
+}
+function DesktopHandoff(t0) {
+  const $ = import_compiler_runtime.c(20);
+  const {
+    onDone
+  } = t0;
+  const [state, setState] = import_react.useState("checking");
+  const [error, setError] = import_react.useState(null);
+  const [downloadMessage, setDownloadMessage] = import_react.useState("");
+  let t1;
+  if ($[0] !== error || $[1] !== onDone || $[2] !== state) {
+    t1 = (input) => {
+      if (state === "error") {
+        onDone(error ?? "Unknown error", {
+          display: "system"
+        });
+        return;
+      }
+      if (state === "prompt-download") {
+        if (input === "y" || input === "Y") {
+          openBrowser(getDownloadUrl()).catch(_temp);
+          onDone(`Starting download. Re-run /desktop once you\u2019ve installed the app.
+Learn more at ${DESKTOP_DOCS_URL}`, {
+            display: "system"
+          });
+        } else {
+          if (input === "n" || input === "N") {
+            onDone(`The desktop app is required for /desktop. Learn more at ${DESKTOP_DOCS_URL}`, {
+              display: "system"
+            });
+          }
+        }
+      }
+    };
+    $[0] = error;
+    $[1] = onDone;
+    $[2] = state;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  use_input_default(t1);
+  let t2;
+  let t3;
+  if ($[4] !== onDone) {
+    t2 = () => {
+      const performHandoff = async function performHandoff2() {
+        setState("checking");
+        const installStatus = await getDesktopInstallStatus();
+        if (installStatus.status === "not-installed") {
+          setDownloadMessage("Claude Desktop is not installed.");
+          setState("prompt-download");
+          return;
+        }
+        if (installStatus.status === "version-too-old") {
+          setDownloadMessage(`Claude Desktop needs to be updated (found v${installStatus.version}, need v1.1.2396+).`);
+          setState("prompt-download");
+          return;
+        }
+        setState("flushing");
+        await flushSessionStorage();
+        setState("opening");
+        const result = await openCurrentSessionInDesktop();
+        if (!result.success) {
+          setError(result.error ?? "Failed to open Claude Desktop");
+          setState("error");
+          return;
+        }
+        setState("success");
+        setTimeout(_temp2, 500, onDone);
+      };
+      performHandoff().catch((err) => {
+        setError(errorMessage(err));
+        setState("error");
+      });
+    };
+    t3 = [onDone];
+    $[4] = onDone;
+    $[5] = t2;
+    $[6] = t3;
+  } else {
+    t2 = $[5];
+    t3 = $[6];
+  }
+  import_react.useEffect(t2, t3);
+  if (state === "error") {
+    let t42;
+    if ($[7] !== error) {
+      t42 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+        color: "error",
+        children: [
+          "Error: ",
+          error
+        ]
+      }, undefined, true, undefined, this);
+      $[7] = error;
+      $[8] = t42;
+    } else {
+      t42 = $[8];
+    }
+    let t52;
+    if ($[9] === Symbol.for("react.memo_cache_sentinel")) {
+      t52 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+        dimColor: true,
+        children: "Press any key to continue\u2026"
+      }, undefined, false, undefined, this);
+      $[9] = t52;
+    } else {
+      t52 = $[9];
+    }
+    let t62;
+    if ($[10] !== t42) {
+      t62 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+        flexDirection: "column",
+        paddingX: 2,
+        children: [
+          t42,
+          t52
+        ]
+      }, undefined, true, undefined, this);
+      $[10] = t42;
+      $[11] = t62;
+    } else {
+      t62 = $[11];
+    }
+    return t62;
+  }
+  if (state === "prompt-download") {
+    let t42;
+    if ($[12] !== downloadMessage) {
+      t42 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+        children: downloadMessage
+      }, undefined, false, undefined, this);
+      $[12] = downloadMessage;
+      $[13] = t42;
+    } else {
+      t42 = $[13];
+    }
+    let t52;
+    if ($[14] === Symbol.for("react.memo_cache_sentinel")) {
+      t52 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+        children: "Download now? (y/n)"
+      }, undefined, false, undefined, this);
+      $[14] = t52;
+    } else {
+      t52 = $[14];
+    }
+    let t62;
+    if ($[15] !== t42) {
+      t62 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+        flexDirection: "column",
+        paddingX: 2,
+        children: [
+          t42,
+          t52
+        ]
+      }, undefined, true, undefined, this);
+      $[15] = t42;
+      $[16] = t62;
+    } else {
+      t62 = $[16];
+    }
+    return t62;
+  }
+  let t4;
+  if ($[17] === Symbol.for("react.memo_cache_sentinel")) {
+    t4 = {
+      checking: "Checking for Claude Desktop\u2026",
+      flushing: "Saving session\u2026",
+      opening: "Opening Claude Desktop\u2026",
+      success: "Opening in Claude Desktop\u2026"
+    };
+    $[17] = t4;
+  } else {
+    t4 = $[17];
+  }
+  const messages = t4;
+  const t5 = messages[state];
+  let t6;
+  if ($[18] !== t5) {
+    t6 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(LoadingState, {
+      message: t5
+    }, undefined, false, undefined, this);
+    $[18] = t5;
+    $[19] = t6;
+  } else {
+    t6 = $[19];
+  }
+  return t6;
+}
+async function _temp2(onDone_0) {
+  onDone_0("Session transferred to Claude Desktop", {
+    display: "system"
+  });
+  await gracefulShutdown(0, "other");
+}
+function _temp() {}
+var import_compiler_runtime, import_react, jsx_dev_runtime, DESKTOP_DOCS_URL = "https://clau.de/desktop";
+var init_DesktopHandoff = __esm(() => {
+  init_ink();
+  init_browser();
+  init_desktopDeepLink();
+  init_errors();
+  init_gracefulShutdown();
+  init_sessionStorage();
+  init_LoadingState();
+  import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
+  import_react = __toESM(require_react(), 1);
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+export { DesktopHandoff, init_DesktopHandoff };

package/dist/chunk-1xkekb9y.js

@@ -0,0 +1,19 @@
+// @bun
+import {
+  DANGEROUS_uncachedSystemPromptSection,
+  clearSystemPromptSections,
+  init_systemPromptSections,
+  resolveSystemPromptSections,
+  systemPromptSection
+} from "./chunk-t0rgmccj.js";
+import"./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-qp2qdcda.js";
+init_systemPromptSections();
+
+export {
+  systemPromptSection,
+  resolveSystemPromptSections,
+  clearSystemPromptSections,
+  DANGEROUS_uncachedSystemPromptSection
+};

package/dist/chunk-201dvaa3.js

@@ -0,0 +1,246 @@
+// @bun
+import {
+  MODEL_COSTS,
+  getAPIProvider,
+  getCanonicalName,
+  getEventMetadata,
+  getOrCreateUserID,
+  init_config,
+  init_config1 as init_config2,
+  init_metadata,
+  init_model,
+  init_modelCost,
+  init_providers,
+  isAnalyticsDisabled
+} from "./chunk-7wm1rjfm.js";
+import {
+  init_log,
+  logError
+} from "./chunk-p7g7pf3f.js";
+import {
+  init_memoize,
+  memoize_default
+} from "./chunk-hqmz36b3.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-xszk7n10.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/services/analytics/datadog.ts
+import { createHash } from "crypto";
+function camelToSnakeCase(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+async function flushLogs() {
+  if (logBatch.length === 0)
+    return;
+  const logsToSend = logBatch;
+  logBatch = [];
+  try {
+    await axios_default.post(DATADOG_LOGS_ENDPOINT, logsToSend, {
+      headers: {
+        "Content-Type": "application/json",
+        "DD-API-KEY": DATADOG_CLIENT_TOKEN
+      },
+      timeout: NETWORK_TIMEOUT_MS
+    });
+  } catch (error) {
+    logError(error);
+  }
+}
+function scheduleFlush() {
+  if (flushTimer)
+    return;
+  flushTimer = setTimeout(() => {
+    flushTimer = null;
+    flushLogs();
+  }, getFlushIntervalMs()).unref();
+}
+async function shutdownDatadog() {
+  if (flushTimer) {
+    clearTimeout(flushTimer);
+    flushTimer = null;
+  }
+  await flushLogs();
+}
+async function trackDatadogEvent(eventName, properties) {
+  if (true) {
+    return;
+  }
+  if (getAPIProvider() !== "firstParty") {
+    return;
+  }
+  let initialized = datadogInitialized;
+  if (initialized === null) {
+    initialized = await initializeDatadog();
+  }
+  if (!initialized || !DATADOG_ALLOWED_EVENTS.has(eventName)) {
+    return;
+  }
+  try {
+    const metadata = await getEventMetadata({
+      model: properties.model,
+      betas: properties.betas
+    });
+    const { envContext, ...restMetadata } = metadata;
+    const allData = {
+      ...restMetadata,
+      ...envContext,
+      ...properties,
+      userBucket: getUserBucket()
+    };
+    if (typeof allData.toolName === "string" && allData.toolName.startsWith("mcp__")) {
+      allData.toolName = "mcp";
+    }
+    if (process.env.USER_TYPE !== "ant" && typeof allData.model === "string") {
+      const shortName = getCanonicalName(allData.model.replace(/\[1m]$/i, ""));
+      allData.model = shortName in MODEL_COSTS ? shortName : "other";
+    }
+    if (typeof allData.version === "string") {
+      allData.version = allData.version.replace(/^(\d+\.\d+\.\d+-dev\.\d{8})\.t\d+\.sha[a-f0-9]+$/, "$1");
+    }
+    if (allData.status !== undefined && allData.status !== null) {
+      const statusCode = String(allData.status);
+      allData.http_status = statusCode;
+      const firstDigit = statusCode.charAt(0);
+      if (firstDigit >= "1" && firstDigit <= "5") {
+        allData.http_status_range = `${firstDigit}xx`;
+      }
+      delete allData.status;
+    }
+    const allDataRecord = allData;
+    const tags = [
+      `event:${eventName}`,
+      ...TAG_FIELDS.filter((field) => allDataRecord[field] !== undefined && allDataRecord[field] !== null).map((field) => `${camelToSnakeCase(field)}:${allDataRecord[field]}`)
+    ];
+    const log = {
+      ddsource: "nodejs",
+      ddtags: tags.join(","),
+      message: eventName,
+      service: "claude-code",
+      hostname: "claude-code",
+      env: process.env.USER_TYPE
+    };
+    for (const [key, value] of Object.entries(allData)) {
+      if (value !== undefined && value !== null) {
+        log[camelToSnakeCase(key)] = value;
+      }
+    }
+    logBatch.push(log);
+    if (logBatch.length >= MAX_BATCH_SIZE) {
+      if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+      }
+      flushLogs();
+    } else {
+      scheduleFlush();
+    }
+  } catch (error) {
+    logError(error);
+  }
+}
+function getFlushIntervalMs() {
+  return parseInt(process.env.CLAUDE_CODE_DATADOG_FLUSH_INTERVAL_MS || "", 10) || DEFAULT_FLUSH_INTERVAL_MS;
+}
+var DATADOG_LOGS_ENDPOINT = "https://http-intake.logs.us5.datadoghq.com/api/v2/logs", DATADOG_CLIENT_TOKEN = "pubbbf48e6d78dae54bceaa4acf463299bf", DEFAULT_FLUSH_INTERVAL_MS = 15000, MAX_BATCH_SIZE = 100, NETWORK_TIMEOUT_MS = 5000, DATADOG_ALLOWED_EVENTS, TAG_FIELDS, logBatch, flushTimer = null, datadogInitialized = null, initializeDatadog, NUM_USER_BUCKETS = 30, getUserBucket;
+var init_datadog = __esm(() => {
+  init_axios();
+  init_memoize();
+  init_config2();
+  init_log();
+  init_model();
+  init_providers();
+  init_modelCost();
+  init_config();
+  init_metadata();
+  DATADOG_ALLOWED_EVENTS = new Set([
+    "chrome_bridge_connection_succeeded",
+    "chrome_bridge_connection_failed",
+    "chrome_bridge_disconnected",
+    "chrome_bridge_tool_call_completed",
+    "chrome_bridge_tool_call_error",
+    "chrome_bridge_tool_call_started",
+    "chrome_bridge_tool_call_timeout",
+    "tengu_api_error",
+    "tengu_api_success",
+    "tengu_brief_mode_enabled",
+    "tengu_brief_mode_toggled",
+    "tengu_brief_send",
+    "tengu_cancel",
+    "tengu_compact_failed",
+    "tengu_exit",
+    "tengu_flicker",
+    "tengu_init",
+    "tengu_model_fallback_triggered",
+    "tengu_oauth_error",
+    "tengu_oauth_success",
+    "tengu_oauth_token_refresh_failure",
+    "tengu_oauth_token_refresh_success",
+    "tengu_oauth_token_refresh_lock_acquiring",
+    "tengu_oauth_token_refresh_lock_acquired",
+    "tengu_oauth_token_refresh_starting",
+    "tengu_oauth_token_refresh_completed",
+    "tengu_oauth_token_refresh_lock_releasing",
+    "tengu_oauth_token_refresh_lock_released",
+    "tengu_query_error",
+    "tengu_session_file_read",
+    "tengu_started",
+    "tengu_tool_use_error",
+    "tengu_tool_use_granted_in_prompt_permanent",
+    "tengu_tool_use_granted_in_prompt_temporary",
+    "tengu_tool_use_rejected_in_prompt",
+    "tengu_tool_use_success",
+    "tengu_uncaught_exception",
+    "tengu_unhandled_rejection",
+    "tengu_voice_recording_started",
+    "tengu_voice_toggled",
+    "tengu_team_mem_sync_pull",
+    "tengu_team_mem_sync_push",
+    "tengu_team_mem_sync_started",
+    "tengu_team_mem_entries_capped"
+  ]);
+  TAG_FIELDS = [
+    "arch",
+    "clientType",
+    "errorType",
+    "http_status_range",
+    "http_status",
+    "kairosActive",
+    "model",
+    "platform",
+    "provider",
+    "skillMode",
+    "subscriptionType",
+    "toolName",
+    "userBucket",
+    "userType",
+    "version",
+    "versionBase"
+  ];
+  logBatch = [];
+  initializeDatadog = memoize_default(async () => {
+    if (isAnalyticsDisabled()) {
+      datadogInitialized = false;
+      return false;
+    }
+    try {
+      datadogInitialized = true;
+      return true;
+    } catch (error) {
+      logError(error);
+      datadogInitialized = false;
+      return false;
+    }
+  });
+  getUserBucket = memoize_default(() => {
+    const userId = getOrCreateUserID();
+    const hash = createHash("sha256").update(userId).digest("hex");
+    return parseInt(hash.slice(0, 8), 16) % NUM_USER_BUCKETS;
+  });
+});
+
+export { shutdownDatadog, trackDatadogEvent, init_datadog };