@xmem-ai/memcode 4.0.2

package/dist/utils/doctorDiagnostic.js

@@ -0,0 +1,415 @@
+import { execa } from "execa";
+import { readFile, realpath } from "fs/promises";
+import { homedir } from "os";
+import { delimiter, join, posix, win32 } from "path";
+import { checkGlobalInstallPermissions } from "./autoUpdater.js";
+import { isInBundledMode } from "./bundledMode.js";
+import {
+  formatAutoUpdaterDisabledReason,
+  getAutoUpdaterDisabledReason,
+  getGlobalConfig
+} from "./config.js";
+import { getCwd } from "./cwd.js";
+import { isEnvTruthy } from "./envUtils.js";
+import { execFileNoThrow } from "./execFileNoThrow.js";
+import { getFsImplementation } from "./fsOperations.js";
+import {
+  getShellType,
+  isRunningFromLocalInstallation,
+  localInstallationExists
+} from "./localInstaller.js";
+import {
+  detectApk,
+  detectAsdf,
+  detectDeb,
+  detectHomebrew,
+  detectMise,
+  detectPacman,
+  detectRpm,
+  detectWinget,
+  getPackageManager
+} from "./nativeInstaller/packageManagers.js";
+import { getPlatform } from "./platform.js";
+import { getRipgrepStatus } from "./ripgrep.js";
+import { SandboxManager } from "./sandbox/sandbox-adapter.js";
+import { getManagedFilePath } from "./settings/managedPath.js";
+import { CUSTOMIZATION_SURFACES } from "./settings/types.js";
+import {
+  findClaudeAlias,
+  findValidClaudeAlias,
+  getShellConfigPaths
+} from "./shellConfig.js";
+import { jsonParse } from "./slowOperations.js";
+import { which } from "./which.js";
+const CLI_BIN = "memcode";
+const LOCAL_BIN = join(".local", "bin", CLI_BIN);
+const LOCAL_DATA_DIR = join(".local", "share", CLI_BIN);
+function getNormalizedPaths() {
+  let invokedPath = process.argv[1] || "";
+  let execPath = process.execPath || process.argv[0] || "";
+  if (getPlatform() === "windows") {
+    invokedPath = invokedPath.split(win32.sep).join(posix.sep);
+    execPath = execPath.split(win32.sep).join(posix.sep);
+  }
+  return [invokedPath, execPath];
+}
+async function getCurrentInstallationType() {
+  if (process.env.NODE_ENV === "development") {
+    return "development";
+  }
+  const [invokedPath] = getNormalizedPaths();
+  if (isInBundledMode()) {
+    if (detectHomebrew() || detectWinget() || detectMise() || detectAsdf() || await detectPacman() || await detectDeb() || await detectRpm() || await detectApk()) {
+      return "package-manager";
+    }
+    return "native";
+  }
+  if (isRunningFromLocalInstallation()) {
+    return "npm-local";
+  }
+  const npmGlobalPaths = [
+    "/usr/local/lib/node_modules",
+    "/usr/lib/node_modules",
+    "/opt/homebrew/lib/node_modules",
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    "/.nvm/versions/node/"
+    // nvm installations
+  ];
+  if (npmGlobalPaths.some((path) => invokedPath.includes(path))) {
+    return "npm-global";
+  }
+  if (invokedPath.includes("/npm/") || invokedPath.includes("/nvm/")) {
+    return "npm-global";
+  }
+  const npmConfigResult = await execa("npm config get prefix", {
+    shell: true,
+    reject: false
+  });
+  const globalPrefix = npmConfigResult.exitCode === 0 ? npmConfigResult.stdout.trim() : null;
+  if (globalPrefix && invokedPath.startsWith(globalPrefix)) {
+    return "npm-global";
+  }
+  return "unknown";
+}
+async function getInstallationPath() {
+  if (process.env.NODE_ENV === "development") {
+    return getCwd();
+  }
+  if (isInBundledMode()) {
+    try {
+      return await realpath(process.execPath);
+    } catch {
+    }
+    try {
+      const path = await which(CLI_BIN);
+      if (path) {
+        return path;
+      }
+    } catch {
+    }
+    try {
+      await getFsImplementation().stat(join(homedir(), LOCAL_BIN));
+      return join(homedir(), LOCAL_BIN);
+    } catch {
+    }
+    return "native";
+  }
+  try {
+    return process.argv[0] || "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function getInvokedBinary() {
+  try {
+    if (isInBundledMode()) {
+      return process.execPath || "unknown";
+    }
+    return process.argv[1] || "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+async function detectMultipleInstallations() {
+  const fs = getFsImplementation();
+  const installations = [];
+  const localPath = join(homedir(), ".memcode", "local");
+  if (await localInstallationExists()) {
+    installations.push({ type: "npm-local", path: localPath });
+  }
+  const packagesToCheck = ["@xortex-ai/memcode"];
+  if (MACRO.PACKAGE_URL && MACRO.PACKAGE_URL !== "@xortex-ai/memcode") {
+    packagesToCheck.push(MACRO.PACKAGE_URL);
+  }
+  const npmResult = await execFileNoThrow("npm", [
+    "-g",
+    "config",
+    "get",
+    "prefix"
+  ]);
+  if (npmResult.code === 0 && npmResult.stdout) {
+    const npmPrefix = npmResult.stdout.trim();
+    const isWindows = getPlatform() === "windows";
+    const globalBinPath = isWindows ? join(npmPrefix, CLI_BIN) : join(npmPrefix, "bin", CLI_BIN);
+    let globalBinExists = false;
+    try {
+      await fs.stat(globalBinPath);
+      globalBinExists = true;
+    } catch {
+    }
+    if (globalBinExists) {
+      let isCurrentHomebrewInstallation = false;
+      try {
+        const realPath = await realpath(globalBinPath);
+        if (realPath.includes("/Caskroom/")) {
+          isCurrentHomebrewInstallation = detectHomebrew();
+        }
+      } catch {
+      }
+      if (!isCurrentHomebrewInstallation) {
+        installations.push({ type: "npm-global", path: globalBinPath });
+      }
+    } else {
+      for (const packageName of packagesToCheck) {
+        const globalPackagePath = isWindows ? join(npmPrefix, "node_modules", packageName) : join(npmPrefix, "lib", "node_modules", packageName);
+        try {
+          await fs.stat(globalPackagePath);
+          installations.push({
+            type: "npm-global-orphan",
+            path: globalPackagePath
+          });
+        } catch {
+        }
+      }
+    }
+  }
+  const nativeBinPath = join(homedir(), LOCAL_BIN);
+  try {
+    await fs.stat(nativeBinPath);
+    installations.push({ type: "native", path: nativeBinPath });
+  } catch {
+  }
+  const config = getGlobalConfig();
+  if (config.installMethod === "native") {
+    const nativeDataPath = join(homedir(), LOCAL_DATA_DIR);
+    try {
+      await fs.stat(nativeDataPath);
+      if (!installations.some((i) => i.type === "native")) {
+        installations.push({ type: "native", path: nativeDataPath });
+      }
+    } catch {
+    }
+  }
+  return installations;
+}
+async function detectConfigurationIssues(type) {
+  const warnings = [];
+  try {
+    const raw = await readFile(
+      join(getManagedFilePath(), "managed-settings.json"),
+      "utf-8"
+    );
+    const parsed = jsonParse(raw);
+    const field = parsed && typeof parsed === "object" ? parsed.strictPluginOnlyCustomization : void 0;
+    if (field !== void 0 && typeof field !== "boolean") {
+      if (!Array.isArray(field)) {
+        warnings.push({
+          issue: `managed-settings.json: strictPluginOnlyCustomization has an invalid value (expected true or an array, got ${typeof field})`,
+          fix: `The field is silently ignored (schema .catch rescues it). Set it to true, or an array of: ${CUSTOMIZATION_SURFACES.join(", ")}.`
+        });
+      } else {
+        const unknown = field.filter(
+          (x) => typeof x === "string" && !CUSTOMIZATION_SURFACES.includes(x)
+        );
+        if (unknown.length > 0) {
+          warnings.push({
+            issue: `managed-settings.json: strictPluginOnlyCustomization has ${unknown.length} value(s) this client doesn't recognize: ${unknown.map(String).join(", ")}`,
+            fix: `These are silently ignored (forwards-compat). Known surfaces for this version: ${CUSTOMIZATION_SURFACES.join(", ")}. Either remove them, or this client is older than the managed-settings intended.`
+          });
+        }
+      }
+    }
+  } catch {
+  }
+  const config = getGlobalConfig();
+  if (type === "development") {
+    return warnings;
+  }
+  if (type === "native") {
+    const path = process.env.PATH || "";
+    const pathDirectories = path.split(delimiter);
+    const homeDir = homedir();
+    const localBinPath = join(homeDir, ".local", "bin");
+    let normalizedLocalBinPath = localBinPath;
+    if (getPlatform() === "windows") {
+      normalizedLocalBinPath = localBinPath.split(win32.sep).join(posix.sep);
+    }
+    const localBinInPath = pathDirectories.some((dir) => {
+      let normalizedDir = dir;
+      if (getPlatform() === "windows") {
+        normalizedDir = dir.split(win32.sep).join(posix.sep);
+      }
+      const trimmedDir = normalizedDir.replace(/\/+$/, "");
+      const trimmedRawDir = dir.replace(/[/\\]+$/, "");
+      return trimmedDir === normalizedLocalBinPath || trimmedRawDir === "~/.local/bin" || trimmedRawDir === "$HOME/.local/bin";
+    });
+    if (!localBinInPath) {
+      const isWindows = getPlatform() === "windows";
+      if (isWindows) {
+        const windowsLocalBinPath = localBinPath.split(posix.sep).join(win32.sep);
+        warnings.push({
+          issue: `Native installation exists but ${windowsLocalBinPath} is not in your PATH`,
+          fix: `Add it by opening: System Properties \u2192 Environment Variables \u2192 Edit User PATH \u2192 New \u2192 Add the path above. Then restart your terminal.`
+        });
+      } else {
+        const shellType = getShellType();
+        const configPaths = getShellConfigPaths();
+        const configFile = configPaths[shellType];
+        const displayPath = configFile ? configFile.replace(homedir(), "~") : "your shell config file";
+        warnings.push({
+          issue: "Native installation exists but ~/.local/bin is not in your PATH",
+          fix: `Run: echo 'export PATH="$HOME/.local/bin:$PATH"' >> ${displayPath} then open a new terminal or run: source ${displayPath}`
+        });
+      }
+    }
+  }
+  if (!isEnvTruthy(process.env.DISABLE_INSTALLATION_CHECKS)) {
+    if (type === "npm-local" && config.installMethod !== "local") {
+      warnings.push({
+        issue: `Running from local installation but config install method is '${config.installMethod}'`,
+        fix: "Consider using native installation: memcode install"
+      });
+    }
+    if (type === "native" && config.installMethod !== "native") {
+      warnings.push({
+        issue: `Running native installation but config install method is '${config.installMethod}'`,
+        fix: "Run memcode install to update configuration"
+      });
+    }
+  }
+  if (type === "npm-global" && await localInstallationExists()) {
+    warnings.push({
+      issue: "Local installation exists but not being used",
+      fix: "Consider using native installation: memcode install"
+    });
+  }
+  const existingAlias = await findClaudeAlias();
+  const validAlias = await findValidClaudeAlias();
+  if (type === "npm-local") {
+    const whichResult = await which(CLI_BIN);
+    const memcodeInPath = !!whichResult;
+    if (!memcodeInPath && !validAlias) {
+      if (existingAlias) {
+        warnings.push({
+          issue: "Local installation not accessible",
+          fix: `Alias exists but points to invalid target: ${existingAlias}. Update alias: alias memcode="~/.memcode/local/memcode"`
+        });
+      } else {
+        warnings.push({
+          issue: "Local installation not accessible",
+          fix: 'Create alias: alias memcode="~/.memcode/local/memcode"'
+        });
+      }
+    }
+  }
+  return warnings;
+}
+function detectLinuxGlobPatternWarnings() {
+  if (getPlatform() !== "linux") {
+    return [];
+  }
+  const warnings = [];
+  const globPatterns = SandboxManager.getLinuxGlobPatternWarnings();
+  if (globPatterns.length > 0) {
+    const displayPatterns = globPatterns.slice(0, 3).join(", ");
+    const remaining = globPatterns.length - 3;
+    const patternList = remaining > 0 ? `${displayPatterns} (${remaining} more)` : displayPatterns;
+    warnings.push({
+      issue: `Glob patterns in sandbox permission rules are not fully supported on Linux`,
+      fix: `Found ${globPatterns.length} pattern(s): ${patternList}. On Linux, glob patterns in Edit/Read rules will be ignored.`
+    });
+  }
+  return warnings;
+}
+async function getDoctorDiagnostic() {
+  const installationType = await getCurrentInstallationType();
+  const version = typeof MACRO !== "undefined" && MACRO.VERSION ? MACRO.VERSION : "unknown";
+  const installationPath = await getInstallationPath();
+  const invokedBinary = getInvokedBinary();
+  const multipleInstallations = await detectMultipleInstallations();
+  const warnings = await detectConfigurationIssues(installationType);
+  warnings.push(...detectLinuxGlobPatternWarnings());
+  if (installationType === "native") {
+    const npmInstalls = multipleInstallations.filter(
+      (i) => i.type === "npm-global" || i.type === "npm-global-orphan" || i.type === "npm-local"
+    );
+    const isWindows = getPlatform() === "windows";
+    for (const install of npmInstalls) {
+      if (install.type === "npm-global") {
+        let uninstallCmd = "npm -g uninstall @xortex-ai/memcode";
+        if (MACRO.PACKAGE_URL && MACRO.PACKAGE_URL !== "@xortex-ai/memcode") {
+          uninstallCmd += ` && npm -g uninstall ${MACRO.PACKAGE_URL}`;
+        }
+        warnings.push({
+          issue: `Leftover npm global installation at ${install.path}`,
+          fix: `Run: ${uninstallCmd}`
+        });
+      } else if (install.type === "npm-global-orphan") {
+        warnings.push({
+          issue: `Orphaned npm global package at ${install.path}`,
+          fix: isWindows ? `Run: rmdir /s /q "${install.path}"` : `Run: rm -rf ${install.path}`
+        });
+      } else if (install.type === "npm-local") {
+        warnings.push({
+          issue: `Leftover npm local installation at ${install.path}`,
+          fix: isWindows ? `Run: rmdir /s /q "${install.path}"` : `Run: rm -rf ${install.path}`
+        });
+      }
+    }
+  }
+  const config = getGlobalConfig();
+  const configInstallMethod = config.installMethod || "not set";
+  let hasUpdatePermissions = null;
+  if (installationType === "npm-global") {
+    const permCheck = await checkGlobalInstallPermissions();
+    hasUpdatePermissions = permCheck.hasPermissions;
+    if (!hasUpdatePermissions && !getAutoUpdaterDisabledReason()) {
+      warnings.push({
+        issue: "Insufficient permissions for auto-updates",
+        fix: "Do one of: (1) Re-install node without sudo, or (2) Use `memcode install` for native installation"
+      });
+    }
+  }
+  const ripgrepStatusRaw = getRipgrepStatus();
+  const ripgrepStatus = {
+    working: ripgrepStatusRaw.working ?? true,
+    // Assume working if not yet tested
+    mode: ripgrepStatusRaw.mode,
+    systemPath: ripgrepStatusRaw.mode === "system" ? ripgrepStatusRaw.path : null
+  };
+  const packageManager = installationType === "package-manager" ? await getPackageManager() : void 0;
+  const diagnostic = {
+    installationType,
+    version,
+    installationPath,
+    invokedBinary,
+    configInstallMethod,
+    autoUpdates: (() => {
+      const reason = getAutoUpdaterDisabledReason();
+      return reason ? `disabled (${formatAutoUpdaterDisabledReason(reason)})` : "enabled";
+    })(),
+    hasUpdatePermissions,
+    multipleInstallations,
+    warnings,
+    packageManager,
+    ripgrepStatus
+  };
+  return diagnostic;
+}
+export {
+  detectLinuxGlobPatternWarnings,
+  getCurrentInstallationType,
+  getDoctorDiagnostic,
+  getInvokedBinary
+};

package/dist/utils/dxt/helpers.js

@@ -0,0 +1,44 @@
+import { errorMessage } from "../errors.js";
+import { jsonParse } from "../slowOperations.js";
+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;
+}
+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);
+}
+async function parseAndValidateManifestFromBytes(manifestData) {
+  const manifestText = new TextDecoder().decode(manifestData);
+  return parseAndValidateManifestFromText(manifestText);
+}
+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}`;
+}
+export {
+  generateExtensionId,
+  parseAndValidateManifestFromBytes,
+  parseAndValidateManifestFromText,
+  validateManifest
+};

package/dist/utils/dxt/zip.js

@@ -0,0 +1,123 @@
+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,
+  // 512MB per file
+  MAX_TOTAL_SIZE: 1024 * 1024 * 1024,
+  // 1024MB total uncompressed
+  MAX_FILE_COUNT: 1e5,
+  // Maximum number of files
+  MAX_COMPRESSION_RATIO: 50,
+  // Anything above 50:1 is suspicious
+  MIN_COMPRESSION_RATIO: 0.5
+  // Below 0.5:1 might indicate already compressed malicious content
+};
+function isPathSafe(filePath) {
+  if (containsPathTraversal(filePath)) {
+    return false;
+  }
+  const normalized = normalize(filePath);
+  if (isAbsolute(normalized)) {
+    return false;
+  }
+  return true;
+}
+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 };
+}
+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;
+}
+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;
+}
+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}`);
+  }
+}
+export {
+  isPathSafe,
+  parseZipModes,
+  readAndUnzipFile,
+  unzipFile,
+  validateZipFile
+};

package/dist/utils/earlyInput.js

@@ -0,0 +1,104 @@
+import { lastGrapheme } from "./intl.js";
+let earlyInputBuffer = "";
+let isCapturing = false;
+let readableHandler = null;
+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 += "\n";
+      i++;
+      continue;
+    }
+    earlyInputBuffer += char;
+    i++;
+  }
+}
+function stopCapturingEarlyInput() {
+  if (!isCapturing) {
+    return;
+  }
+  isCapturing = false;
+  if (readableHandler) {
+    process.stdin.removeListener("readable", readableHandler);
+    readableHandler = null;
+  }
+}
+function consumeEarlyInput() {
+  stopCapturingEarlyInput();
+  const input = earlyInputBuffer.trim();
+  earlyInputBuffer = "";
+  return input;
+}
+function hasEarlyInput() {
+  return earlyInputBuffer.trim().length > 0;
+}
+function seedEarlyInput(text) {
+  earlyInputBuffer = text;
+}
+function isCapturingEarlyInput() {
+  return isCapturing;
+}
+export {
+  consumeEarlyInput,
+  hasEarlyInput,
+  isCapturingEarlyInput,
+  seedEarlyInput,
+  startCapturingEarlyInput,
+  stopCapturingEarlyInput
+};