@luluyun/automd 1.0.0 → 1.0.2

package/dist/chunk-k2aedy4h.js

@@ -0,0 +1,494 @@
+// @bun
+import {
+  APIUserAbortError,
+  init_sdk
+} from "./chunk-g51z2hdg.js";
+import {
+  __esm
+} from "./chunk-hhsxm2yr.js";
+
+// src/utils/errors.ts
+function isAbortError(e) {
+  return e instanceof AbortError || e instanceof APIUserAbortError || e instanceof Error && e.name === "AbortError";
+}
+function hasExactErrorMessage(error, message) {
+  return error instanceof Error && error.message === message;
+}
+function toError(e) {
+  return e instanceof Error ? e : new Error(String(e));
+}
+function errorMessage(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+function getErrnoCode(e) {
+  if (e && typeof e === "object" && "code" in e && typeof e.code === "string") {
+    return e.code;
+  }
+  return;
+}
+function isENOENT(e) {
+  return getErrnoCode(e) === "ENOENT";
+}
+function getErrnoPath(e) {
+  if (e && typeof e === "object" && "path" in e && typeof e.path === "string") {
+    return e.path;
+  }
+  return;
+}
+function isFsInaccessible(e) {
+  const code = getErrnoCode(e);
+  return code === "ENOENT" || code === "EACCES" || code === "EPERM" || code === "ENOTDIR" || code === "ELOOP";
+}
+function classifyAxiosError(e) {
+  const message = errorMessage(e);
+  if (!e || typeof e !== "object" || !("isAxiosError" in e) || !e.isAxiosError) {
+    return { kind: "other", message };
+  }
+  const err = e;
+  const status = err.response?.status;
+  if (status === 401 || status === 403)
+    return { kind: "auth", status, message };
+  if (err.code === "ECONNABORTED")
+    return { kind: "timeout", status, message };
+  if (err.code === "ECONNREFUSED" || err.code === "ENOTFOUND") {
+    return { kind: "network", status, message };
+  }
+  return { kind: "http", status, message };
+}
+var ClaudeError, MalformedCommandError, AbortError, ConfigParseError, ShellError, TeleportOperationError, TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS;
+var init_errors = __esm(() => {
+  init_sdk();
+  ClaudeError = class ClaudeError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = this.constructor.name;
+    }
+  };
+  MalformedCommandError = class MalformedCommandError extends Error {
+  };
+  AbortError = class AbortError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "AbortError";
+    }
+  };
+  ConfigParseError = class ConfigParseError extends Error {
+    filePath;
+    defaultConfig;
+    constructor(message, filePath, defaultConfig) {
+      super(message);
+      this.name = "ConfigParseError";
+      this.filePath = filePath;
+      this.defaultConfig = defaultConfig;
+    }
+  };
+  ShellError = class ShellError extends Error {
+    stdout;
+    stderr;
+    code;
+    interrupted;
+    constructor(stdout, stderr, code, interrupted) {
+      super("Shell command failed");
+      this.stdout = stdout;
+      this.stderr = stderr;
+      this.code = code;
+      this.interrupted = interrupted;
+      this.name = "ShellError";
+    }
+  };
+  TeleportOperationError = class TeleportOperationError extends Error {
+    formattedMessage;
+    constructor(message, formattedMessage) {
+      super(message);
+      this.formattedMessage = formattedMessage;
+      this.name = "TeleportOperationError";
+    }
+  };
+  TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS = class TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS extends Error {
+    telemetryMessage;
+    constructor(message, telemetryMessage) {
+      super(message);
+      this.name = "TelemetrySafeError";
+      this.telemetryMessage = telemetryMessage ?? message;
+    }
+  };
+});
+
+// src/utils/fsOperations.ts
+import * as fs from "fs";
+import {
+  mkdir as mkdirPromise,
+  open,
+  readdir as readdirPromise,
+  readFile as readFilePromise,
+  rename as renamePromise,
+  rmdir as rmdirPromise,
+  rm as rmPromise,
+  stat as statPromise,
+  unlink as unlinkPromise
+} from "fs/promises";
+import { homedir } from "os";
+import * as nodePath from "path";
+function safeResolvePath(fs2, filePath) {
+  if (filePath.startsWith("//") || filePath.startsWith("\\\\")) {
+    return { resolvedPath: filePath, isSymlink: false, isCanonical: false };
+  }
+  try {
+    const stats = fs2.lstatSync(filePath);
+    if (stats.isFIFO() || stats.isSocket() || stats.isCharacterDevice() || stats.isBlockDevice()) {
+      return { resolvedPath: filePath, isSymlink: false, isCanonical: false };
+    }
+    const resolvedPath = fs2.realpathSync(filePath);
+    return {
+      resolvedPath,
+      isSymlink: resolvedPath !== filePath,
+      isCanonical: true
+    };
+  } catch (_error) {
+    return { resolvedPath: filePath, isSymlink: false, isCanonical: false };
+  }
+}
+function isDuplicatePath(fs2, filePath, loadedPaths) {
+  const { resolvedPath } = safeResolvePath(fs2, filePath);
+  if (loadedPaths.has(resolvedPath)) {
+    return true;
+  }
+  loadedPaths.add(resolvedPath);
+  return false;
+}
+function resolveDeepestExistingAncestorSync(fs2, absolutePath) {
+  let dir = absolutePath;
+  const segments = [];
+  while (dir !== nodePath.dirname(dir)) {
+    let st;
+    try {
+      st = fs2.lstatSync(dir);
+    } catch {
+      segments.unshift(nodePath.basename(dir));
+      dir = nodePath.dirname(dir);
+      continue;
+    }
+    if (st.isSymbolicLink()) {
+      try {
+        const resolved = fs2.realpathSync(dir);
+        return segments.length === 0 ? resolved : nodePath.join(resolved, ...segments);
+      } catch {
+        const target = fs2.readlinkSync(dir);
+        const absTarget = nodePath.isAbsolute(target) ? target : nodePath.resolve(nodePath.dirname(dir), target);
+        return segments.length === 0 ? absTarget : nodePath.join(absTarget, ...segments);
+      }
+    }
+    try {
+      const resolved = fs2.realpathSync(dir);
+      if (resolved !== dir) {
+        return segments.length === 0 ? resolved : nodePath.join(resolved, ...segments);
+      }
+    } catch {}
+    return;
+  }
+  return;
+}
+function getPathsForPermissionCheck(inputPath) {
+  let path = inputPath;
+  if (path === "~") {
+    path = homedir().normalize("NFC");
+  } else if (path.startsWith("~/")) {
+    path = nodePath.join(homedir().normalize("NFC"), path.slice(2));
+  }
+  const pathSet = new Set;
+  const fsImpl = getFsImplementation();
+  pathSet.add(path);
+  if (path.startsWith("//") || path.startsWith("\\\\")) {
+    return Array.from(pathSet);
+  }
+  try {
+    let currentPath = path;
+    const visited = new Set;
+    const maxDepth = 40;
+    for (let depth = 0;depth < maxDepth; depth++) {
+      if (visited.has(currentPath)) {
+        break;
+      }
+      visited.add(currentPath);
+      if (!fsImpl.existsSync(currentPath)) {
+        if (currentPath === path) {
+          const resolved = resolveDeepestExistingAncestorSync(fsImpl, path);
+          if (resolved !== undefined) {
+            pathSet.add(resolved);
+          }
+        }
+        break;
+      }
+      const stats = fsImpl.lstatSync(currentPath);
+      if (stats.isFIFO() || stats.isSocket() || stats.isCharacterDevice() || stats.isBlockDevice()) {
+        break;
+      }
+      if (!stats.isSymbolicLink()) {
+        break;
+      }
+      const target = fsImpl.readlinkSync(currentPath);
+      const absoluteTarget = nodePath.isAbsolute(target) ? target : nodePath.resolve(nodePath.dirname(currentPath), target);
+      pathSet.add(absoluteTarget);
+      currentPath = absoluteTarget;
+    }
+  } catch {}
+  const { resolvedPath, isSymlink } = safeResolvePath(fsImpl, path);
+  if (isSymlink && resolvedPath !== path) {
+    pathSet.add(resolvedPath);
+  }
+  return Array.from(pathSet);
+}
+function getFsImplementation() {
+  return activeFs;
+}
+async function readFileRange(path, offset, maxBytes) {
+  const fh = await open(path, "r");
+  try {
+    const size = (await fh.stat()).size;
+    if (size <= offset) {
+      return null;
+    }
+    const bytesToRead = Math.min(size - offset, maxBytes);
+    const buffer = Buffer.allocUnsafe(bytesToRead);
+    let totalRead = 0;
+    while (totalRead < bytesToRead) {
+      const { bytesRead } = await fh.read(buffer, totalRead, bytesToRead - totalRead, offset + totalRead);
+      if (bytesRead === 0) {
+        break;
+      }
+      totalRead += bytesRead;
+    }
+    return {
+      content: buffer.toString("utf8", 0, totalRead),
+      bytesRead: totalRead,
+      bytesTotal: size
+    };
+  } finally {
+    await fh.close();
+  }
+}
+async function tailFile(path, maxBytes) {
+  const fh = await open(path, "r");
+  try {
+    const size = (await fh.stat()).size;
+    if (size === 0) {
+      return { content: "", bytesRead: 0, bytesTotal: 0 };
+    }
+    const offset = Math.max(0, size - maxBytes);
+    const bytesToRead = size - offset;
+    const buffer = Buffer.allocUnsafe(bytesToRead);
+    let totalRead = 0;
+    while (totalRead < bytesToRead) {
+      const { bytesRead } = await fh.read(buffer, totalRead, bytesToRead - totalRead, offset + totalRead);
+      if (bytesRead === 0) {
+        break;
+      }
+      totalRead += bytesRead;
+    }
+    return {
+      content: buffer.toString("utf8", 0, totalRead),
+      bytesRead: totalRead,
+      bytesTotal: size
+    };
+  } finally {
+    await fh.close();
+  }
+}
+async function* readLinesReverse(path) {
+  const CHUNK_SIZE = 1024 * 4;
+  const fileHandle = await open(path, "r");
+  try {
+    const stats = await fileHandle.stat();
+    let position = stats.size;
+    let remainder = Buffer.alloc(0);
+    const buffer = Buffer.alloc(CHUNK_SIZE);
+    while (position > 0) {
+      const currentChunkSize = Math.min(CHUNK_SIZE, position);
+      position -= currentChunkSize;
+      await fileHandle.read(buffer, 0, currentChunkSize, position);
+      const combined = Buffer.concat([
+        buffer.subarray(0, currentChunkSize),
+        remainder
+      ]);
+      const firstNewline = combined.indexOf(10);
+      if (firstNewline === -1) {
+        remainder = combined;
+        continue;
+      }
+      remainder = Buffer.from(combined.subarray(0, firstNewline));
+      const lines = combined.toString("utf8", firstNewline + 1).split(`
+`);
+      for (let i = lines.length - 1;i >= 0; i--) {
+        const line = lines[i];
+        if (line) {
+          yield line;
+        }
+      }
+    }
+    if (remainder.length > 0) {
+      yield remainder.toString("utf8");
+    }
+  } finally {
+    await fileHandle.close();
+  }
+}
+var NodeFsOperations, activeFs;
+var init_fsOperations = __esm(() => {
+  init_errors();
+  NodeFsOperations = {
+    cwd() {
+      return process.cwd();
+    },
+    existsSync(fsPath) {
+      return fs.existsSync(fsPath);
+    },
+    async stat(fsPath) {
+      return statPromise(fsPath);
+    },
+    async readdir(fsPath) {
+      return readdirPromise(fsPath, { withFileTypes: true });
+    },
+    async unlink(fsPath) {
+      return unlinkPromise(fsPath);
+    },
+    async rmdir(fsPath) {
+      return rmdirPromise(fsPath);
+    },
+    async rm(fsPath, options) {
+      return rmPromise(fsPath, options);
+    },
+    async mkdir(dirPath, options) {
+      try {
+        await mkdirPromise(dirPath, { recursive: true, ...options });
+      } catch (e) {
+        if (getErrnoCode(e) !== "EEXIST")
+          throw e;
+      }
+    },
+    async readFile(fsPath, options) {
+      return readFilePromise(fsPath, { encoding: options.encoding });
+    },
+    async rename(oldPath, newPath) {
+      return renamePromise(oldPath, newPath);
+    },
+    statSync(fsPath) {
+      return fs.statSync(fsPath);
+    },
+    lstatSync(fsPath) {
+      return fs.lstatSync(fsPath);
+    },
+    readFileSync(fsPath, options) {
+      return fs.readFileSync(fsPath, { encoding: options.encoding });
+    },
+    readFileBytesSync(fsPath) {
+      return fs.readFileSync(fsPath);
+    },
+    readSync(fsPath, options) {
+      let fd = undefined;
+      try {
+        fd = fs.openSync(fsPath, "r");
+        const buffer = Buffer.alloc(options.length);
+        const bytesRead = fs.readSync(fd, buffer, 0, options.length, 0);
+        return { buffer, bytesRead };
+      } finally {
+        if (fd)
+          fs.closeSync(fd);
+      }
+    },
+    appendFileSync(path, data, options) {
+      if (options?.mode !== undefined) {
+        try {
+          const fd = fs.openSync(path, "ax", options.mode);
+          try {
+            fs.appendFileSync(fd, data);
+          } finally {
+            fs.closeSync(fd);
+          }
+          return;
+        } catch (e) {
+          if (getErrnoCode(e) !== "EEXIST")
+            throw e;
+        }
+      }
+      fs.appendFileSync(path, data);
+    },
+    copyFileSync(src, dest) {
+      fs.copyFileSync(src, dest);
+    },
+    unlinkSync(path) {
+      fs.unlinkSync(path);
+    },
+    renameSync(oldPath, newPath) {
+      fs.renameSync(oldPath, newPath);
+    },
+    linkSync(target, path) {
+      fs.linkSync(target, path);
+    },
+    symlinkSync(target, path, type) {
+      fs.symlinkSync(target, path, type);
+    },
+    readlinkSync(path) {
+      return fs.readlinkSync(path);
+    },
+    realpathSync(path) {
+      return fs.realpathSync(path).normalize("NFC");
+    },
+    mkdirSync(dirPath, options) {
+      const mkdirOptions = {
+        recursive: true
+      };
+      if (options?.mode !== undefined) {
+        mkdirOptions.mode = options.mode;
+      }
+      try {
+        fs.mkdirSync(dirPath, mkdirOptions);
+      } catch (e) {
+        if (getErrnoCode(e) !== "EEXIST")
+          throw e;
+      }
+    },
+    readdirSync(dirPath) {
+      return fs.readdirSync(dirPath, { withFileTypes: true });
+    },
+    readdirStringSync(dirPath) {
+      return fs.readdirSync(dirPath);
+    },
+    isDirEmptySync(dirPath) {
+      const files = this.readdirSync(dirPath);
+      return files.length === 0;
+    },
+    rmdirSync(dirPath) {
+      fs.rmdirSync(dirPath);
+    },
+    rmSync(path, options) {
+      fs.rmSync(path, options);
+    },
+    createWriteStream(path) {
+      return fs.createWriteStream(path);
+    },
+    async readFileBytes(fsPath, maxBytes) {
+      if (maxBytes === undefined) {
+        return readFilePromise(fsPath);
+      }
+      const handle = await open(fsPath, "r");
+      try {
+        const { size } = await handle.stat();
+        const readSize = Math.min(size, maxBytes);
+        const buffer = Buffer.allocUnsafe(readSize);
+        let offset = 0;
+        while (offset < readSize) {
+          const { bytesRead } = await handle.read(buffer, offset, readSize - offset, offset);
+          if (bytesRead === 0)
+            break;
+          offset += bytesRead;
+        }
+        return offset < readSize ? buffer.subarray(0, offset) : buffer;
+      } finally {
+        await handle.close();
+      }
+    }
+  };
+  activeFs = NodeFsOperations;
+});
+
+export { ClaudeError, MalformedCommandError, AbortError, isAbortError, ConfigParseError, ShellError, TeleportOperationError, TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, hasExactErrorMessage, toError, errorMessage, getErrnoCode, isENOENT, getErrnoPath, isFsInaccessible, classifyAxiosError, init_errors, safeResolvePath, isDuplicatePath, getPathsForPermissionCheck, getFsImplementation, readFileRange, tailFile, readLinesReverse, init_fsOperations };