lcclaude 1.0.0

package/dist/src/utils/dxt/helpers.js

@@ -0,0 +1,36 @@
+import { errorMessage } from "../errors.js";
+import { jsonParse } from "../slowOperations.js";
+export async function validateManifest(manifestJson) {
+  const { McpbManifestSchema } = await import("@anthropic-ai/mcpb");
+  const parseResult = McpbManifestSchema.safeParse(manifestJson);
+  if (!parseResult.success) {
+    const errors = parseResult.error.flatten();
+    const errorMessages = [
+      ...Object.entries(errors.fieldErrors).map(([field, errs]) => `${field}: ${errs?.join(", ")}`),
+      ...errors.formErrors || []
+    ].filter(Boolean).join("; ");
+    throw new Error(`Invalid manifest: ${errorMessages}`);
+  }
+  return parseResult.data;
+}
+export async function parseAndValidateManifestFromText(manifestText) {
+  let manifestJson;
+  try {
+    manifestJson = jsonParse(manifestText);
+  } catch (error) {
+    throw new Error(`Invalid JSON in manifest.json: ${errorMessage(error)}`);
+  }
+  return validateManifest(manifestJson);
+}
+export async function parseAndValidateManifestFromBytes(manifestData) {
+  const manifestText = new TextDecoder().decode(manifestData);
+  return parseAndValidateManifestFromText(manifestText);
+}
+export function generateExtensionId(manifest, prefix) {
+  const sanitize = (str) => str.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-_.]/g, "").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+  const authorName = manifest.author.name;
+  const extensionName = manifest.name;
+  const sanitizedAuthor = sanitize(authorName);
+  const sanitizedName = sanitize(extensionName);
+  return prefix ? `${prefix}.${sanitizedAuthor}.${sanitizedName}` : `${sanitizedAuthor}.${sanitizedName}`;
+}

package/dist/src/utils/dxt/zip.js

@@ -0,0 +1,112 @@
+import { isAbsolute, normalize } from "path";
+import { logForDebugging } from "../debug.js";
+import { isENOENT } from "../errors.js";
+import { getFsImplementation } from "../fsOperations.js";
+import { containsPathTraversal } from "../path.js";
+const LIMITS = {
+  MAX_FILE_SIZE: 512 * 1024 * 1024,
+  MAX_TOTAL_SIZE: 1024 * 1024 * 1024,
+  MAX_FILE_COUNT: 1e5,
+  MAX_COMPRESSION_RATIO: 50,
+  MIN_COMPRESSION_RATIO: 0.5
+};
+export function isPathSafe(filePath) {
+  if (containsPathTraversal(filePath)) {
+    return false;
+  }
+  const normalized = normalize(filePath);
+  if (isAbsolute(normalized)) {
+    return false;
+  }
+  return true;
+}
+export function validateZipFile(file, state) {
+  state.fileCount++;
+  let error;
+  if (state.fileCount > LIMITS.MAX_FILE_COUNT) {
+    error = `Archive contains too many files: ${state.fileCount} (max: ${LIMITS.MAX_FILE_COUNT})`;
+  }
+  if (!isPathSafe(file.name)) {
+    error = `Unsafe file path detected: "${file.name}". Path traversal or absolute paths are not allowed.`;
+  }
+  const fileSize = file.originalSize || 0;
+  if (fileSize > LIMITS.MAX_FILE_SIZE) {
+    error = `File "${file.name}" is too large: ${Math.round(fileSize / 1024 / 1024)}MB (max: ${Math.round(LIMITS.MAX_FILE_SIZE / 1024 / 1024)}MB)`;
+  }
+  state.totalUncompressedSize += fileSize;
+  if (state.totalUncompressedSize > LIMITS.MAX_TOTAL_SIZE) {
+    error = `Archive total size is too large: ${Math.round(state.totalUncompressedSize / 1024 / 1024)}MB (max: ${Math.round(LIMITS.MAX_TOTAL_SIZE / 1024 / 1024)}MB)`;
+  }
+  const currentRatio = state.totalUncompressedSize / state.compressedSize;
+  if (currentRatio > LIMITS.MAX_COMPRESSION_RATIO) {
+    error = `Suspicious compression ratio detected: ${currentRatio.toFixed(1)}:1 (max: ${LIMITS.MAX_COMPRESSION_RATIO}:1). This may be a zip bomb.`;
+  }
+  return error ? { isValid: false, error } : { isValid: true };
+}
+export async function unzipFile(zipData) {
+  const { unzipSync } = await import("fflate");
+  const compressedSize = zipData.length;
+  const state = {
+    fileCount: 0,
+    totalUncompressedSize: 0,
+    compressedSize,
+    errors: []
+  };
+  const result = unzipSync(new Uint8Array(zipData), {
+    filter: (file) => {
+      const validationResult = validateZipFile(file, state);
+      if (!validationResult.isValid) {
+        throw new Error(validationResult.error);
+      }
+      return true;
+    }
+  });
+  logForDebugging(`Zip extraction completed: ${state.fileCount} files, ${Math.round(state.totalUncompressedSize / 1024)}KB uncompressed`);
+  return result;
+}
+export function parseZipModes(data) {
+  const buf = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+  const modes = {};
+  const minEocd = Math.max(0, buf.length - 22 - 65535);
+  let eocd = -1;
+  for (let i = buf.length - 22;i >= minEocd; i--) {
+    if (buf.readUInt32LE(i) === 101010256) {
+      eocd = i;
+      break;
+    }
+  }
+  if (eocd < 0)
+    return modes;
+  const entryCount = buf.readUInt16LE(eocd + 10);
+  let off = buf.readUInt32LE(eocd + 16);
+  for (let i = 0;i < entryCount; i++) {
+    if (off + 46 > buf.length || buf.readUInt32LE(off) !== 33639248)
+      break;
+    const versionMadeBy = buf.readUInt16LE(off + 4);
+    const nameLen = buf.readUInt16LE(off + 28);
+    const extraLen = buf.readUInt16LE(off + 30);
+    const commentLen = buf.readUInt16LE(off + 32);
+    const externalAttr = buf.readUInt32LE(off + 38);
+    const name = buf.toString("utf8", off + 46, off + 46 + nameLen);
+    if (versionMadeBy >> 8 === 3) {
+      const mode = externalAttr >>> 16 & 65535;
+      if (mode)
+        modes[name] = mode;
+    }
+    off += 46 + nameLen + extraLen + commentLen;
+  }
+  return modes;
+}
+export async function readAndUnzipFile(filePath) {
+  const fs = getFsImplementation();
+  try {
+    const zipData = await fs.readFileBytes(filePath);
+    return await unzipFile(zipData);
+  } catch (error) {
+    if (isENOENT(error)) {
+      throw error;
+    }
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to read or unzip file: ${errorMessage}`);
+  }
+}

package/dist/src/utils/earlyInput.js

@@ -0,0 +1,98 @@
+import { lastGrapheme } from "./intl.js";
+let earlyInputBuffer = "";
+let isCapturing = false;
+let readableHandler = null;
+export function startCapturingEarlyInput() {
+  if (!process.stdin.isTTY || isCapturing || process.argv.includes("-p") || process.argv.includes("--print")) {
+    return;
+  }
+  isCapturing = true;
+  earlyInputBuffer = "";
+  try {
+    process.stdin.setEncoding("utf8");
+    process.stdin.setRawMode(true);
+    process.stdin.ref();
+    readableHandler = () => {
+      let chunk = process.stdin.read();
+      while (chunk !== null) {
+        if (typeof chunk === "string") {
+          processChunk(chunk);
+        }
+        chunk = process.stdin.read();
+      }
+    };
+    process.stdin.on("readable", readableHandler);
+  } catch {
+    isCapturing = false;
+  }
+}
+function processChunk(str) {
+  let i = 0;
+  while (i < str.length) {
+    const char = str[i];
+    const code = char.charCodeAt(0);
+    if (code === 3) {
+      stopCapturingEarlyInput();
+      process.exit(130);
+      return;
+    }
+    if (code === 4) {
+      stopCapturingEarlyInput();
+      return;
+    }
+    if (code === 127 || code === 8) {
+      if (earlyInputBuffer.length > 0) {
+        const last = lastGrapheme(earlyInputBuffer);
+        earlyInputBuffer = earlyInputBuffer.slice(0, -(last.length || 1));
+      }
+      i++;
+      continue;
+    }
+    if (code === 27) {
+      i++;
+      while (i < str.length && !(str.charCodeAt(i) >= 64 && str.charCodeAt(i) <= 126)) {
+        i++;
+      }
+      if (i < str.length)
+        i++;
+      continue;
+    }
+    if (code < 32 && code !== 9 && code !== 10 && code !== 13) {
+      i++;
+      continue;
+    }
+    if (code === 13) {
+      earlyInputBuffer += `
+`;
+      i++;
+      continue;
+    }
+    earlyInputBuffer += char;
+    i++;
+  }
+}
+export function stopCapturingEarlyInput() {
+  if (!isCapturing) {
+    return;
+  }
+  isCapturing = false;
+  if (readableHandler) {
+    process.stdin.removeListener("readable", readableHandler);
+    readableHandler = null;
+  }
+}
+export function consumeEarlyInput() {
+  stopCapturingEarlyInput();
+  const input = earlyInputBuffer.trim();
+  earlyInputBuffer = "";
+  return input;
+}
+export function hasEarlyInput() {
+  return earlyInputBuffer.trim().length > 0;
+}
+export function seedEarlyInput(text) {
+  earlyInputBuffer = text;
+}
+export function isCapturingEarlyInput() {
+  return isCapturing;
+}

package/dist/src/utils/editor.js

@@ -0,0 +1,105 @@
+import {
+  spawn,
+  spawnSync
+} from "child_process";
+import memoize from "lodash-es/memoize.js";
+import { basename } from "path";
+import instances from "../ink/instances.js";
+import { logForDebugging } from "./debug.js";
+import { whichSync } from "./which.js";
+function isCommandAvailable(command) {
+  return !!whichSync(command);
+}
+const GUI_EDITORS = [
+  "code",
+  "cursor",
+  "windsurf",
+  "codium",
+  "subl",
+  "atom",
+  "gedit",
+  "notepad++",
+  "notepad"
+];
+const PLUS_N_EDITORS = /\b(vi|vim|nvim|nano|emacs|pico|micro|helix|hx)\b/;
+const VSCODE_FAMILY = new Set(["code", "cursor", "windsurf", "codium"]);
+export function classifyGuiEditor(editor) {
+  const base = basename(editor.split(" ")[0] ?? "");
+  return GUI_EDITORS.find((g) => base.includes(g));
+}
+function guiGotoArgv(guiFamily, filePath, line) {
+  if (!line)
+    return [filePath];
+  if (VSCODE_FAMILY.has(guiFamily))
+    return ["-g", `${filePath}:${line}`];
+  if (guiFamily === "subl")
+    return [`${filePath}:${line}`];
+  return [filePath];
+}
+export function openFileInExternalEditor(filePath, line) {
+  const editor = getExternalEditor();
+  if (!editor)
+    return false;
+  const parts = editor.split(" ");
+  const base = parts[0] ?? editor;
+  const editorArgs = parts.slice(1);
+  const guiFamily = classifyGuiEditor(editor);
+  if (guiFamily) {
+    const gotoArgv = guiGotoArgv(guiFamily, filePath, line);
+    const detachedOpts = { detached: true, stdio: "ignore" };
+    let child;
+    if (process.platform === "win32") {
+      const gotoStr = gotoArgv.map((a) => `"${a}"`).join(" ");
+      child = spawn(`${editor} ${gotoStr}`, { ...detachedOpts, shell: true });
+    } else {
+      child = spawn(base, [...editorArgs, ...gotoArgv], detachedOpts);
+    }
+    child.on("error", (e) => logForDebugging(`editor spawn failed: ${e}`, { level: "error" }));
+    child.unref();
+    return true;
+  }
+  const inkInstance = instances.get(process.stdout);
+  if (!inkInstance)
+    return false;
+  const useGotoLine = line && PLUS_N_EDITORS.test(basename(base));
+  inkInstance.enterAlternateScreen();
+  try {
+    const syncOpts = { stdio: "inherit" };
+    let result;
+    if (process.platform === "win32") {
+      const lineArg = useGotoLine ? `+${line} ` : "";
+      result = spawnSync(`${editor} ${lineArg}"${filePath}"`, {
+        ...syncOpts,
+        shell: true
+      });
+    } else {
+      const args = [
+        ...editorArgs,
+        ...useGotoLine ? [`+${line}`, filePath] : [filePath]
+      ];
+      result = spawnSync(base, args, syncOpts);
+    }
+    if (result.error) {
+      logForDebugging(`editor spawn failed: ${result.error}`, {
+        level: "error"
+      });
+      return false;
+    }
+    return true;
+  } finally {
+    inkInstance.exitAlternateScreen();
+  }
+}
+export const getExternalEditor = memoize(() => {
+  if (process.env.VISUAL?.trim()) {
+    return process.env.VISUAL.trim();
+  }
+  if (process.env.EDITOR?.trim()) {
+    return process.env.EDITOR.trim();
+  }
+  if (process.platform === "win32") {
+    return "start /wait notepad";
+  }
+  const editors = ["code", "vi", "nano"];
+  return editors.find((command) => isCommandAvailable(command));
+});

package/dist/src/utils/effort.js

@@ -0,0 +1,188 @@
+import { isUltrathinkEnabled } from "./thinking.js";
+import { getInitialSettings } from "./settings/settings.js";
+import { isProSubscriber, isMaxSubscriber, isTeamSubscriber } from "./auth.js";
+import { getFeatureValue_CACHED_MAY_BE_STALE } from "../services/analytics/growthbook.js";
+import { getAPIProvider } from "./model/providers.js";
+import { get3PModelCapabilityOverride } from "./model/modelSupportOverrides.js";
+import { isEnvTruthy } from "./envUtils.js";
+export const EFFORT_LEVELS = [
+  "low",
+  "medium",
+  "high",
+  "max"
+];
+export function modelSupportsEffort(model) {
+  const m = model.toLowerCase();
+  if (isEnvTruthy(process.env.CLAUDE_CODE_ALWAYS_ENABLE_EFFORT)) {
+    return true;
+  }
+  const supported3P = get3PModelCapabilityOverride(model, "effort");
+  if (supported3P !== undefined) {
+    return supported3P;
+  }
+  if (m.includes("opus-4-6") || m.includes("sonnet-4-6")) {
+    return true;
+  }
+  if (m.includes("haiku") || m.includes("sonnet") || m.includes("opus")) {
+    return false;
+  }
+  return getAPIProvider() === "firstParty";
+}
+export function modelSupportsMaxEffort(model) {
+  const supported3P = get3PModelCapabilityOverride(model, "max_effort");
+  if (supported3P !== undefined) {
+    return supported3P;
+  }
+  if (model.toLowerCase().includes("opus-4-6")) {
+    return true;
+  }
+  if (process.env.USER_TYPE === "ant" && resolveAntModel(model)) {
+    return true;
+  }
+  return false;
+}
+export function isEffortLevel(value) {
+  return EFFORT_LEVELS.includes(value);
+}
+export function parseEffortValue(value) {
+  if (value === undefined || value === null || value === "") {
+    return;
+  }
+  if (typeof value === "number" && isValidNumericEffort(value)) {
+    return value;
+  }
+  const str = String(value).toLowerCase();
+  if (isEffortLevel(str)) {
+    return str;
+  }
+  const numericValue = parseInt(str, 10);
+  if (!isNaN(numericValue) && isValidNumericEffort(numericValue)) {
+    return numericValue;
+  }
+  return;
+}
+export function toPersistableEffort(value) {
+  if (value === "low" || value === "medium" || value === "high") {
+    return value;
+  }
+  if (value === "max" && process.env.USER_TYPE === "ant") {
+    return value;
+  }
+  return;
+}
+export function getInitialEffortSetting() {
+  return toPersistableEffort(getInitialSettings().effortLevel);
+}
+export function resolvePickerEffortPersistence(picked, modelDefault, priorPersisted, toggledInPicker) {
+  const hadExplicit = priorPersisted !== undefined || toggledInPicker;
+  return hadExplicit || picked !== modelDefault ? picked : undefined;
+}
+export function getEffortEnvOverride() {
+  const envOverride = process.env.CLAUDE_CODE_EFFORT_LEVEL;
+  return envOverride?.toLowerCase() === "unset" || envOverride?.toLowerCase() === "auto" ? null : parseEffortValue(envOverride);
+}
+export function resolveAppliedEffort(model, appStateEffortValue) {
+  const envOverride = getEffortEnvOverride();
+  if (envOverride === null) {
+    return;
+  }
+  const resolved = envOverride ?? appStateEffortValue ?? getDefaultEffortForModel(model);
+  if (resolved === "max" && !modelSupportsMaxEffort(model)) {
+    return "high";
+  }
+  return resolved;
+}
+export function getDisplayedEffortLevel(model, appStateEffort) {
+  const resolved = resolveAppliedEffort(model, appStateEffort) ?? "high";
+  return convertEffortValueToLevel(resolved);
+}
+export function getEffortSuffix(model, effortValue) {
+  if (effortValue === undefined)
+    return "";
+  const resolved = resolveAppliedEffort(model, effortValue);
+  if (resolved === undefined)
+    return "";
+  return ` with ${convertEffortValueToLevel(resolved)} effort`;
+}
+export function isValidNumericEffort(value) {
+  return Number.isInteger(value);
+}
+export function convertEffortValueToLevel(value) {
+  if (typeof value === "string") {
+    return isEffortLevel(value) ? value : "high";
+  }
+  if (process.env.USER_TYPE === "ant" && typeof value === "number") {
+    if (value <= 50)
+      return "low";
+    if (value <= 85)
+      return "medium";
+    if (value <= 100)
+      return "high";
+    return "max";
+  }
+  return "high";
+}
+export function getEffortLevelDescription(level) {
+  switch (level) {
+    case "low":
+      return "Quick, straightforward implementation with minimal overhead";
+    case "medium":
+      return "Balanced approach with standard implementation and testing";
+    case "high":
+      return "Comprehensive implementation with extensive testing and documentation";
+    case "max":
+      return "Maximum capability with deepest reasoning (Opus 4.6 only)";
+  }
+}
+export function getEffortValueDescription(value) {
+  if (process.env.USER_TYPE === "ant" && typeof value === "number") {
+    return `[ANT-ONLY] Numeric effort value of ${value}`;
+  }
+  if (typeof value === "string") {
+    return getEffortLevelDescription(value);
+  }
+  return "Balanced approach with standard implementation and testing";
+}
+const OPUS_DEFAULT_EFFORT_CONFIG_DEFAULT = {
+  enabled: true,
+  dialogTitle: "We recommend medium effort for Opus",
+  dialogDescription: "Effort determines how long Claude thinks for when completing your task. We recommend medium effort for most tasks to balance speed and intelligence and maximize rate limits. Use ultrathink to trigger high effort when needed."
+};
+export function getOpusDefaultEffortConfig() {
+  const config = getFeatureValue_CACHED_MAY_BE_STALE("tengu_grey_step2", OPUS_DEFAULT_EFFORT_CONFIG_DEFAULT);
+  return {
+    ...OPUS_DEFAULT_EFFORT_CONFIG_DEFAULT,
+    ...config
+  };
+}
+export function getDefaultEffortForModel(model) {
+  if (process.env.USER_TYPE === "ant") {
+    const config = getAntModelOverrideConfig();
+    const isDefaultModel = config?.defaultModel !== undefined && model.toLowerCase() === config.defaultModel.toLowerCase();
+    if (isDefaultModel && config?.defaultModelEffortLevel) {
+      return config.defaultModelEffortLevel;
+    }
+    const antModel = resolveAntModel(model);
+    if (antModel) {
+      if (antModel.defaultEffortLevel) {
+        return antModel.defaultEffortLevel;
+      }
+      if (antModel.defaultEffortValue !== undefined) {
+        return antModel.defaultEffortValue;
+      }
+    }
+    return;
+  }
+  if (model.toLowerCase().includes("opus-4-6")) {
+    if (isProSubscriber()) {
+      return "medium";
+    }
+    if (getOpusDefaultEffortConfig().enabled && (isMaxSubscriber() || isTeamSubscriber())) {
+      return "medium";
+    }
+  }
+  if (isUltrathinkEnabled() && modelSupportsEffort(model)) {
+    return "medium";
+  }
+  return;
+}

package/dist/src/utils/embeddedTools.js

@@ -0,0 +1,10 @@
+import { isEnvTruthy } from "./envUtils.js";
+export function hasEmbeddedSearchTools() {
+  if (!isEnvTruthy(process.env.EMBEDDED_SEARCH_TOOLS))
+    return false;
+  const e = process.env.CLAUDE_CODE_ENTRYPOINT;
+  return e !== "sdk-ts" && e !== "sdk-py" && e !== "sdk-cli" && e !== "local-agent";
+}
+export function embeddedSearchToolsBinaryPath() {
+  return process.execPath;
+}