claude-code-best 1.0.3

package/dist/chunk-avwewk4v.js

@@ -0,0 +1,176 @@
+// @bun
+import {
+  init_sink,
+  initializeAnalyticsSink
+} from "./chunk-k808gmhk.js";
+import {
+  CACHE_PATHS,
+  attachErrorLogSink,
+  dateToFilename,
+  init_cachePaths,
+  init_log
+} from "./chunk-p7g7pf3f.js";
+import {
+  createBufferedWriter,
+  getFsImplementation,
+  init_bufferedWriter,
+  init_cleanupRegistry,
+  init_debug,
+  init_fsOperations,
+  init_slowOperations,
+  jsonStringify,
+  logForDebugging,
+  registerCleanup
+} from "./chunk-nxsh6de2.js";
+import {
+  getSessionId,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-xszk7n10.js";
+
+// src/utils/sinks.ts
+init_sink();
+
+// src/utils/errorLogSink.ts
+init_axios();
+init_state();
+init_bufferedWriter();
+init_cachePaths();
+init_cleanupRegistry();
+init_debug();
+init_fsOperations();
+init_log();
+init_slowOperations();
+import { dirname, join } from "path";
+var DATE = dateToFilename(new Date);
+function getErrorsPath() {
+  return join(CACHE_PATHS.errors(), DATE + ".jsonl");
+}
+function getMCPLogsPath(serverName) {
+  return join(CACHE_PATHS.mcpLogs(serverName), DATE + ".jsonl");
+}
+function createJsonlWriter(options) {
+  const writer = createBufferedWriter(options);
+  return {
+    write(obj) {
+      writer.write(jsonStringify(obj) + `
+`);
+    },
+    flush: writer.flush,
+    dispose: writer.dispose
+  };
+}
+var logWriters = new Map;
+function getLogWriter(path) {
+  let writer = logWriters.get(path);
+  if (!writer) {
+    const dir = dirname(path);
+    writer = createJsonlWriter({
+      writeFn: (content) => {
+        try {
+          getFsImplementation().appendFileSync(path, content);
+        } catch {
+          getFsImplementation().mkdirSync(dir);
+          getFsImplementation().appendFileSync(path, content);
+        }
+      },
+      flushIntervalMs: 1000,
+      maxBufferSize: 50
+    });
+    logWriters.set(path, writer);
+    registerCleanup(async () => writer?.dispose());
+  }
+  return writer;
+}
+function appendToLog(path, message) {
+  if (process.env.USER_TYPE !== "ant") {
+    return;
+  }
+  const messageWithTimestamp = {
+    timestamp: new Date().toISOString(),
+    ...message,
+    cwd: getFsImplementation().cwd(),
+    userType: process.env.USER_TYPE,
+    sessionId: getSessionId(),
+    version: "2.1.888"
+  };
+  getLogWriter(path).write(messageWithTimestamp);
+}
+function extractServerMessage(data) {
+  if (typeof data === "string") {
+    return data;
+  }
+  if (data && typeof data === "object") {
+    const obj = data;
+    if (typeof obj.message === "string") {
+      return obj.message;
+    }
+    if (typeof obj.error === "object" && obj.error && "message" in obj.error && typeof obj.error.message === "string") {
+      return obj.error.message;
+    }
+  }
+  return;
+}
+function logErrorImpl(error) {
+  const errorStr = error.stack || error.message;
+  let context = "";
+  if (axios_default.isAxiosError(error) && error.config?.url) {
+    const parts = [`url=${error.config.url}`];
+    if (error.response?.status !== undefined) {
+      parts.push(`status=${error.response.status}`);
+    }
+    const serverMessage = extractServerMessage(error.response?.data);
+    if (serverMessage) {
+      parts.push(`body=${serverMessage}`);
+    }
+    context = `[${parts.join(",")}] `;
+  }
+  logForDebugging(`${error.name}: ${context}${errorStr}`, { level: "error" });
+  appendToLog(getErrorsPath(), {
+    error: `${context}${errorStr}`
+  });
+}
+function logMCPErrorImpl(serverName, error) {
+  logForDebugging(`MCP server "${serverName}" ${error}`, { level: "error" });
+  const logFile = getMCPLogsPath(serverName);
+  const errorStr = error instanceof Error ? error.stack || error.message : String(error);
+  const errorInfo = {
+    error: errorStr,
+    timestamp: new Date().toISOString(),
+    sessionId: getSessionId(),
+    cwd: getFsImplementation().cwd()
+  };
+  getLogWriter(logFile).write(errorInfo);
+}
+function logMCPDebugImpl(serverName, message) {
+  logForDebugging(`MCP server "${serverName}": ${message}`);
+  const logFile = getMCPLogsPath(serverName);
+  const debugInfo = {
+    debug: message,
+    timestamp: new Date().toISOString(),
+    sessionId: getSessionId(),
+    cwd: getFsImplementation().cwd()
+  };
+  getLogWriter(logFile).write(debugInfo);
+}
+function initializeErrorLogSink() {
+  attachErrorLogSink({
+    logError: logErrorImpl,
+    logMCPError: logMCPErrorImpl,
+    logMCPDebug: logMCPDebugImpl,
+    getErrorsPath,
+    getMCPLogsPath
+  });
+  logForDebugging("Error log sink initialized");
+}
+
+// src/utils/sinks.ts
+function initSinks() {
+  initializeErrorLogSink();
+  initializeAnalyticsSink();
+}
+
+export { initSinks };

package/dist/chunk-b0105v1f.js

@@ -0,0 +1,79 @@
+// @bun
+import {
+  getRepoClassCached,
+  init_commitAttribution
+} from "./chunk-hgtf13es.js";
+import {
+  getGlobalConfig,
+  init_config1 as init_config
+} from "./chunk-7wm1rjfm.js";
+import {
+  init_envUtils,
+  isEnvTruthy
+} from "./chunk-3r24h7t6.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/undercover.ts
+function isUndercover() {
+  if (process.env.USER_TYPE === "ant") {
+    if (isEnvTruthy(process.env.CLAUDE_CODE_UNDERCOVER))
+      return true;
+    return getRepoClassCached() !== "internal";
+  }
+  return false;
+}
+function getUndercoverInstructions() {
+  if (process.env.USER_TYPE === "ant") {
+    return `## UNDERCOVER MODE \u2014 CRITICAL
+
+You are operating UNDERCOVER in a PUBLIC/OPEN-SOURCE repository. Your commit
+messages, PR titles, and PR bodies MUST NOT contain ANY Anthropic-internal
+information. Do not blow your cover.
+
+NEVER include in commit messages or PR descriptions:
+- Internal model codenames (animal names like Capybara, Tengu, etc.)
+- Unreleased model version numbers (e.g., opus-4-7, sonnet-4-8)
+- Internal repo or project names (e.g., claude-cli-internal, anthropics/\u2026)
+- Internal tooling, Slack channels, or short links (e.g., go/cc, #claude-code-\u2026)
+- The phrase "Claude Code" or any mention that you are an AI
+- Any hint of what model or version you are
+- Co-Authored-By lines or any other attribution
+
+Write commit messages as a human developer would \u2014 describe only what the code
+change does.
+
+GOOD:
+- "Fix race condition in file watcher initialization"
+- "Add support for custom key bindings"
+- "Refactor parser for better error messages"
+
+BAD (never write these):
+- "Fix bug found while testing with Claude Capybara"
+- "1-shotted by claude-opus-4-6"
+- "Generated with Claude Code"
+- "Co-Authored-By: Claude Opus 4.6 <\u2026>"
+`;
+  }
+  return "";
+}
+function shouldShowUndercoverAutoNotice() {
+  if (process.env.USER_TYPE === "ant") {
+    if (isEnvTruthy(process.env.CLAUDE_CODE_UNDERCOVER))
+      return false;
+    if (!isUndercover())
+      return false;
+    if (getGlobalConfig().hasSeenUndercoverAutoNotice)
+      return false;
+    return true;
+  }
+  return false;
+}
+var init_undercover = __esm(() => {
+  init_commitAttribution();
+  init_config();
+  init_envUtils();
+});
+
+export { isUndercover, getUndercoverInstructions, shouldShowUndercoverAutoNotice, init_undercover };

package/dist/chunk-b4wg70y1.js

@@ -0,0 +1,54 @@
+// @bun
+import {
+  __commonJS
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@aws-sdk+core@3.973.26/node_modules/@aws-sdk/core/dist-cjs/submodules/client/index.js
+var require_client = __commonJS((exports) => {
+  var state = {
+    warningEmitted: false
+  };
+  var emitWarningIfUnsupportedVersion = (version) => {
+    if (version && !state.warningEmitted && parseInt(version.substring(1, version.indexOf("."))) < 20) {
+      state.warningEmitted = true;
+      process.emitWarning(`NodeDeprecationWarning: The AWS SDK for JavaScript (v3) will
+no longer support Node.js ${version} in January 2026.
+
+To continue receiving updates to AWS services, bug fixes, and security
+updates please upgrade to a supported Node.js LTS version.
+
+More information can be found at: https://a.co/c895JFp`);
+    }
+  };
+  function setCredentialFeature(credentials, feature, value) {
+    if (!credentials.$source) {
+      credentials.$source = {};
+    }
+    credentials.$source[feature] = value;
+    return credentials;
+  }
+  function setFeature(context, feature, value) {
+    if (!context.__aws_sdk_context) {
+      context.__aws_sdk_context = {
+        features: {}
+      };
+    } else if (!context.__aws_sdk_context.features) {
+      context.__aws_sdk_context.features = {};
+    }
+    context.__aws_sdk_context.features[feature] = value;
+  }
+  function setTokenFeature(token, feature, value) {
+    if (!token.$source) {
+      token.$source = {};
+    }
+    token.$source[feature] = value;
+    return token;
+  }
+  exports.emitWarningIfUnsupportedVersion = emitWarningIfUnsupportedVersion;
+  exports.setCredentialFeature = setCredentialFeature;
+  exports.setFeature = setFeature;
+  exports.setTokenFeature = setTokenFeature;
+  exports.state = state;
+});
+
+export { require_client };

package/dist/chunk-bjqw6798.js

@@ -0,0 +1,328 @@
+// @bun
+import {
+  DEFAULT_MANIFEST_VERSION,
+  EXCLUDE_PATTERNS,
+  LATEST_MANIFEST_VERSION,
+  MANIFEST_SCHEMAS,
+  MANIFEST_SCHEMAS_LOOSE,
+  McpbManifestSchema,
+  McpbManifestSchema1 as McpbManifestSchema2,
+  McpbManifestSchema2 as McpbManifestSchema3,
+  McpbManifestSchema3 as McpbManifestSchema4,
+  buildManifest,
+  cleanMcpb,
+  createMcpConfig,
+  exports_0_1,
+  exports_0_2,
+  exports_0_3,
+  exports_0_4,
+  extractSignatureBlock,
+  getAllFiles,
+  getAllFilesWithCount,
+  getDefaultAuthorEmail,
+  getDefaultAuthorInfo,
+  getDefaultAuthorName,
+  getDefaultAuthorUrl,
+  getDefaultBasicInfo,
+  getDefaultEntryPoint,
+  getDefaultOptionalFields,
+  getDefaultRepositoryUrl,
+  getDefaultServerConfig,
+  initExtension,
+  init_0_1,
+  init_0_2,
+  init_0_3,
+  init_0_4,
+  init_constants,
+  init_files,
+  init_init,
+  init_pack,
+  init_sign,
+  init_unpack,
+  init_validate,
+  packExtension,
+  printNextSteps,
+  promptAuthorInfo,
+  promptBasicInfo,
+  promptCompatibility,
+  promptLocalization,
+  promptLongDescription,
+  promptOptionalFields,
+  promptPrompts,
+  promptServerConfig,
+  promptTools,
+  promptUrls,
+  promptUserConfig,
+  promptVisualAssets,
+  readMcpbIgnorePatterns,
+  readPackageJson,
+  shouldExclude,
+  signMcpbFile,
+  unpackExtension,
+  unsignMcpbFile,
+  validateManifest,
+  verifyCertificateChain,
+  verifyMcpbFile
+} from "./chunk-2t3vw4tx.js";
+import"./chunk-vyjeh50y.js";
+import"./chunk-v78fj8by.js";
+import"./chunk-sd36yzx8.js";
+import {
+  exports_external,
+  init_zod,
+  unionType
+} from "./chunk-v9smspw2.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-sdj9b9wh.js";
+import {
+  __esm,
+  __export
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@anthropic-ai+mcpb@2.1.2/node_modules/@anthropic-ai/mcpb/dist/schemas/any.js
+var exports_any = {};
+__export(exports_any, {
+  McpbManifestSchema: () => McpbManifestSchema5
+});
+var McpbManifestSchema5;
+var init_any = __esm(() => {
+  init_zod();
+  init_0_1();
+  init_0_2();
+  init_0_3();
+  init_0_4();
+  McpbManifestSchema5 = unionType([
+    McpbManifestSchema,
+    McpbManifestSchema2,
+    McpbManifestSchema3,
+    McpbManifestSchema4
+  ]);
+});
+
+// node_modules/.bun/@anthropic-ai+mcpb@2.1.2/node_modules/@anthropic-ai/mcpb/dist/schemas/index.js
+var VERSIONED_MANIFEST_SCHEMAS;
+var init_schemas = __esm(() => {
+  init_0_1();
+  init_0_2();
+  init_0_3();
+  init_0_4();
+  init_0_1();
+  init_0_2();
+  init_0_3();
+  init_0_4();
+  init_any();
+  VERSIONED_MANIFEST_SCHEMAS = {
+    "0.1": McpbManifestSchema,
+    "0.2": McpbManifestSchema2,
+    "0.3": McpbManifestSchema3,
+    "0.4": McpbManifestSchema4
+  };
+});
+
+// node_modules/.bun/@anthropic-ai+mcpb@2.1.2/node_modules/@anthropic-ai/mcpb/dist/shared/common.js
+var McpbUserConfigValuesSchema, McpbSignatureInfoSchema;
+var init_common = __esm(() => {
+  init_zod();
+  McpbUserConfigValuesSchema = exports_external.record(exports_external.string(), exports_external.union([exports_external.string(), exports_external.number(), exports_external.boolean(), exports_external.array(exports_external.string())]));
+  McpbSignatureInfoSchema = exports_external.strictObject({
+    status: exports_external.enum(["signed", "unsigned", "self-signed"]),
+    publisher: exports_external.string().optional(),
+    issuer: exports_external.string().optional(),
+    valid_from: exports_external.string().optional(),
+    valid_to: exports_external.string().optional(),
+    fingerprint: exports_external.string().optional()
+  });
+});
+
+// node_modules/.bun/@anthropic-ai+mcpb@2.1.2/node_modules/@anthropic-ai/mcpb/dist/shared/config.js
+function replaceVariables(value, variables) {
+  if (typeof value === "string") {
+    let result = value;
+    for (const [key, replacement] of Object.entries(variables)) {
+      const pattern = new RegExp(`\\$\\{${key}\\}`, "g");
+      if (result.match(pattern)) {
+        if (Array.isArray(replacement)) {
+          console.warn(`Cannot replace ${key} with array value in string context: "${value}"`, { key, replacement });
+        } else {
+          result = result.replace(pattern, replacement);
+        }
+      }
+    }
+    return result;
+  } else if (Array.isArray(value)) {
+    const result = [];
+    for (const item of value) {
+      if (typeof item === "string" && item.match(/^\$\{user_config\.[^}]+\}$/)) {
+        const varName = item.match(/^\$\{([^}]+)\}$/)?.[1];
+        if (varName && variables[varName]) {
+          const replacement = variables[varName];
+          if (Array.isArray(replacement)) {
+            result.push(...replacement);
+          } else {
+            result.push(replacement);
+          }
+        } else {
+          result.push(item);
+        }
+      } else {
+        result.push(replaceVariables(item, variables));
+      }
+    }
+    return result;
+  } else if (value && typeof value === "object") {
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      result[key] = replaceVariables(val, variables);
+    }
+    return result;
+  }
+  return value;
+}
+async function getMcpConfigForManifest(options) {
+  const { manifest, extensionPath, systemDirs, userConfig, pathSeparator, logger } = options;
+  const baseConfig = manifest.server?.mcp_config;
+  if (!baseConfig) {
+    return;
+  }
+  let result = {
+    ...baseConfig
+  };
+  if (baseConfig.platform_overrides) {
+    if (process.platform in baseConfig.platform_overrides) {
+      const platformConfig = baseConfig.platform_overrides[process.platform];
+      result.command = platformConfig.command || result.command;
+      result.args = platformConfig.args || result.args;
+      result.env = platformConfig.env || result.env;
+    }
+  }
+  if (hasRequiredConfigMissing({ manifest, userConfig })) {
+    logger?.warn(`Extension ${manifest.name} has missing required configuration, skipping MCP config`);
+    return;
+  }
+  const variables = {
+    __dirname: extensionPath,
+    pathSeparator,
+    "/": pathSeparator,
+    ...systemDirs
+  };
+  const mergedConfig = {};
+  if (manifest.user_config) {
+    for (const [key, configOption] of Object.entries(manifest.user_config)) {
+      if (configOption.default !== undefined) {
+        mergedConfig[key] = configOption.default;
+      }
+    }
+  }
+  if (userConfig) {
+    Object.assign(mergedConfig, userConfig);
+  }
+  for (const [key, value] of Object.entries(mergedConfig)) {
+    const userConfigKey = `user_config.${key}`;
+    if (Array.isArray(value)) {
+      variables[userConfigKey] = value.map(String);
+    } else if (typeof value === "boolean") {
+      variables[userConfigKey] = value ? "true" : "false";
+    } else {
+      variables[userConfigKey] = String(value);
+    }
+  }
+  result = replaceVariables(result, variables);
+  return result;
+}
+function isInvalidSingleValue(value) {
+  return value === undefined || value === null || value === "";
+}
+function hasRequiredConfigMissing({ manifest, userConfig }) {
+  if (!manifest.user_config) {
+    return false;
+  }
+  const config = userConfig || {};
+  for (const [key, configOption] of Object.entries(manifest.user_config)) {
+    if (configOption.required) {
+      const value = config[key];
+      if (isInvalidSingleValue(value) || Array.isArray(value) && (value.length === 0 || value.some(isInvalidSingleValue))) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+var init_config = () => {};
+
+// node_modules/.bun/@anthropic-ai+mcpb@2.1.2/node_modules/@anthropic-ai/mcpb/dist/types.js
+var init_types = () => {};
+
+// node_modules/.bun/@anthropic-ai+mcpb@2.1.2/node_modules/@anthropic-ai/mcpb/dist/index.js
+var init_dist = __esm(() => {
+  init_init();
+  init_pack();
+  init_unpack();
+  init_files();
+  init_sign();
+  init_validate();
+  init_schemas();
+  init_common();
+  init_config();
+  init_constants();
+  init_types();
+});
+init_dist();
+
+export {
+  verifyMcpbFile,
+  verifyCertificateChain,
+  validateManifest,
+  exports_any as vAny,
+  exports_0_4 as v0_4,
+  exports_0_3 as v0_3,
+  exports_0_2 as v0_2,
+  exports_0_1 as v0_1,
+  unsignMcpbFile,
+  unpackExtension,
+  signMcpbFile,
+  shouldExclude,
+  replaceVariables,
+  readPackageJson,
+  readMcpbIgnorePatterns,
+  promptVisualAssets,
+  promptUserConfig,
+  promptUrls,
+  promptTools,
+  promptServerConfig,
+  promptPrompts,
+  promptOptionalFields,
+  promptLongDescription,
+  promptLocalization,
+  promptCompatibility,
+  promptBasicInfo,
+  promptAuthorInfo,
+  printNextSteps,
+  packExtension,
+  initExtension,
+  hasRequiredConfigMissing,
+  getMcpConfigForManifest,
+  getDefaultServerConfig,
+  getDefaultRepositoryUrl,
+  getDefaultOptionalFields,
+  getDefaultEntryPoint,
+  getDefaultBasicInfo,
+  getDefaultAuthorUrl,
+  getDefaultAuthorName,
+  getDefaultAuthorInfo,
+  getDefaultAuthorEmail,
+  getAllFilesWithCount,
+  getAllFiles,
+  extractSignatureBlock,
+  createMcpConfig,
+  cleanMcpb,
+  buildManifest,
+  VERSIONED_MANIFEST_SCHEMAS,
+  McpbUserConfigValuesSchema,
+  McpbSignatureInfoSchema,
+  MANIFEST_SCHEMAS_LOOSE,
+  MANIFEST_SCHEMAS,
+  LATEST_MANIFEST_VERSION,
+  EXCLUDE_PATTERNS,
+  DEFAULT_MANIFEST_VERSION
+};

package/dist/chunk-bm1qb16p.js

@@ -0,0 +1,17 @@
+// @bun
+import {
+  BROWSER_TOOLS,
+  ClaudeForChromeContext,
+  Logger,
+  createClaudeForChromeMcpServer,
+  init_src
+} from "./chunk-gyj242zr.js";
+import"./chunk-qp2qdcda.js";
+init_src();
+
+export {
+  createClaudeForChromeMcpServer,
+  Logger,
+  ClaudeForChromeContext,
+  BROWSER_TOOLS
+};