claude-code-best 1.0.3

package/dist/chunk-2tkt52mz.js

@@ -0,0 +1,165 @@
+// @bun
+import {
+  checkAndDisableBypassPermissionsIfNeeded,
+  init_bypassPermissionsKillswitch,
+  resetBypassPermissionsCheck
+} from "./chunk-7ahman84.js";
+import {
+  init_useMainLoopModel,
+  useMainLoopModel
+} from "./chunk-5a3cw988.js";
+import {
+  ConsoleOAuthFlow,
+  init_ConsoleOAuthFlow,
+  init_messages1 as init_messages,
+  init_policyLimits,
+  init_remoteManagedSettings,
+  refreshPolicyLimits,
+  refreshRemoteManagedSettings,
+  stripSignatureBlocks
+} from "./chunk-g9q2cznf.js";
+import {
+  clearTrustedDeviceToken,
+  enrollTrustedDevice,
+  init_trustedDevice
+} from "./chunk-def1dc97.js";
+import {
+  ConfigurableShortcutHint,
+  Dialog,
+  init_ConfigurableShortcutHint,
+  init_Dialog
+} from "./chunk-9egdc8n4.js";
+import {
+  ThemedText,
+  init_ink,
+  require_compiler_runtime
+} from "./chunk-8d5eyjse.js";
+import {
+  require_jsx_dev_runtime
+} from "./chunk-g338npwr.js";
+import {
+  init_growthbook,
+  init_user,
+  refreshGrowthBookAfterAuthChange,
+  resetUserCache
+} from "./chunk-7wm1rjfm.js";
+import {
+  init_state,
+  resetCostState
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/login/login.tsx
+async function call(onDone, context) {
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Login, {
+    onDone: async (success) => {
+      context.onChangeAPIKey();
+      context.setMessages(stripSignatureBlocks);
+      if (success) {
+        resetCostState();
+        refreshRemoteManagedSettings();
+        refreshPolicyLimits();
+        resetUserCache();
+        refreshGrowthBookAfterAuthChange();
+        clearTrustedDeviceToken();
+        enrollTrustedDevice();
+        resetBypassPermissionsCheck();
+        const appState = context.getAppState();
+        checkAndDisableBypassPermissionsIfNeeded(appState.toolPermissionContext, context.setAppState);
+        if (false) {}
+        context.setAppState((prev) => ({
+          ...prev,
+          authVersion: prev.authVersion + 1
+        }));
+      }
+      onDone(success ? "Login successful" : "Login interrupted");
+    }
+  }, undefined, false, undefined, this);
+}
+function Login(props) {
+  const $ = import_compiler_runtime.c(12);
+  const mainLoopModel = useMainLoopModel();
+  let t0;
+  if ($[0] !== mainLoopModel || $[1] !== props) {
+    t0 = () => props.onDone(false, mainLoopModel);
+    $[0] = mainLoopModel;
+    $[1] = props;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  let t1;
+  if ($[3] !== mainLoopModel || $[4] !== props) {
+    t1 = () => props.onDone(true, mainLoopModel);
+    $[3] = mainLoopModel;
+    $[4] = props;
+    $[5] = t1;
+  } else {
+    t1 = $[5];
+  }
+  let t2;
+  if ($[6] !== props.startingMessage || $[7] !== t1) {
+    t2 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ConsoleOAuthFlow, {
+      onDone: t1,
+      startingMessage: props.startingMessage
+    }, undefined, false, undefined, this);
+    $[6] = props.startingMessage;
+    $[7] = t1;
+    $[8] = t2;
+  } else {
+    t2 = $[8];
+  }
+  let t3;
+  if ($[9] !== t0 || $[10] !== t2) {
+    t3 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Dialog, {
+      title: "Login",
+      onCancel: t0,
+      color: "permission",
+      inputGuide: _temp,
+      children: t2
+    }, undefined, false, undefined, this);
+    $[9] = t0;
+    $[10] = t2;
+    $[11] = t3;
+  } else {
+    t3 = $[11];
+  }
+  return t3;
+}
+function _temp(exitState) {
+  return exitState.pending ? /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+    children: [
+      "Press ",
+      exitState.keyName,
+      " again to exit"
+    ]
+  }, undefined, true, undefined, this) : /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ConfigurableShortcutHint, {
+    action: "confirm:no",
+    context: "Confirmation",
+    fallback: "Esc",
+    description: "cancel"
+  }, undefined, false, undefined, this);
+}
+var import_compiler_runtime, jsx_dev_runtime;
+var init_login = __esm(() => {
+  init_state();
+  init_trustedDevice();
+  init_ConfigurableShortcutHint();
+  init_ConsoleOAuthFlow();
+  init_Dialog();
+  init_useMainLoopModel();
+  init_ink();
+  init_growthbook();
+  init_policyLimits();
+  init_remoteManagedSettings();
+  init_messages();
+  init_bypassPermissionsKillswitch();
+  init_user();
+  import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+export { call, Login, init_login };

package/dist/chunk-2tme3s1c.js

@@ -0,0 +1,114 @@
+// @bun
+import {
+  Settings,
+  init_Settings
+} from "./chunk-97r68x5g.js";
+import"./chunk-exy9bnjf.js";
+import"./chunk-5wxspfct.js";
+import"./chunk-f1f3dmd5.js";
+import"./chunk-veaq13qy.js";
+import"./chunk-tb2g2bba.js";
+import"./chunk-j5zq8axt.js";
+import"./chunk-fakajzny.js";
+import"./chunk-jjsx6t78.js";
+import"./chunk-2x3gmbws.js";
+import"./chunk-nx6nds18.js";
+import"./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"./chunk-pvvew193.js";
+import"./chunk-8d5eyjse.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import {
+  require_jsx_dev_runtime
+} 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"./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"./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/config/config.tsx
+var jsx_dev_runtime, call = async (onDone, context) => {
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Settings, {
+    onClose: onDone,
+    context,
+    defaultTab: "Config"
+  }, undefined, false, undefined, this);
+};
+var init_config = __esm(() => {
+  init_Settings();
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+init_config();
+
+export {
+  call
+};

package/dist/chunk-2tw2ve8h.js

@@ -0,0 +1,145 @@
+// @bun
+import {
+  getProjectsDir,
+  getWorktreePathsPortable,
+  init_getWorktreePathsPortable,
+  init_sessionStoragePortable,
+  sanitizePath
+} from "./chunk-vratq94g.js";
+import {
+  init_v4
+} from "./chunk-g0j0t6qk.js";
+import {
+  exports_external,
+  init_lazySchema,
+  lazySchema
+} from "./chunk-55wgxwa9.js";
+import"./chunk-8tnsngw2.js";
+import {
+  init_debug,
+  init_errors,
+  init_slowOperations,
+  isENOENT,
+  jsonParse,
+  jsonStringify,
+  logForDebugging
+} 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-qp2qdcda.js";
+
+// src/bridge/bridgePointer.ts
+init_v4();
+init_debug();
+init_errors();
+init_getWorktreePathsPortable();
+init_lazySchema();
+init_sessionStoragePortable();
+init_slowOperations();
+import { mkdir, readFile, stat, unlink, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+var MAX_WORKTREE_FANOUT = 50;
+var BRIDGE_POINTER_TTL_MS = 4 * 60 * 60 * 1000;
+var BridgePointerSchema = lazySchema(() => exports_external.object({
+  sessionId: exports_external.string(),
+  environmentId: exports_external.string(),
+  source: exports_external.enum(["standalone", "repl"])
+}));
+function getBridgePointerPath(dir) {
+  return join(getProjectsDir(), sanitizePath(dir), "bridge-pointer.json");
+}
+async function writeBridgePointer(dir, pointer) {
+  const path = getBridgePointerPath(dir);
+  try {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, jsonStringify(pointer), "utf8");
+    logForDebugging(`[bridge:pointer] wrote ${path}`);
+  } catch (err) {
+    logForDebugging(`[bridge:pointer] write failed: ${err}`, { level: "warn" });
+  }
+}
+async function readBridgePointer(dir) {
+  const path = getBridgePointerPath(dir);
+  let raw;
+  let mtimeMs;
+  try {
+    mtimeMs = (await stat(path)).mtimeMs;
+    raw = await readFile(path, "utf8");
+  } catch {
+    return null;
+  }
+  const parsed = BridgePointerSchema().safeParse(safeJsonParse(raw));
+  if (!parsed.success) {
+    logForDebugging(`[bridge:pointer] invalid schema, clearing: ${path}`);
+    await clearBridgePointer(dir);
+    return null;
+  }
+  const ageMs = Math.max(0, Date.now() - mtimeMs);
+  if (ageMs > BRIDGE_POINTER_TTL_MS) {
+    logForDebugging(`[bridge:pointer] stale (>4h mtime), clearing: ${path}`);
+    await clearBridgePointer(dir);
+    return null;
+  }
+  return { ...parsed.data, ageMs };
+}
+async function readBridgePointerAcrossWorktrees(dir) {
+  const here = await readBridgePointer(dir);
+  if (here) {
+    return { pointer: here, dir };
+  }
+  const worktrees = await getWorktreePathsPortable(dir);
+  if (worktrees.length <= 1)
+    return null;
+  if (worktrees.length > MAX_WORKTREE_FANOUT) {
+    logForDebugging(`[bridge:pointer] ${worktrees.length} worktrees exceeds fanout cap ${MAX_WORKTREE_FANOUT}, skipping`);
+    return null;
+  }
+  const dirKey = sanitizePath(dir);
+  const candidates = worktrees.filter((wt) => sanitizePath(wt) !== dirKey);
+  const results = await Promise.all(candidates.map(async (wt) => {
+    const p = await readBridgePointer(wt);
+    return p ? { pointer: p, dir: wt } : null;
+  }));
+  let freshest = null;
+  for (const r of results) {
+    if (r && (!freshest || r.pointer.ageMs < freshest.pointer.ageMs)) {
+      freshest = r;
+    }
+  }
+  if (freshest) {
+    logForDebugging(`[bridge:pointer] fanout found pointer in worktree ${freshest.dir} (ageMs=${freshest.pointer.ageMs})`);
+  }
+  return freshest;
+}
+async function clearBridgePointer(dir) {
+  const path = getBridgePointerPath(dir);
+  try {
+    await unlink(path);
+    logForDebugging(`[bridge:pointer] cleared ${path}`);
+  } catch (err) {
+    if (!isENOENT(err)) {
+      logForDebugging(`[bridge:pointer] clear failed: ${err}`, {
+        level: "warn"
+      });
+    }
+  }
+}
+function safeJsonParse(raw) {
+  try {
+    return jsonParse(raw);
+  } catch {
+    return null;
+  }
+}
+export {
+  writeBridgePointer,
+  readBridgePointerAcrossWorktrees,
+  readBridgePointer,
+  getBridgePointerPath,
+  clearBridgePointer,
+  BRIDGE_POINTER_TTL_MS
+};

package/dist/chunk-2v1br2x0.js

@@ -0,0 +1,59 @@
+// @bun
+import {
+  getFeatureValue_CACHED_MAY_BE_STALE,
+  init_constants1 as init_constants,
+  init_growthbook
+} from "./chunk-7wm1rjfm.js";
+import {
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/tools/ToolSearchTool/constants.ts
+var TOOL_SEARCH_TOOL_NAME = "ToolSearch";
+var init_constants2 = () => {};
+
+// src/tools/ToolSearchTool/prompt.ts
+function getToolLocationHint() {
+  const deltaEnabled = process.env.USER_TYPE === "ant" || getFeatureValue_CACHED_MAY_BE_STALE("tengu_glacier_2xr", false);
+  return deltaEnabled ? "Deferred tools appear by name in <system-reminder> messages." : "Deferred tools appear by name in <available-deferred-tools> messages.";
+}
+function isDeferredTool(tool) {
+  if (tool.alwaysLoad === true)
+    return false;
+  if (tool.isMcp === true)
+    return true;
+  if (tool.name === TOOL_SEARCH_TOOL_NAME)
+    return false;
+  if (false) {}
+  if (false) {}
+  if (false) {}
+  return tool.shouldDefer === true;
+}
+function formatDeferredToolLine(tool) {
+  return tool.name;
+}
+function getPrompt() {
+  return PROMPT_HEAD + getToolLocationHint() + PROMPT_TAIL;
+}
+var PROMPT_HEAD = `Fetches full schema definitions for deferred tools so they can be called.
+
+`, PROMPT_TAIL = ` Until fetched, only the name is known \u2014 there is no parameter schema, so the tool cannot be invoked. This tool takes a query, matches it against the deferred tool list, and returns the matched tools' complete JSONSchema definitions inside a <functions> block. Once a tool's schema appears in that result, it is callable exactly like any tool defined at the top of the prompt.
+
+Result format: each matched tool appears as one <function>{"description": "...", "name": "...", "parameters": {...}}</function> line inside the <functions> block \u2014 the same encoding as the tool list at the top of this prompt.
+
+Query forms:
+- "select:Read,Edit,Grep" \u2014 fetch these exact tools by name
+- "notebook jupyter" \u2014 keyword search, up to max_results best matches
+- "+slack send" \u2014 require "slack" in the name, rank by remaining terms`;
+var init_prompt = __esm(() => {
+  init_state();
+  init_growthbook();
+  init_constants();
+  init_constants2();
+  init_constants2();
+});
+
+export { TOOL_SEARCH_TOOL_NAME, isDeferredTool, formatDeferredToolLine, getPrompt, init_prompt };

package/dist/chunk-2x3gmbws.js

@@ -0,0 +1,120 @@
+// @bun
+import {
+  getOAuthHeaders,
+  init_api,
+  prepareApiRequest
+} from "./chunk-zkmxtgc3.js";
+import {
+  getGlobalConfig,
+  getOauthAccountInfo,
+  init_auth,
+  init_config1 as init_config,
+  saveGlobalConfig
+} from "./chunk-7wm1rjfm.js";
+import {
+  getOauthConfig,
+  init_oauth
+} from "./chunk-7ymfj7m3.js";
+import {
+  init_log,
+  init_privacyLevel,
+  isEssentialTrafficOnly,
+  logError
+} from "./chunk-p7g7pf3f.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-xszk7n10.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/services/api/overageCreditGrant.ts
+async function fetchOverageCreditGrant() {
+  try {
+    const { accessToken, orgUUID } = await prepareApiRequest();
+    const url = `${getOauthConfig().BASE_API_URL}/api/oauth/organizations/${orgUUID}/overage_credit_grant`;
+    const response = await axios_default.get(url, {
+      headers: getOAuthHeaders(accessToken)
+    });
+    return response.data;
+  } catch (err) {
+    logError(err);
+    return null;
+  }
+}
+function getCachedOverageCreditGrant() {
+  const orgId = getOauthAccountInfo()?.organizationUuid;
+  if (!orgId)
+    return null;
+  const cached = getGlobalConfig().overageCreditGrantCache?.[orgId];
+  if (!cached)
+    return null;
+  if (Date.now() - cached.timestamp > CACHE_TTL_MS)
+    return null;
+  return cached.info;
+}
+function invalidateOverageCreditGrantCache() {
+  const orgId = getOauthAccountInfo()?.organizationUuid;
+  if (!orgId)
+    return;
+  const cache = getGlobalConfig().overageCreditGrantCache;
+  if (!cache || !(orgId in cache))
+    return;
+  saveGlobalConfig((prev) => {
+    const next = { ...prev.overageCreditGrantCache };
+    delete next[orgId];
+    return { ...prev, overageCreditGrantCache: next };
+  });
+}
+async function refreshOverageCreditGrantCache() {
+  if (isEssentialTrafficOnly())
+    return;
+  const orgId = getOauthAccountInfo()?.organizationUuid;
+  if (!orgId)
+    return;
+  const info = await fetchOverageCreditGrant();
+  if (!info)
+    return;
+  saveGlobalConfig((prev) => {
+    const prevCached = prev.overageCreditGrantCache?.[orgId];
+    const existing = prevCached?.info;
+    const dataUnchanged = existing && existing.available === info.available && existing.eligible === info.eligible && existing.granted === info.granted && existing.amount_minor_units === info.amount_minor_units && existing.currency === info.currency;
+    if (dataUnchanged && prevCached && Date.now() - prevCached.timestamp <= CACHE_TTL_MS) {
+      return prev;
+    }
+    const entry = {
+      info: dataUnchanged ? existing : info,
+      timestamp: Date.now()
+    };
+    return {
+      ...prev,
+      overageCreditGrantCache: {
+        ...prev.overageCreditGrantCache,
+        [orgId]: entry
+      }
+    };
+  });
+}
+function formatGrantAmount(info) {
+  if (info.amount_minor_units == null || !info.currency)
+    return null;
+  if (info.currency.toUpperCase() === "USD") {
+    const dollars = info.amount_minor_units / 100;
+    return Number.isInteger(dollars) ? `$${dollars}` : `$${dollars.toFixed(2)}`;
+  }
+  return null;
+}
+var CACHE_TTL_MS;
+var init_overageCreditGrant = __esm(() => {
+  init_axios();
+  init_oauth();
+  init_auth();
+  init_config();
+  init_log();
+  init_privacyLevel();
+  init_api();
+  CACHE_TTL_MS = 60 * 60 * 1000;
+});
+
+export { getCachedOverageCreditGrant, invalidateOverageCreditGrantCache, refreshOverageCreditGrantCache, formatGrantAmount, init_overageCreditGrant };