@struktoai/mirage-node 0.0.3 → 0.0.4

package/dist/chunk-5ZHNPNDD.js

@@ -0,0 +1,944 @@
+import {
+  redactSshConfig
+} from "./chunk-LPLZLSMK.js";
+
+// src/resource/ssh/ssh.ts
+import {
+  BaseResource,
+  PathSpec,
+  ResourceName as ResourceName4,
+  makeResolveGlob,
+  mountKey,
+  mountPrefixOf as mountPrefixOf3
+} from "@struktoai/mirage-core";
+
+// src/accessor/ssh.ts
+import { Accessor } from "@struktoai/mirage-core";
+import { homedir } from "os";
+import { readFileSync } from "fs";
+import { resolve } from "path";
+function expandHome(p) {
+  if (p === "~") return homedir();
+  if (p.startsWith("~/")) return resolve(homedir(), p.slice(2));
+  return p;
+}
+var SSHAccessor = class extends Accessor {
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  config;
+  client = null;
+  sftpClient = null;
+  connectPromise = null;
+  async sftp() {
+    if (this.sftpClient !== null) return this.sftpClient;
+    if (this.connectPromise !== null) return this.connectPromise;
+    this.connectPromise = this.connect();
+    try {
+      return await this.connectPromise;
+    } finally {
+      this.connectPromise = null;
+    }
+  }
+  async connect() {
+    let ssh2Mod;
+    try {
+      ssh2Mod = await import("ssh2");
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(`ssh2 is required for the SSH resource \u2014 install it as a peer dep: ${msg}`);
+    }
+    const { Client: ClientCtor } = ssh2Mod;
+    const c = new ClientCtor();
+    const opts = {
+      host: this.config.hostname ?? this.config.host,
+      port: this.config.port ?? 22,
+      readyTimeout: (this.config.timeout ?? 30) * 1e3
+    };
+    if (this.config.username !== void 0) opts.username = this.config.username;
+    if (this.config.password !== void 0) opts.password = this.config.password;
+    if (this.config.identityFile !== void 0) {
+      opts.privateKey = readFileSync(expandHome(this.config.identityFile));
+      if (this.config.passphrase !== void 0) opts.passphrase = this.config.passphrase;
+    }
+    return new Promise((resolveFn, rejectFn) => {
+      c.on("ready", () => {
+        c.sftp((err, sftp) => {
+          if (err !== void 0) {
+            rejectFn(err);
+            return;
+          }
+          this.client = c;
+          this.sftpClient = sftp;
+          resolveFn(sftp);
+        });
+      });
+      c.on("error", rejectFn);
+      c.connect(opts);
+    });
+  }
+  close() {
+    if (this.client !== null) {
+      this.client.end();
+      this.client = null;
+      this.sftpClient = null;
+    }
+    return Promise.resolve();
+  }
+};
+
+// src/commands/builtin/ssh/index.ts
+import {
+  ResourceName as ResourceName2,
+  makeFiletypeCommands,
+  makeGenericCommands
+} from "@struktoai/mirage-core";
+
+// src/core/ssh/read.ts
+import { enoent as enoent2 } from "@struktoai/mirage-core";
+
+// src/core/ssh/stream.ts
+import { once } from "events";
+import { enoent } from "@struktoai/mirage-core";
+
+// src/core/ssh/utils.ts
+import { lstripSlash, mountPrefixOf, rstripSlash } from "@struktoai/mirage-core";
+var S_IFMT = 61440;
+var S_IFDIR = 16384;
+var S_IFREG = 32768;
+function stripPrefix(p) {
+  if (mountPrefixOf(p.virtual, p.resourcePath) && p.virtual.startsWith(mountPrefixOf(p.virtual, p.resourcePath))) {
+    return p.virtual.slice(mountPrefixOf(p.virtual, p.resourcePath).length) || "/";
+  }
+  return p.virtual;
+}
+function joinRoot(root, rel) {
+  const r = rstripSlash(root);
+  const stripped = lstripSlash(rel);
+  if (stripped === "") return r === "" ? "/" : r;
+  if (r === "") return `/${stripped}`;
+  return `${r}/${stripped}`;
+}
+function isNoSuchFile(err) {
+  if (err === null || err === void 0) return false;
+  if (typeof err !== "object") return false;
+  const code = err.code;
+  return code === 2;
+}
+function isDirectoryAttrs(attrs) {
+  if (attrs.mode === void 0) return false;
+  return (attrs.mode & S_IFMT) === S_IFDIR;
+}
+function isFileAttrs(attrs) {
+  if (attrs.mode === void 0) return false;
+  return (attrs.mode & S_IFMT) === S_IFREG;
+}
+
+// src/core/ssh/stream.ts
+async function waitForClose(rs) {
+  try {
+    await once(rs, "close");
+    return null;
+  } catch (error) {
+    return error instanceof Error ? error : new Error(String(error));
+  }
+}
+async function* readChunks(rs) {
+  const closed = waitForClose(rs);
+  let closeError = null;
+  try {
+    for await (const chunk of rs) {
+      const buf = chunk;
+      yield new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+    }
+  } finally {
+    if (!rs.destroyed) rs.destroy();
+    closeError = await closed;
+  }
+  if (closeError !== null) throw closeError;
+}
+async function* stream(accessor, p) {
+  const sftp = await accessor.sftp();
+  const virtual = stripPrefix(p);
+  const remote = joinRoot(accessor.config.root ?? "/", virtual);
+  const rs = sftp.createReadStream(remote);
+  try {
+    yield* readChunks(rs);
+  } catch (err) {
+    if (isNoSuchFile(err)) throw enoent(p);
+    throw err;
+  }
+}
+async function rangeRead(accessor, p, start, end) {
+  const sftp = await accessor.sftp();
+  const virtual = stripPrefix(p);
+  const remote = joinRoot(accessor.config.root ?? "/", virtual);
+  const rs = sftp.createReadStream(remote, { start, end: end - 1 });
+  const chunks = [];
+  let total = 0;
+  try {
+    for await (const u8 of readChunks(rs)) {
+      chunks.push(u8);
+      total += u8.byteLength;
+    }
+  } catch (err) {
+    if (isNoSuchFile(err)) throw enoent(p);
+    throw err;
+  }
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const c of chunks) {
+    out.set(c, offset);
+    offset += c.byteLength;
+  }
+  return out;
+}
+
+// src/core/ssh/read.ts
+async function read(accessor, p) {
+  const sftp = await accessor.sftp();
+  const virtual = stripPrefix(p);
+  const remote = joinRoot(accessor.config.root ?? "/", virtual);
+  const rs = sftp.createReadStream(remote);
+  const chunks = [];
+  let total = 0;
+  try {
+    for await (const u8 of readChunks(rs)) {
+      chunks.push(u8);
+      total += u8.byteLength;
+    }
+  } catch (err) {
+    if (isNoSuchFile(err)) throw enoent2(p);
+    throw err;
+  }
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const c of chunks) {
+    out.set(c, offset);
+    offset += c.byteLength;
+  }
+  return out;
+}
+
+// src/core/ssh/entry.ts
+import { FileStat, FileType, guessType } from "@struktoai/mirage-core";
+function attrsToFileStat(name, attrs) {
+  const modified = attrs.mtime !== void 0 ? new Date(attrs.mtime * 1e3).toISOString() : null;
+  const extra = {};
+  if (attrs.mode !== void 0) extra.mode = attrs.mode;
+  if (attrs.uid !== void 0) extra.uid = attrs.uid;
+  if (attrs.gid !== void 0) extra.gid = attrs.gid;
+  if (isDirectoryAttrs(attrs)) {
+    return new FileStat({
+      name,
+      size: null,
+      modified,
+      type: FileType.DIRECTORY,
+      extra
+    });
+  }
+  return new FileStat({
+    name,
+    size: attrs.size ?? null,
+    modified,
+    fingerprint: null,
+    type: guessType(name),
+    extra
+  });
+}
+
+// src/core/ssh/stat.ts
+import { enoent as enoent3, rstripSlash as rstripSlash2 } from "@struktoai/mirage-core";
+async function stat(accessor, p) {
+  const sftp = await accessor.sftp();
+  const virtual = stripPrefix(p);
+  const remote = joinRoot(accessor.config.root ?? "/", virtual);
+  const attrs = await new Promise((resolveFn, rejectFn) => {
+    sftp.lstat(remote, (err, stats) => {
+      if (err !== void 0) {
+        if (isNoSuchFile(err)) rejectFn(enoent3(p));
+        else rejectFn(err);
+        return;
+      }
+      resolveFn(stats);
+    });
+  });
+  const cleaned = rstripSlash2(virtual);
+  const name = cleaned.length === 0 ? "/" : cleaned.split("/").pop() ?? "/";
+  return attrsToFileStat(name, attrs);
+}
+
+// src/core/ssh/append.ts
+import { invalidateAfterWrite } from "@struktoai/mirage-core";
+async function appendBytes(accessor, p, data) {
+  const sftp = await accessor.sftp();
+  const virtual = stripPrefix(p);
+  const remote = joinRoot(accessor.config.root ?? "/", virtual);
+  await new Promise((resolveFn, rejectFn) => {
+    sftp.appendFile(remote, Buffer.from(data), (err) => {
+      if (err) rejectFn(err);
+      else resolveFn();
+    });
+  });
+  await invalidateAfterWrite(p);
+}
+
+// src/core/ssh/constants.ts
+var SCOPE_ERROR = 5e3;
+
+// src/core/ssh/write.ts
+import { ResourceName, invalidateAfterWrite as invalidateAfterWrite2, record } from "@struktoai/mirage-core";
+async function writeBytes(accessor, p, data) {
+  const start = performance.now();
+  const sftp = await accessor.sftp();
+  const virtual = stripPrefix(p);
+  const remote = joinRoot(accessor.config.root ?? "/", virtual);
+  await new Promise((resolveFn, rejectFn) => {
+    sftp.writeFile(remote, Buffer.from(data), (err) => {
+      if (err) rejectFn(err);
+      else resolveFn();
+    });
+  });
+  record("write", virtual, ResourceName.SSH, data.byteLength, start);
+  await invalidateAfterWrite2(p);
+}
+
+// src/core/ssh/copy.ts
+async function copy(accessor, src, dst) {
+  const data = await read(accessor, src);
+  await writeBytes(accessor, dst, data);
+}
+
+// src/core/ssh/create.ts
+function create(accessor, path) {
+  return writeBytes(accessor, path, new Uint8Array());
+}
+
+// src/core/ssh/du.ts
+import { norm } from "@struktoai/mirage-core";
+async function readRemoteDir(accessor, remote) {
+  const sftp = await accessor.sftp();
+  return new Promise((resolveFn, rejectFn) => {
+    sftp.readdir(remote, (err, entries) => {
+      if (err !== void 0) {
+        const code = err.code;
+        if (code === 2) {
+          resolveFn(null);
+          return;
+        }
+        rejectFn(err);
+        return;
+      }
+      resolveFn(entries);
+    });
+  });
+}
+async function statRemote(accessor, remote) {
+  const sftp = await accessor.sftp();
+  return new Promise((resolveFn, rejectFn) => {
+    sftp.lstat(remote, (err, stats) => {
+      if (err !== void 0) {
+        const code = err.code;
+        if (code === 2) {
+          resolveFn(null);
+          return;
+        }
+        rejectFn(err);
+        return;
+      }
+      resolveFn({ mode: stats.mode, size: stats.size });
+    });
+  });
+}
+async function walkSizes(accessor, virtual) {
+  const remote = joinRoot(accessor.config.root ?? "/", virtual);
+  const st = await statRemote(accessor, remote);
+  if (st === null) return 0;
+  if (isFileAttrs(st)) return st.size;
+  if (!isDirectoryAttrs(st)) return 0;
+  const entries = await readRemoteDir(accessor, remote);
+  if (entries === null) return 0;
+  let total = 0;
+  for (const entry of entries) {
+    if (entry.filename === "." || entry.filename === "..") continue;
+    const child = virtual === "/" ? `/${entry.filename}` : `${virtual}/${entry.filename}`;
+    if (isDirectoryAttrs(entry.attrs)) {
+      total += await walkSizes(accessor, child);
+    } else {
+      total += entry.attrs.size;
+    }
+  }
+  return total;
+}
+async function walkAll(accessor, virtual, entries) {
+  const remote = joinRoot(accessor.config.root ?? "/", virtual);
+  const st = await statRemote(accessor, remote);
+  if (st === null) return 0;
+  if (isFileAttrs(st)) {
+    entries.push([virtual, st.size]);
+    return st.size;
+  }
+  if (!isDirectoryAttrs(st)) return 0;
+  const list = await readRemoteDir(accessor, remote);
+  if (list === null) return 0;
+  let total = 0;
+  for (const entry of list) {
+    if (entry.filename === "." || entry.filename === "..") continue;
+    const child = virtual === "/" ? `/${entry.filename}` : `${virtual}/${entry.filename}`;
+    if (isDirectoryAttrs(entry.attrs)) {
+      total += await walkAll(accessor, child, entries);
+    } else {
+      const size = entry.attrs.size;
+      entries.push([child, size]);
+      total += size;
+    }
+  }
+  return total;
+}
+async function du(accessor, p) {
+  const virtual = stripPrefix(p);
+  return walkSizes(accessor, virtual);
+}
+async function duAll(accessor, p) {
+  const virtual = norm(stripPrefix(p));
+  const entries = [];
+  const total = await walkAll(accessor, virtual, entries);
+  entries.sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+  return [entries, total];
+}
+
+// src/core/ssh/exists.ts
+async function exists(accessor, p) {
+  const sftp = await accessor.sftp();
+  const remote = joinRoot(accessor.config.root ?? "/", stripPrefix(p));
+  return new Promise((resolveFn) => {
+    sftp.exists(remote, (yes) => {
+      resolveFn(yes);
+    });
+  });
+}
+
+// src/core/ssh/find.ts
+import { norm as norm2 } from "@struktoai/mirage-core";
+import {
+  buildTree,
+  emitStartPath,
+  keep,
+  startBasename
+} from "@struktoai/mirage-core";
+function isFileType(t) {
+  return t === "f" || t === "file";
+}
+function isDirType(t) {
+  return t === "d" || t === "directory";
+}
+function matches(entry, entryPath, isDir, depth, opts, tree) {
+  if (opts.maxDepth !== null && opts.maxDepth !== void 0 && depth > opts.maxDepth) return false;
+  const basename = entryPath.slice(entryPath.lastIndexOf("/") + 1);
+  const isEmpty = isDir ? false : entry.attrs.size === 0;
+  if (!keep(
+    { key: entryPath, name: basename, kind: isDir ? "d" : "f", depth, isEmpty },
+    tree,
+    opts.minDepth
+  )) {
+    return false;
+  }
+  if (opts.minSize != null || opts.maxSize != null) {
+    const size = isDir ? 0 : entry.attrs.size;
+    if (opts.minSize != null && size < opts.minSize) return false;
+    if (opts.maxSize != null && size > opts.maxSize) return false;
+  }
+  if (opts.mtimeMin !== null && opts.mtimeMin !== void 0 || opts.mtimeMax !== null && opts.mtimeMax !== void 0) {
+    const mtime = entry.attrs.mtime;
+    if (opts.mtimeMin !== null && opts.mtimeMin !== void 0 && mtime < opts.mtimeMin) return false;
+    if (opts.mtimeMax !== null && opts.mtimeMax !== void 0 && mtime > opts.mtimeMax) return false;
+  }
+  return true;
+}
+async function readRemoteDir2(accessor, remote) {
+  const sftp = await accessor.sftp();
+  return new Promise((resolveFn, rejectFn) => {
+    sftp.readdir(remote, (err, entries) => {
+      if (err !== void 0) {
+        const code = err.code;
+        if (code === 2) {
+          resolveFn(null);
+          return;
+        }
+        rejectFn(err);
+        return;
+      }
+      resolveFn(entries);
+    });
+  });
+}
+async function statRemote2(accessor, remote) {
+  const sftp = await accessor.sftp();
+  return new Promise((resolveFn, rejectFn) => {
+    sftp.stat(remote, (err, stats) => {
+      if (err !== void 0) {
+        const code = err.code;
+        if (code === 2) {
+          resolveFn(null);
+          return;
+        }
+        rejectFn(err);
+        return;
+      }
+      resolveFn({ isDir: stats.isDirectory(), size: stats.size });
+    });
+  });
+}
+async function walk(ctx, virtual, depth) {
+  const opts = ctx.options;
+  if (opts.maxDepth !== null && opts.maxDepth !== void 0 && depth > opts.maxDepth) return;
+  const remote = joinRoot(ctx.accessor.config.root ?? "/", virtual);
+  const entries = await readRemoteDir2(ctx.accessor, remote);
+  if (entries === null) return;
+  for (const entry of entries) {
+    if (entry.filename === "." || entry.filename === "..") continue;
+    const childPath = virtual === "/" ? `/${entry.filename}` : `${virtual}/${entry.filename}`;
+    const isDir = isDirectoryAttrs(entry.attrs);
+    if (matches(entry, childPath, isDir, depth + 1, opts, ctx.tree)) {
+      ctx.results.push(childPath);
+    }
+    if (isDir) {
+      await walk(ctx, childPath, depth + 1);
+    }
+  }
+}
+async function find(accessor, p, options = {}) {
+  const virtual = norm2(stripPrefix(p));
+  const startName = startBasename(p.virtual);
+  const results = [];
+  const baseDepth = (virtual.match(/\//g) ?? []).length;
+  const typeKind = isFileType(options.type) ? "f" : isDirType(options.type) ? "d" : null;
+  const tree = options.tree ?? buildTree({
+    name: options.name,
+    iname: options.iname,
+    pathPattern: options.pathPattern,
+    type: typeKind,
+    nameExclude: options.nameExclude,
+    orNames: options.orNames
+  });
+  if (options.maxDepth == null || options.maxDepth >= 0) {
+    const st = await statRemote2(accessor, joinRoot(accessor.config.root ?? "/", virtual));
+    emitStartPath(results, virtual, startName, {
+      kind: st?.isDir ? "d" : "f",
+      isEmpty: st === null ? null : st.isDir ? false : st.size === 0,
+      exists: st !== null,
+      tree,
+      maxDepth: options.maxDepth,
+      minDepth: options.minDepth,
+      size: st === null || st.isDir ? null : st.size,
+      minSize: options.minSize,
+      maxSize: options.maxSize
+    });
+  }
+  await walk({ accessor, options, results, baseDepth, tree }, virtual, 0);
+  results.sort();
+  return results;
+}
+
+// src/core/ssh/mkdir.ts
+import { invalidateAfterWrite as invalidateAfterWrite3, invalidateAncestors } from "@struktoai/mirage-core";
+import { enoent as enoent4, stripSlash } from "@struktoai/mirage-core";
+async function statRemote3(sftp, remote) {
+  return new Promise((resolveFn) => {
+    sftp.lstat(remote, (err, stats) => {
+      if (err) resolveFn(null);
+      else resolveFn(stats);
+    });
+  });
+}
+async function mkdirOne(sftp, remote, ignoreExisting) {
+  return new Promise((resolveFn, rejectFn) => {
+    sftp.mkdir(remote, (err) => {
+      if (!err) {
+        resolveFn();
+        return;
+      }
+      if (ignoreExisting) {
+        resolveFn();
+        return;
+      }
+      rejectFn(err);
+    });
+  });
+}
+async function mkdir(accessor, p, recursive) {
+  const sftp = await accessor.sftp();
+  const virtual = stripPrefix(p);
+  const root = accessor.config.root ?? "/";
+  const remote = joinRoot(root, virtual);
+  if (!recursive) {
+    try {
+      await mkdirOne(sftp, remote, false);
+    } catch (err) {
+      if (isNoSuchFile(err)) throw enoent4(p);
+      throw err;
+    }
+    return;
+  }
+  const cleaned = stripSlash(virtual);
+  if (cleaned.length === 0) return;
+  const parts = cleaned.split("/");
+  let cur = "";
+  for (const part of parts) {
+    cur = cur === "" ? `/${part}` : `${cur}/${part}`;
+    const stepRemote = joinRoot(root, cur);
+    const existing = await statRemote3(sftp, stepRemote);
+    if (existing?.isDirectory()) continue;
+    await mkdirOne(sftp, stepRemote, true);
+  }
+  await invalidateAfterWrite3(p);
+  await invalidateAncestors(p);
+}
+
+// src/core/ssh/readdir.ts
+import { enoent as enoent5, mountPrefixOf as mountPrefixOf2, stripSlash as stripSlash2 } from "@struktoai/mirage-core";
+async function readdir(accessor, p) {
+  const sftp = await accessor.sftp();
+  const virtual = p.pattern !== null ? p.directory.slice(mountPrefixOf2(p.virtual, p.resourcePath).length) || "/" : stripPrefix(p);
+  const remote = joinRoot(accessor.config.root ?? "/", virtual);
+  const list = await new Promise((resolveFn, rejectFn) => {
+    sftp.readdir(remote, (err, entries) => {
+      if (err !== void 0) {
+        if (isNoSuchFile(err)) rejectFn(enoent5(p));
+        else rejectFn(err);
+        return;
+      }
+      resolveFn(entries);
+    });
+  });
+  const base = `/${stripSlash2(virtual)}`;
+  const dirPrefix = base === "/" ? "/" : `${base}/`;
+  const mountPrefix = mountPrefixOf2(p.virtual, p.resourcePath);
+  const names = [];
+  for (const entry of list) {
+    if (entry.filename === "." || entry.filename === "..") continue;
+    names.push(`${mountPrefix}${dirPrefix}${entry.filename}`);
+  }
+  names.sort();
+  return names;
+}
+
+// src/core/ssh/rename.ts
+import { invalidateAfterUnlink, invalidateAfterWrite as invalidateAfterWrite4 } from "@struktoai/mirage-core";
+import { enoent as enoent6 } from "@struktoai/mirage-core";
+async function rename(accessor, src, dst) {
+  const sftp = await accessor.sftp();
+  const root = accessor.config.root ?? "/";
+  const srcVirtual = stripPrefix(src);
+  const dstVirtual = stripPrefix(dst);
+  const remoteSrc = joinRoot(root, srcVirtual);
+  const remoteDst = joinRoot(root, dstVirtual);
+  await new Promise((resolveFn, rejectFn) => {
+    const done = (err) => {
+      if (!err) resolveFn();
+      else if (isNoSuchFile(err)) rejectFn(enoent6(src));
+      else rejectFn(err);
+    };
+    try {
+      sftp.ext_openssh_rename(remoteSrc, remoteDst, done);
+    } catch {
+      sftp.rename(remoteSrc, remoteDst, done);
+    }
+  });
+  await invalidateAfterWrite4(dst);
+  await invalidateAfterUnlink(src);
+}
+
+// src/core/ssh/rm.ts
+import { enoent as enoent7, invalidateAfterUnlink as invalidateAfterUnlink2 } from "@struktoai/mirage-core";
+async function statRemote4(sftp, remote) {
+  return new Promise((resolveFn, rejectFn) => {
+    sftp.lstat(remote, (err, stats) => {
+      if (err !== void 0) rejectFn(err);
+      else resolveFn(stats);
+    });
+  });
+}
+async function readdirRemote(sftp, remote) {
+  return new Promise((resolveFn, rejectFn) => {
+    sftp.readdir(remote, (err, list) => {
+      if (err !== void 0) rejectFn(err);
+      else resolveFn(list);
+    });
+  });
+}
+async function unlinkRemote(sftp, remote) {
+  return new Promise((resolveFn, rejectFn) => {
+    sftp.unlink(remote, (err) => {
+      if (err) rejectFn(err);
+      else resolveFn();
+    });
+  });
+}
+async function rmdirRemote(sftp, remote) {
+  return new Promise((resolveFn, rejectFn) => {
+    sftp.rmdir(remote, (err) => {
+      if (err) rejectFn(err);
+      else resolveFn();
+    });
+  });
+}
+async function rmRecurse(sftp, remote) {
+  const stats = await statRemote4(sftp, remote);
+  if (isDirectoryAttrs(stats)) {
+    const entries = await readdirRemote(sftp, remote);
+    for (const entry of entries) {
+      if (entry.filename === "." || entry.filename === "..") continue;
+      const child = remote === "/" ? `/${entry.filename}` : `${remote}/${entry.filename}`;
+      await rmRecurse(sftp, child);
+    }
+    await rmdirRemote(sftp, remote);
+    return;
+  }
+  await unlinkRemote(sftp, remote);
+}
+async function rmR(accessor, p) {
+  const sftp = await accessor.sftp();
+  const virtual = stripPrefix(p);
+  const remote = joinRoot(accessor.config.root ?? "/", virtual);
+  try {
+    await rmRecurse(sftp, remote);
+  } catch (err) {
+    if (isNoSuchFile(err)) throw enoent7(p);
+    throw err;
+  }
+  await invalidateAfterUnlink2(p);
+}
+
+// src/core/ssh/rmdir.ts
+import { enoent as enoent8, invalidateAfterUnlink as invalidateAfterUnlink3 } from "@struktoai/mirage-core";
+async function rmdir(accessor, p) {
+  const sftp = await accessor.sftp();
+  const virtual = stripPrefix(p);
+  const remote = joinRoot(accessor.config.root ?? "/", virtual);
+  await new Promise((resolveFn, rejectFn) => {
+    sftp.rmdir(remote, (err) => {
+      if (!err) {
+        resolveFn();
+        return;
+      }
+      if (isNoSuchFile(err)) rejectFn(enoent8(p));
+      else rejectFn(err);
+    });
+  });
+  await invalidateAfterUnlink3(p);
+}
+
+// src/core/ssh/truncate.ts
+async function truncate(accessor, p, length) {
+  let data;
+  try {
+    data = await read(accessor, p);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      data = new Uint8Array(0);
+    } else {
+      throw err;
+    }
+  }
+  const out = new Uint8Array(length);
+  out.set(data.subarray(0, Math.min(data.byteLength, length)));
+  await writeBytes(accessor, p, out);
+}
+
+// src/core/ssh/unlink.ts
+import { invalidateAfterUnlink as invalidateAfterUnlink4 } from "@struktoai/mirage-core";
+import { enoent as enoent9 } from "@struktoai/mirage-core";
+async function unlink(accessor, p) {
+  const sftp = await accessor.sftp();
+  const virtual = stripPrefix(p);
+  const remote = joinRoot(accessor.config.root ?? "/", virtual);
+  await new Promise((resolveFn, rejectFn) => {
+    sftp.unlink(remote, (err) => {
+      if (!err) {
+        resolveFn();
+        return;
+      }
+      if (isNoSuchFile(err)) rejectFn(enoent9(p));
+      else rejectFn(err);
+    });
+  });
+  await invalidateAfterUnlink4(p);
+}
+
+// src/commands/builtin/ssh/io.ts
+var SSH_IO = {
+  maxGlobMatches: SCOPE_ERROR,
+  readdir,
+  readBytes: read,
+  readStream: stream,
+  stat,
+  isMounted: () => true,
+  local: false,
+  write: writeBytes,
+  exists,
+  mkdir: (accessor, path, parents) => mkdir(accessor, path, parents === true),
+  unlink,
+  rmdir,
+  rmR,
+  rename,
+  copy,
+  create,
+  truncate,
+  append: appendBytes,
+  find,
+  duTotal: du,
+  duAll
+};
+
+// src/commands/builtin/ssh/index.ts
+var SSH_COMMANDS = [
+  ...makeFiletypeCommands({
+    resource: ResourceName2.SSH,
+    readBytes: read,
+    statEntry: stat
+  }),
+  ...makeGenericCommands(ResourceName2.SSH, SSH_IO)
+];
+
+// src/ops/ssh/index.ts
+import { ResourceName as ResourceName3, makeGenericOps } from "@struktoai/mirage-core";
+var SSH_OPS = makeGenericOps(ResourceName3.SSH, SSH_IO, {
+  mkdirParents: true,
+  forwardIndex: false
+});
+
+// src/resource/ssh/prompt.ts
+var SSH_PROMPT = `{prefix}
+  Remote filesystem via SSH/SFTP.
+  IMPORTANT: This is a remote mount. Prefer targeted reads over full scans.
+  Supports: ls, cat, head, tail, grep, rg, wc, find, tree, stat, mkdir, touch, cp, mv, rm, tee.`;
+
+// src/resource/ssh/ssh.ts
+var globCore = makeResolveGlob(readdir, SCOPE_ERROR);
+var SSHResource = class extends BaseResource {
+  kind = ResourceName4.SSH;
+  cachesReads = true;
+  indexTtl = 60;
+  prompt = SSH_PROMPT;
+  config;
+  accessor;
+  opsMap = {
+    read_bytes: read,
+    write: writeBytes,
+    readdir,
+    stat,
+    unlink,
+    rmdir,
+    copy,
+    rename,
+    mkdir,
+    read_stream: stream,
+    range_read: rangeRead,
+    rm_recursive: rmR,
+    du_total: du,
+    du_all: duAll,
+    create,
+    truncate,
+    exists,
+    find_flat: find,
+    append: appendBytes
+  };
+  constructor(config) {
+    super();
+    this.config = config;
+    this.accessor = new SSHAccessor(config);
+  }
+  open() {
+    return Promise.resolve();
+  }
+  close() {
+    return this.accessor.close();
+  }
+  ops() {
+    return SSH_OPS;
+  }
+  commands() {
+    return SSH_COMMANDS;
+  }
+  streamPath(p) {
+    return stream(this.accessor, p);
+  }
+  readFile(p) {
+    return read(this.accessor, p);
+  }
+  writeFile(p, data) {
+    return writeBytes(this.accessor, p, data);
+  }
+  appendFile(p, data) {
+    return appendBytes(this.accessor, p, data);
+  }
+  readdir(p) {
+    return readdir(this.accessor, p);
+  }
+  stat(p) {
+    return stat(this.accessor, p);
+  }
+  exists(p) {
+    return exists(this.accessor, p);
+  }
+  mkdir(p, options) {
+    return mkdir(this.accessor, p, options?.recursive === true);
+  }
+  rmdir(p) {
+    return rmdir(this.accessor, p);
+  }
+  unlink(p) {
+    return unlink(this.accessor, p);
+  }
+  rename(src, dst) {
+    return rename(this.accessor, src, dst);
+  }
+  truncate(p, length) {
+    return truncate(this.accessor, p, length);
+  }
+  copy(src, dst) {
+    return copy(this.accessor, src, dst);
+  }
+  rmR(p) {
+    return rmR(this.accessor, p);
+  }
+  du(p) {
+    return du(this.accessor, p);
+  }
+  find(p, options = {}) {
+    return find(this.accessor, p, options);
+  }
+  glob(paths, prefix = "") {
+    const effective = prefix ? paths.map(
+      (p) => mountPrefixOf3(p.virtual, p.resourcePath) ? p : new PathSpec({
+        virtual: p.virtual,
+        directory: p.directory,
+        ...p.pattern !== null ? { pattern: p.pattern } : {},
+        resolved: p.resolved,
+        resourcePath: mountKey(p.virtual, prefix)
+      })
+    ) : paths;
+    return globCore(this.accessor, effective);
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async getState() {
+    return {
+      type: this.kind,
+      config: redactSshConfig(this.config)
+    };
+  }
+  loadState(_state) {
+    return Promise.resolve();
+  }
+};
+
+export {
+  SSHAccessor,
+  SSH_COMMANDS,
+  SSH_OPS,
+  SSH_PROMPT,
+  SSHResource
+};
+//# sourceMappingURL=chunk-5ZHNPNDD.js.map