claude-code-best 1.0.3

package/dist/chunk-qdrwxg3e.js

@@ -0,0 +1,316 @@
+// @bun
+import {
+  StdioServerTransport,
+  init_stdio
+} from "./chunk-a3csma98.js";
+import {
+  init_sink,
+  initializeAnalyticsSink
+} from "./chunk-k808gmhk.js";
+import {
+  createClaudeForChromeMcpServer,
+  init_src
+} from "./chunk-gyj242zr.js";
+import {
+  init_sideQuery,
+  sideQuery
+} from "./chunk-g9q2cznf.js";
+import"./chunk-q1e6pzwh.js";
+import {
+  init_datadog,
+  shutdownDatadog
+} from "./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 {
+  getAllSocketPaths,
+  getSecureSocketPath,
+  init_common
+} from "./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"./chunk-g338npwr.js";
+import"./chunk-2v1br2x0.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-zkmxtgc3.js";
+import"./chunk-m06q12hg.js";
+import"./chunk-grdvmq7q.js";
+import {
+  enableConfigs,
+  getClaudeAIOAuthTokens,
+  getFeatureValue_CACHED_MAY_BE_STALE,
+  getGlobalConfig,
+  init_auth,
+  init_config1 as init_config,
+  init_firstPartyEventLogger,
+  init_growthbook,
+  saveGlobalConfig,
+  shutdown1PEventLogging
+} 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 {
+  init_analytics,
+  logEvent
+} from "./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 {
+  init_debug,
+  logForDebugging
+} from "./chunk-nxsh6de2.js";
+import"./chunk-fbv4apne.js";
+import {
+  init_envUtils,
+  isEnvTruthy
+} from "./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
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/claudeInChrome/mcpServer.ts
+import { format } from "util";
+function isPermissionMode(raw) {
+  return PERMISSION_MODES.some((m) => m === raw);
+}
+function getChromeBridgeUrl() {
+  const bridgeEnabled = process.env.USER_TYPE === "ant" || getFeatureValue_CACHED_MAY_BE_STALE("tengu_copper_bridge", false);
+  if (!bridgeEnabled) {
+    return;
+  }
+  if (isEnvTruthy(process.env.USE_LOCAL_OAUTH) || isEnvTruthy(process.env.LOCAL_BRIDGE)) {
+    return "ws://localhost:8765";
+  }
+  if (isEnvTruthy(process.env.USE_STAGING_OAUTH)) {
+    return "wss://bridge-staging.claudeusercontent.com";
+  }
+  return "wss://bridge.claudeusercontent.com";
+}
+function isLocalBridge() {
+  return isEnvTruthy(process.env.USE_LOCAL_OAUTH) || isEnvTruthy(process.env.LOCAL_BRIDGE);
+}
+function createChromeContext(env) {
+  const logger = new DebugLogger;
+  const chromeBridgeUrl = getChromeBridgeUrl();
+  logger.info(`Bridge URL: ${chromeBridgeUrl ?? "none (using native socket)"}`);
+  const rawPermissionMode = env?.CLAUDE_CHROME_PERMISSION_MODE ?? process.env.CLAUDE_CHROME_PERMISSION_MODE;
+  let initialPermissionMode;
+  if (rawPermissionMode) {
+    if (isPermissionMode(rawPermissionMode)) {
+      initialPermissionMode = rawPermissionMode;
+    } else {
+      logger.warn(`Invalid CLAUDE_CHROME_PERMISSION_MODE "${rawPermissionMode}". Valid values: ${PERMISSION_MODES.join(", ")}`);
+    }
+  }
+  return {
+    serverName: "Claude in Chrome",
+    logger,
+    socketPath: getSecureSocketPath(),
+    getSocketPaths: getAllSocketPaths,
+    clientTypeId: "claude-code",
+    onAuthenticationError: () => {
+      logger.warn("Authentication error occurred. Please ensure you are logged into the Claude browser extension with the same claude.ai account as Claude Code.");
+    },
+    onToolCallDisconnected: () => {
+      return `Browser extension is not connected. Please ensure the Claude browser extension is installed and running (${EXTENSION_DOWNLOAD_URL}), and that you are logged into claude.ai with the same account as Claude Code. If this is your first time connecting to Chrome, you may need to restart Chrome for the installation to take effect. If you continue to experience issues, please report a bug: ${BUG_REPORT_URL}`;
+    },
+    onExtensionPaired: (deviceId, name) => {
+      saveGlobalConfig((config) => {
+        if (config.chromeExtension?.pairedDeviceId === deviceId && config.chromeExtension?.pairedDeviceName === name) {
+          return config;
+        }
+        return {
+          ...config,
+          chromeExtension: {
+            pairedDeviceId: deviceId,
+            pairedDeviceName: name
+          }
+        };
+      });
+      logger.info(`Paired with "${name}" (${deviceId.slice(0, 8)})`);
+    },
+    getPersistedDeviceId: () => {
+      return getGlobalConfig().chromeExtension?.pairedDeviceId;
+    },
+    ...chromeBridgeUrl && {
+      bridgeConfig: {
+        url: chromeBridgeUrl,
+        getUserId: async () => {
+          return getGlobalConfig().oauthAccount?.accountUuid;
+        },
+        getOAuthToken: async () => {
+          return getClaudeAIOAuthTokens()?.accessToken ?? "";
+        },
+        ...isLocalBridge() && { devUserId: "dev_user_local" }
+      }
+    },
+    ...initialPermissionMode && { initialPermissionMode },
+    ...process.env.USER_TYPE === "ant" && {
+      callAnthropicMessages: async (req) => {
+        const response = await sideQuery({
+          model: req.model,
+          system: req.system,
+          messages: req.messages,
+          max_tokens: req.max_tokens,
+          stop_sequences: req.stop_sequences,
+          signal: req.signal,
+          skipSystemPromptPrefix: true,
+          tools: [],
+          querySource: "chrome_mcp"
+        });
+        const textBlocks = [];
+        for (const b of response.content) {
+          if (b.type === "text") {
+            textBlocks.push({ type: "text", text: b.text });
+          }
+        }
+        return {
+          content: textBlocks,
+          stop_reason: response.stop_reason,
+          usage: {
+            input_tokens: response.usage.input_tokens,
+            output_tokens: response.usage.output_tokens
+          }
+        };
+      }
+    },
+    trackEvent: (eventName, metadata) => {
+      const safeMetadata = {};
+      if (metadata) {
+        for (const [key, value] of Object.entries(metadata)) {
+          const safeKey = key === "status" ? "bridge_status" : key;
+          if (typeof value === "boolean" || typeof value === "number") {
+            safeMetadata[safeKey] = value;
+          } else if (typeof value === "string" && SAFE_BRIDGE_STRING_KEYS.has(safeKey)) {
+            safeMetadata[safeKey] = value;
+          }
+        }
+      }
+      logEvent(eventName, safeMetadata);
+    }
+  };
+}
+async function runClaudeInChromeMcpServer() {
+  enableConfigs();
+  initializeAnalyticsSink();
+  const context = createChromeContext();
+  const server = createClaudeForChromeMcpServer(context);
+  const transport = new StdioServerTransport;
+  let exiting = false;
+  const shutdownAndExit = async () => {
+    if (exiting) {
+      return;
+    }
+    exiting = true;
+    await shutdown1PEventLogging();
+    await shutdownDatadog();
+    process.exit(0);
+  };
+  process.stdin.on("end", () => void shutdownAndExit());
+  process.stdin.on("error", () => void shutdownAndExit());
+  logForDebugging("[Claude in Chrome] Starting MCP server");
+  await server.connect(transport);
+  logForDebugging("[Claude in Chrome] MCP server started");
+}
+
+class DebugLogger {
+  silly(message, ...args) {
+    logForDebugging(format(message, ...args), { level: "debug" });
+  }
+  debug(message, ...args) {
+    logForDebugging(format(message, ...args), { level: "debug" });
+  }
+  info(message, ...args) {
+    logForDebugging(format(message, ...args), { level: "info" });
+  }
+  warn(message, ...args) {
+    logForDebugging(format(message, ...args), { level: "warn" });
+  }
+  error(message, ...args) {
+    logForDebugging(format(message, ...args), { level: "error" });
+  }
+}
+var EXTENSION_DOWNLOAD_URL = "https://claude.ai/chrome", BUG_REPORT_URL = "https://github.com/anthropics/claude-code/issues/new?labels=bug,claude-in-chrome", SAFE_BRIDGE_STRING_KEYS, PERMISSION_MODES;
+var init_mcpServer = __esm(() => {
+  init_src();
+  init_stdio();
+  init_datadog();
+  init_firstPartyEventLogger();
+  init_growthbook();
+  init_analytics();
+  init_sink();
+  init_auth();
+  init_config();
+  init_debug();
+  init_envUtils();
+  init_sideQuery();
+  init_common();
+  SAFE_BRIDGE_STRING_KEYS = new Set([
+    "bridge_status",
+    "error_type",
+    "tool_name"
+  ]);
+  PERMISSION_MODES = [
+    "ask",
+    "skip_all_permission_checks",
+    "follow_a_plan"
+  ];
+});
+init_mcpServer();
+
+export {
+  runClaudeInChromeMcpServer,
+  createChromeContext
+};

package/dist/chunk-qnbdekts.js

@@ -0,0 +1,299 @@
+// @bun
+import {
+  init_useMainLoopModel,
+  useMainLoopModel
+} from "./chunk-5a3cw988.js";
+import {
+  getDisplayedEffortLevel,
+  getEffortEnvOverride,
+  getEffortValueDescription,
+  init_AppState,
+  init_effort,
+  isEffortLevel,
+  toPersistableEffort,
+  useAppState,
+  useSetAppState
+} 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"./chunk-pvvew193.js";
+import {
+  require_compiler_runtime
+} 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 {
+  init_settings1 as init_settings,
+  updateSettingsForSource
+} 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 {
+  init_analytics,
+  logEvent
+} from "./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/effort/effort.tsx
+function setEffortValue(effortValue) {
+  const persistable = toPersistableEffort(effortValue);
+  if (persistable !== undefined) {
+    const result = updateSettingsForSource("userSettings", {
+      effortLevel: persistable
+    });
+    if (result.error) {
+      return {
+        message: `Failed to set effort level: ${result.error.message}`
+      };
+    }
+  }
+  logEvent("tengu_effort_command", {
+    effort: effortValue
+  });
+  const envOverride = getEffortEnvOverride();
+  if (envOverride !== undefined && envOverride !== effortValue) {
+    const envRaw = process.env.CLAUDE_CODE_EFFORT_LEVEL;
+    if (persistable === undefined) {
+      return {
+        message: `Not applied: CLAUDE_CODE_EFFORT_LEVEL=${envRaw} overrides effort this session, and ${effortValue} is session-only (nothing saved)`,
+        effortUpdate: {
+          value: effortValue
+        }
+      };
+    }
+    return {
+      message: `CLAUDE_CODE_EFFORT_LEVEL=${envRaw} overrides this session \u2014 clear it and ${effortValue} takes over`,
+      effortUpdate: {
+        value: effortValue
+      }
+    };
+  }
+  const description = getEffortValueDescription(effortValue);
+  const suffix = persistable !== undefined ? "" : " (this session only)";
+  return {
+    message: `Set effort level to ${effortValue}${suffix}: ${description}`,
+    effortUpdate: {
+      value: effortValue
+    }
+  };
+}
+function showCurrentEffort(appStateEffort, model) {
+  const envOverride = getEffortEnvOverride();
+  const effectiveValue = envOverride === null ? undefined : envOverride ?? appStateEffort;
+  if (effectiveValue === undefined) {
+    const level = getDisplayedEffortLevel(model, appStateEffort);
+    return {
+      message: `Effort level: auto (currently ${level})`
+    };
+  }
+  const description = getEffortValueDescription(effectiveValue);
+  return {
+    message: `Current effort level: ${effectiveValue} (${description})`
+  };
+}
+function unsetEffortLevel() {
+  const result = updateSettingsForSource("userSettings", {
+    effortLevel: undefined
+  });
+  if (result.error) {
+    return {
+      message: `Failed to set effort level: ${result.error.message}`
+    };
+  }
+  logEvent("tengu_effort_command", {
+    effort: "auto"
+  });
+  const envOverride = getEffortEnvOverride();
+  if (envOverride !== undefined && envOverride !== null) {
+    const envRaw = process.env.CLAUDE_CODE_EFFORT_LEVEL;
+    return {
+      message: `Cleared effort from settings, but CLAUDE_CODE_EFFORT_LEVEL=${envRaw} still controls this session`,
+      effortUpdate: {
+        value: undefined
+      }
+    };
+  }
+  return {
+    message: "Effort level set to auto",
+    effortUpdate: {
+      value: undefined
+    }
+  };
+}
+function executeEffort(args) {
+  const normalized = args.toLowerCase();
+  if (normalized === "auto" || normalized === "unset") {
+    return unsetEffortLevel();
+  }
+  if (!isEffortLevel(normalized)) {
+    return {
+      message: `Invalid argument: ${args}. Valid options are: low, medium, high, max, auto`
+    };
+  }
+  return setEffortValue(normalized);
+}
+function ShowCurrentEffort(t0) {
+  const {
+    onDone
+  } = t0;
+  const effortValue = useAppState(_temp);
+  const model = useMainLoopModel();
+  const {
+    message
+  } = showCurrentEffort(effortValue, model);
+  onDone(message);
+  return null;
+}
+function _temp(s) {
+  return s.effortValue;
+}
+function ApplyEffortAndClose(t0) {
+  const $ = import_compiler_runtime.c(6);
+  const {
+    result,
+    onDone
+  } = t0;
+  const setAppState = useSetAppState();
+  const {
+    effortUpdate,
+    message
+  } = result;
+  let t1;
+  let t2;
+  if ($[0] !== effortUpdate || $[1] !== message || $[2] !== onDone || $[3] !== setAppState) {
+    t1 = () => {
+      if (effortUpdate) {
+        setAppState((prev) => ({
+          ...prev,
+          effortValue: effortUpdate.value
+        }));
+      }
+      onDone(message);
+    };
+    t2 = [setAppState, effortUpdate, message, onDone];
+    $[0] = effortUpdate;
+    $[1] = message;
+    $[2] = onDone;
+    $[3] = setAppState;
+    $[4] = t1;
+    $[5] = t2;
+  } else {
+    t1 = $[4];
+    t2 = $[5];
+  }
+  React.useEffect(t1, t2);
+  return null;
+}
+async function call(onDone, _context, args) {
+  args = args?.trim() || "";
+  if (COMMON_HELP_ARGS.includes(args)) {
+    onDone(`Usage: /effort [low|medium|high|max|auto]
+
+Effort levels:
+- low: Quick, straightforward implementation
+- medium: Balanced approach with standard testing
+- high: Comprehensive implementation with extensive testing
+- max: Maximum capability with deepest reasoning (Opus 4.6 only)
+- auto: Use the default effort level for your model`);
+    return;
+  }
+  if (!args || args === "current" || args === "status") {
+    return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ShowCurrentEffort, {
+      onDone
+    }, undefined, false, undefined, this);
+  }
+  const result = executeEffort(args);
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ApplyEffortAndClose, {
+    result,
+    onDone
+  }, undefined, false, undefined, this);
+}
+var import_compiler_runtime, React, jsx_dev_runtime, COMMON_HELP_ARGS;
+var init_effort2 = __esm(() => {
+  init_useMainLoopModel();
+  init_analytics();
+  init_AppState();
+  init_effort();
+  init_settings();
+  import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
+  React = __toESM(require_react(), 1);
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+  COMMON_HELP_ARGS = ["help", "-h", "--help"];
+});
+init_effort2();
+
+export {
+  showCurrentEffort,
+  executeEffort,
+  call
+};