@struktoai/mirage-node 0.0.1-alpha.1

package/dist/chunk-M42JTWPR.js

@@ -0,0 +1,2794 @@
+import {
+  redactSshConfig
+} from "./chunk-FZ2GJ4BJ.js";
+import {
+  SCOPE_ERROR
+} from "./chunk-U6QSXTUS.js";
+
+// src/resource/ssh/ssh.ts
+import {
+  PathSpec as PathSpec9,
+  RAMIndexCacheStore,
+  ResourceName as ResourceName33
+} 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/basename.ts
+import {
+  IOResult,
+  ResourceName,
+  command,
+  specOf
+} from "@struktoai/mirage-core";
+function basenameCommand(_accessor, paths, texts, _opts) {
+  const arg = texts[0] ?? paths[0]?.original ?? "";
+  const stripped = arg.replace(/\/+$/, "");
+  const idx = stripped.lastIndexOf("/");
+  const base = idx >= 0 ? stripped.slice(idx + 1) : stripped;
+  const out = new TextEncoder().encode(`${base}
+`);
+  return [out, new IOResult()];
+}
+var SSH_BASENAME = command({
+  name: "basename",
+  resource: ResourceName.SSH,
+  spec: specOf("basename"),
+  fn: basenameCommand
+});
+
+// src/commands/builtin/ssh/cat/cat.ts
+import {
+  AsyncLineIterator,
+  CachableAsyncIterator,
+  IOResult as IOResult2,
+  ProvisionResult,
+  ResourceName as ResourceName2,
+  command as command2,
+  concatAggregate,
+  resolveSource,
+  specOf as specOf2
+} from "@struktoai/mirage-core";
+
+// src/core/ssh/utils.ts
+var S_IFMT = 61440;
+var S_IFDIR = 16384;
+var S_IFREG = 32768;
+function stripPrefix(p) {
+  if (p.prefix && p.original.startsWith(p.prefix)) {
+    return p.original.slice(p.prefix.length) || "/";
+  }
+  return p.original;
+}
+function joinRoot(root, rel) {
+  const r = root.replace(/\/+$/, "");
+  const stripped = rel.replace(/^\/+/, "");
+  if (stripped === "") return r === "" ? "/" : r;
+  if (r === "") return `/${stripped}`;
+  return `${r}/${stripped}`;
+}
+function enoent(path) {
+  const err = new Error(`file not found: ${path}`);
+  err.code = "ENOENT";
+  return err;
+}
+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* 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 {
+    for await (const chunk of rs) {
+      const buf = chunk;
+      yield new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+    }
+  } catch (err) {
+    if (isNoSuchFile(err)) throw enoent(virtual);
+    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 chunk of rs) {
+      const buf = chunk;
+      const u8 = new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+      chunks.push(u8);
+      total += u8.byteLength;
+    }
+  } catch (err) {
+    if (isNoSuchFile(err)) throw enoent(virtual);
+    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
+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(enoent(virtual));
+        else rejectFn(err);
+        return;
+      }
+      resolveFn(stats);
+    });
+  });
+  const cleaned = virtual.replace(/\/+$/, "");
+  const name = cleaned.length === 0 ? "/" : cleaned.split("/").pop() ?? "/";
+  return attrsToFileStat(name, attrs);
+}
+
+// src/commands/builtin/ssh/cat/cat.ts
+var ENC = new TextEncoder();
+async function* numberLinesStream(source) {
+  let num = 1;
+  const lineIter = new AsyncLineIterator(source);
+  for await (const line of lineIter) {
+    yield ENC.encode(`     ${String(num)}	`);
+    yield line;
+    yield ENC.encode("\n");
+    num += 1;
+  }
+}
+async function catProvision(accessor, paths, _texts, _opts) {
+  const [first] = paths;
+  if (first === void 0) return new ProvisionResult({ command: "cat" });
+  try {
+    const s = await stat(accessor, first);
+    return new ProvisionResult({
+      command: `cat ${first.original}`,
+      networkReadLow: s.size ?? 0,
+      networkReadHigh: s.size ?? 0,
+      readOps: 1
+    });
+  } catch {
+    return new ProvisionResult({ command: "cat" });
+  }
+}
+async function* chainStreams(streams) {
+  for (const s of streams) {
+    for await (const chunk of s) yield chunk;
+  }
+}
+async function catCommand(accessor, paths, texts, opts) {
+  const nFlag = opts.flags.n === true;
+  if (paths.length > 0) {
+    for (const p of paths) await stat(accessor, p);
+    const reads = {};
+    const cacheKeys = [];
+    const outputs = [];
+    for (const p of paths) {
+      const cachable = new CachableAsyncIterator(stream(accessor, p));
+      reads[p.stripPrefix] = cachable;
+      cacheKeys.push(p.stripPrefix);
+      outputs.push(cachable);
+    }
+    const merged = chainStreams(outputs);
+    const out = nFlag ? numberLinesStream(merged) : merged;
+    return [out, new IOResult2({ reads, cache: cacheKeys })];
+  }
+  try {
+    const source = resolveSource(opts.stdin, "cat: missing operand");
+    const out = nFlag ? numberLinesStream(source) : source;
+    return [out, new IOResult2()];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [null, new IOResult2({ exitCode: 1, stderr: ENC.encode(`${msg}
+`) })];
+  }
+}
+var SSH_CAT = command2({
+  name: "cat",
+  resource: ResourceName2.SSH,
+  spec: specOf2("cat"),
+  fn: catCommand,
+  provision: catProvision,
+  aggregate: concatAggregate
+});
+
+// src/commands/builtin/ssh/cp.ts
+import {
+  IOResult as IOResult3,
+  PathSpec,
+  ResourceName as ResourceName3,
+  command as command3,
+  specOf as specOf3
+} from "@struktoai/mirage-core";
+
+// 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);
+  return new Promise((resolveFn, rejectFn) => {
+    sftp.readFile(remote, (err, buf) => {
+      if (err !== void 0) {
+        if (isNoSuchFile(err)) rejectFn(enoent(virtual));
+        else rejectFn(err);
+        return;
+      }
+      resolveFn(new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength));
+    });
+  });
+}
+
+// src/core/ssh/write.ts
+async function writeBytes(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.writeFile(remote, Buffer.from(data), (err) => {
+      if (err) rejectFn(err);
+      else resolveFn();
+    });
+  });
+}
+
+// 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/find.ts
+function fnmatch(name, pattern) {
+  let re = "^";
+  for (const ch of pattern) {
+    if (ch === "*") re += ".*";
+    else if (ch === "?") re += ".";
+    else if (/[.+^${}()|[\]\\]/.test(ch)) re += "\\" + ch;
+    else re += ch;
+  }
+  re += "$";
+  return new RegExp(re).test(name);
+}
+function norm(p) {
+  return `/${p.replace(/^\/+|\/+$/g, "")}`;
+}
+function isFileType(t) {
+  return t === "f" || t === "file";
+}
+function isDirType(t) {
+  return t === "d" || t === "directory";
+}
+function matches(entry, entryPath, isDir, depth, opts) {
+  if (opts.minDepth !== null && opts.minDepth !== void 0 && depth < opts.minDepth) return false;
+  if (isFileType(opts.type) && isDir) return false;
+  if (isDirType(opts.type) && !isDir) return false;
+  const basename = entryPath.slice(entryPath.lastIndexOf("/") + 1);
+  if (opts.orNames !== null && opts.orNames !== void 0 && opts.orNames.length > 0) {
+    if (!opts.orNames.some((pat) => fnmatch(basename, pat))) return false;
+  } else if (opts.name !== null && opts.name !== void 0) {
+    if (!fnmatch(basename, opts.name)) return false;
+  }
+  if (opts.iname !== null && opts.iname !== void 0 && !fnmatch(basename.toLowerCase(), opts.iname.toLowerCase())) {
+    return false;
+  }
+  if (opts.nameExclude !== null && opts.nameExclude !== void 0 && fnmatch(basename, opts.nameExclude)) {
+    return false;
+  }
+  if (opts.pathPattern !== null && opts.pathPattern !== void 0 && !fnmatch(entryPath, opts.pathPattern)) {
+    return false;
+  }
+  const size = entry.attrs.size;
+  if (opts.minSize !== null && opts.minSize !== void 0 && size < opts.minSize) return false;
+  if (opts.maxSize !== null && opts.maxSize !== void 0 && 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 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 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 readRemoteDir(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 (isFileType(opts.type) && isDir) {
+      await walk(ctx, childPath, depth + 1);
+      continue;
+    }
+    if (matches(entry, childPath, isDir, depth + 1, opts)) {
+      ctx.results.push(childPath);
+    }
+    if (isDir) {
+      await walk(ctx, childPath, depth + 1);
+    }
+  }
+}
+async function find(accessor, p, options = {}) {
+  const virtual = norm(stripPrefix(p));
+  const results = [];
+  const baseDepth = (virtual.match(/\//g) ?? []).length;
+  await walk({ accessor, options, results, baseDepth }, virtual, 0);
+  results.sort();
+  return results;
+}
+
+// src/commands/builtin/ssh/cp.ts
+async function exists(accessor, path) {
+  try {
+    await stat(accessor, path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function toPathSpec(strPath, prefix) {
+  return new PathSpec({
+    original: strPath,
+    directory: strPath,
+    resolved: false,
+    prefix
+  });
+}
+async function cpCommand(accessor, paths, _texts, opts) {
+  if (paths.length < 2) {
+    return [
+      null,
+      new IOResult3({
+        exitCode: 1,
+        stderr: new TextEncoder().encode("cp: missing operand\n")
+      })
+    ];
+  }
+  const recursive = opts.flags.r === true || opts.flags.R === true || opts.flags.a === true;
+  const noClobber = opts.flags.n === true;
+  const verbose = opts.flags.v === true;
+  const dst = paths[paths.length - 1];
+  if (dst === void 0) return [null, new IOResult3()];
+  const lines = [];
+  if (recursive) {
+    const src = paths[0];
+    if (src === void 0) return [null, new IOResult3()];
+    const srcBase = src.stripPrefix.replace(/\/+$/, "");
+    const dstBase = dst.stripPrefix.replace(/\/+$/, "");
+    const entries = await find(accessor, src, { type: "f" });
+    for (const entry of entries) {
+      const rel = entry.slice(srcBase.length);
+      const dstPath = dstBase + rel;
+      const dstSpec = toPathSpec(dstPath, dst.prefix);
+      if (noClobber && await exists(accessor, dstSpec)) continue;
+      const srcSpec = toPathSpec(entry, src.prefix);
+      await copy(accessor, srcSpec, dstSpec);
+      if (verbose) lines.push(`${entry} -> ${dstPath}`);
+    }
+    const out2 = lines.length > 0 ? new TextEncoder().encode(lines.join("\n") + "\n") : null;
+    return [out2, new IOResult3()];
+  }
+  const sources = paths.slice(0, -1);
+  for (const src of sources) {
+    if (noClobber && await exists(accessor, dst)) continue;
+    await copy(accessor, src, dst);
+    if (verbose) lines.push(`${src.original} -> ${dst.original}`);
+  }
+  const out = lines.length > 0 ? new TextEncoder().encode(lines.join("\n") + "\n") : null;
+  return [out, new IOResult3()];
+}
+var SSH_CP = command3({
+  name: "cp",
+  resource: ResourceName3.SSH,
+  spec: specOf3("cp"),
+  fn: cpCommand,
+  write: true
+});
+
+// src/commands/builtin/ssh/dirname.ts
+import {
+  IOResult as IOResult4,
+  ResourceName as ResourceName4,
+  command as command4,
+  specOf as specOf4
+} from "@struktoai/mirage-core";
+function dirnameCommand(_accessor, paths, texts, _opts) {
+  const arg = texts[0] ?? paths[0]?.original ?? "";
+  const stripped = arg.replace(/\/+$/, "");
+  const idx = stripped.lastIndexOf("/");
+  const dir = idx > 0 ? stripped.slice(0, idx) : idx === 0 ? "/" : ".";
+  const out = new TextEncoder().encode(`${dir}
+`);
+  return [out, new IOResult4()];
+}
+var SSH_DIRNAME = command4({
+  name: "dirname",
+  resource: ResourceName4.SSH,
+  spec: specOf4("dirname"),
+  fn: dirnameCommand
+});
+
+// src/commands/builtin/ssh/du.ts
+import {
+  IOResult as IOResult5,
+  PathSpec as PathSpec2,
+  ResourceName as ResourceName5,
+  command as command5,
+  specOf as specOf5
+} from "@struktoai/mirage-core";
+
+// src/core/ssh/du.ts
+function norm2(p) {
+  return `/${p.replace(/^\/+|\/+$/g, "")}`;
+}
+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 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 readRemoteDir2(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 readRemoteDir2(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 = norm2(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/commands/builtin/ssh/du.ts
+function humanSize(n) {
+  const units = ["", "K", "M", "G", "T"];
+  let v = n;
+  let i = 0;
+  while (v >= 1024 && i < units.length - 1) {
+    v /= 1024;
+    i += 1;
+  }
+  const s = v >= 10 || i === 0 ? Math.round(v).toString() : v.toFixed(1);
+  return `${s}${units[i] ?? ""}`;
+}
+function depthOf(entryPath, basePath) {
+  const base = basePath.replace(/\/+$/, "");
+  const rel = entryPath.replace(/\/+$/, "").slice(base.length);
+  if (!rel) return 0;
+  return (rel.replace(/^\/+|\/+$/g, "").match(/\//g) ?? []).length + 1;
+}
+async function duCommand(accessor, paths, _texts, opts) {
+  const human = opts.flags.h === true;
+  const summarize = opts.flags.s === true;
+  const all = opts.flags.a === true;
+  const cumulative = opts.flags.c === true;
+  const maxDepthRaw = opts.flags["max-depth"];
+  const maxDepth = typeof maxDepthRaw === "string" ? Number.parseInt(maxDepthRaw, 10) : null;
+  const fmt = (size) => human ? humanSize(size) : String(size);
+  const targets = paths.length > 0 ? paths : [new PathSpec2({ original: "/", directory: "/", resolved: false })];
+  const path = targets[0];
+  if (path === void 0) return [null, new IOResult5()];
+  if (summarize) {
+    const total = await du(accessor, path);
+    let output = `${fmt(total)}	${path.original}`;
+    if (cumulative) output += `
+${fmt(total)}	total`;
+    return [new TextEncoder().encode(output), new IOResult5()];
+  }
+  const [allEntriesRaw, totalFromAll] = await duAll(accessor, path);
+  let entries = allEntriesRaw;
+  if (entries.length === 0) {
+    const total = await du(accessor, path);
+    let output = `${fmt(total)}	${path.original}`;
+    if (cumulative) output += `
+${fmt(total)}	total`;
+    return [new TextEncoder().encode(output), new IOResult5()];
+  }
+  if (!all) {
+    entries = entries.filter(([p]) => p === path.original);
+  }
+  if (maxDepth !== null) {
+    entries = entries.filter(([p]) => depthOf(p, path.original) <= maxDepth);
+  }
+  if (entries.length === 0) {
+    const total = totalFromAll !== 0 ? totalFromAll : await du(accessor, path);
+    let output = `${fmt(total)}	${path.original}`;
+    if (cumulative) output += `
+${fmt(total)}	total`;
+    return [new TextEncoder().encode(output), new IOResult5()];
+  }
+  const lines = entries.map(([p, sz]) => `${fmt(sz)}	${p}`);
+  if (cumulative) {
+    const grand = entries.reduce((acc, [, sz]) => acc + sz, 0);
+    lines.push(`${fmt(grand)}	total`);
+  }
+  return [new TextEncoder().encode(lines.join("\n")), new IOResult5()];
+}
+var SSH_DU = command5({
+  name: "du",
+  resource: ResourceName5.SSH,
+  spec: specOf5("du"),
+  fn: duCommand
+});
+
+// src/commands/builtin/ssh/file/file.ts
+import {
+  FileType as FileType2,
+  IOResult as IOResult6,
+  ResourceName as ResourceName6,
+  command as command6,
+  detectFileType,
+  formatFileResult,
+  specOf as specOf6
+} from "@struktoai/mirage-core";
+var ENC2 = new TextEncoder();
+async function fileCommand(accessor, paths, texts, opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult6({ exitCode: 1, stderr: ENC2.encode("file: missing operand\n") })];
+  }
+  const brief = opts.flags.b === true;
+  const mime = opts.flags.i === true;
+  const lines = [];
+  for (const p of paths) {
+    const s = await stat(accessor, p);
+    if (s.type === FileType2.DIRECTORY) {
+      lines.push(formatFileResult(p.original, FileType2.DIRECTORY, brief, mime));
+      continue;
+    }
+    let header;
+    try {
+      const raw = await read(accessor, p);
+      header = raw.subarray(0, 512);
+    } catch {
+      header = new Uint8Array(0);
+    }
+    const result = detectFileType(header, s);
+    lines.push(formatFileResult(p.original, result, brief, mime));
+  }
+  const out = ENC2.encode(lines.join("\n"));
+  return [out, new IOResult6()];
+}
+var SSH_FILE = command6({
+  name: "file",
+  resource: ResourceName6.SSH,
+  spec: specOf6("file"),
+  fn: fileCommand
+});
+
+// src/commands/builtin/ssh/find.ts
+import {
+  IOResult as IOResult7,
+  PathSpec as PathSpec3,
+  ResourceName as ResourceName7,
+  command as command7,
+  specOf as specOf7
+} from "@struktoai/mirage-core";
+function parseSize(spec) {
+  const suffixes = { c: 1, k: 1024, M: 1024 ** 2, G: 1024 ** 3 };
+  const sign = spec.startsWith("+") ? "+" : spec.startsWith("-") ? "-" : "";
+  const raw = sign === "" ? spec : spec.slice(1);
+  const lastChar = raw.slice(-1);
+  const mult = suffixes[lastChar] ?? 1;
+  const numPart = lastChar in suffixes ? raw.slice(0, -1) : raw;
+  const num = Number.parseInt(numPart, 10) * mult;
+  if (sign === "+") return [num, null];
+  if (sign === "-") return [null, num];
+  return [num, num];
+}
+function parseMtime(spec) {
+  const now = Date.now() / 1e3;
+  const day = 86400;
+  const n = Number.parseInt(spec.replace(/^[+-]/, ""), 10);
+  if (spec.startsWith("+")) return [null, now - n * day];
+  if (spec.startsWith("-")) return [now - n * day, null];
+  return [now - (n + 1) * day, now - n * day];
+}
+function extractNotName(texts) {
+  for (let i = 0; i < texts.length; i++) {
+    const pat = texts[i + 2];
+    if (texts[i] === "-not" && texts[i + 1] === "-name" && pat !== void 0) {
+      return pat;
+    }
+  }
+  return null;
+}
+function extractOrNames(name, texts) {
+  const names = [];
+  if (name !== null) names.push(name);
+  let i = 0;
+  while (i < texts.length) {
+    const pat = texts[i + 2];
+    if (texts[i] === "-or" && texts[i + 1] === "-name" && pat !== void 0) {
+      names.push(pat);
+      i += 3;
+    } else {
+      i += 1;
+    }
+  }
+  return names;
+}
+async function findCommand(accessor, paths, texts, opts) {
+  const nameFlag = typeof opts.flags.name === "string" ? opts.flags.name : null;
+  const inameFlag = typeof opts.flags.iname === "string" ? opts.flags.iname : null;
+  const typeFlag = typeof opts.flags.type === "string" ? opts.flags.type : null;
+  const pathFlag = typeof opts.flags.path === "string" ? opts.flags.path : null;
+  const maxDepthFlag = typeof opts.flags.maxdepth === "string" ? opts.flags.maxdepth : null;
+  const minDepthFlag = typeof opts.flags.mindepth === "string" ? opts.flags.mindepth : null;
+  const sizeFlag = typeof opts.flags.size === "string" ? opts.flags.size : null;
+  const mtimeFlag = typeof opts.flags.mtime === "string" ? opts.flags.mtime : null;
+  const targets = paths.length > 0 ? paths : [new PathSpec3({ original: "/", directory: "/", resolved: false })];
+  const findType = typeFlag === "f" ? "f" : typeFlag === "d" ? "d" : null;
+  const maxDepth = maxDepthFlag !== null ? Number.parseInt(maxDepthFlag, 10) : null;
+  const minDepth = minDepthFlag !== null ? Number.parseInt(minDepthFlag, 10) : null;
+  const [minSize, maxSize] = sizeFlag !== null ? parseSize(sizeFlag) : [null, null];
+  const [mtimeMin, mtimeMax] = mtimeFlag !== null ? parseMtime(mtimeFlag) : [null, null];
+  const nameExclude = extractNotName(texts);
+  const orNames = extractOrNames(nameFlag, texts);
+  const matches2 = [];
+  for (const root of targets) {
+    let keys;
+    try {
+      keys = await find(accessor, root, {
+        name: nameFlag,
+        iname: inameFlag,
+        type: findType,
+        ...maxDepth !== null ? { maxDepth } : {},
+        ...minDepth !== null ? { minDepth } : {},
+        ...minSize !== null ? { minSize } : {},
+        ...maxSize !== null ? { maxSize } : {},
+        ...mtimeMin !== null ? { mtimeMin } : {},
+        ...mtimeMax !== null ? { mtimeMax } : {},
+        ...nameExclude !== null ? { nameExclude } : {},
+        ...pathFlag !== null ? { pathPattern: pathFlag } : {},
+        ...orNames.length > 1 ? { orNames } : {}
+      });
+    } catch {
+      continue;
+    }
+    const rootKey = root.stripPrefix.replace(/\/+$/, "") || "/";
+    for (const key of keys) {
+      const displayPath = root.original === "/" ? key : root.original.replace(/\/+$/, "") + key.slice(rootKey === "/" ? 0 : rootKey.length);
+      matches2.push(displayPath);
+    }
+  }
+  matches2.sort();
+  const out = new TextEncoder().encode(matches2.join("\n"));
+  return [out, new IOResult7()];
+}
+var SSH_FIND = command7({
+  name: "find",
+  resource: ResourceName7.SSH,
+  spec: specOf7("find"),
+  fn: findCommand
+});
+
+// src/commands/builtin/ssh/grep/grep.ts
+import {
+  FileType as FileType3,
+  IOResult as IOResult8,
+  PathSpec as PathSpec4,
+  ResourceName as ResourceName8,
+  command as command8,
+  compilePattern,
+  exitOnEmpty,
+  grepLines,
+  grepStream,
+  materialize,
+  prefixAggregate,
+  quietMatch,
+  resolveSource as resolveSource2,
+  specOf as specOf8
+} from "@struktoai/mirage-core";
+var ENC3 = new TextEncoder();
+var DEC = new TextDecoder("utf-8", { fatal: false });
+function getPattern(texts, flags) {
+  if (typeof flags.e === "string") return flags.e;
+  if (texts.length > 0 && texts[0] !== void 0) return texts[0];
+  throw new Error("grep: usage: grep [flags] pattern [path]");
+}
+function parseFlags(flags) {
+  const toInt = (v) => typeof v === "string" ? Number.parseInt(v, 10) : null;
+  const aCtx = toInt(flags.A);
+  const bCtx = toInt(flags.B);
+  const cCtx = toInt(flags.C);
+  return {
+    ignoreCase: flags.i === true,
+    invert: flags.v === true,
+    lineNumbers: flags.n === true,
+    countOnly: flags.c === true,
+    filesOnly: flags.args_l === true || flags.l === true,
+    wholeWord: flags.w === true,
+    fixedString: flags.F === true,
+    onlyMatching: flags.o === true,
+    maxCount: toInt(flags.m),
+    quiet: flags.q === true,
+    afterContext: aCtx ?? cCtx ?? 0,
+    beforeContext: bCtx ?? cCtx ?? 0
+  };
+}
+async function readFile(accessor, p) {
+  return materialize(stream(accessor, p));
+}
+function splitLinesNoTrailing(text) {
+  const stripped = text.endsWith("\n") ? text.slice(0, -1) : text;
+  return stripped === "" ? [] : stripped.split("\n");
+}
+async function expandRecursive(accessor, paths) {
+  const expanded = [];
+  for (const p of paths) {
+    try {
+      const st = await stat(accessor, p);
+      if (st.type === FileType3.DIRECTORY) {
+        const entries = await find(accessor, p, { type: "f" });
+        for (const entry of entries) {
+          expanded.push(
+            new PathSpec4({
+              original: entry,
+              directory: entry,
+              resolved: false,
+              prefix: p.prefix
+            })
+          );
+        }
+      } else {
+        expanded.push(p);
+      }
+    } catch {
+      expanded.push(p);
+    }
+  }
+  return expanded;
+}
+async function grepImpl(name, accessor, paths, texts, opts) {
+  let pattern;
+  try {
+    pattern = getPattern(texts, opts.flags);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [null, new IOResult8({ exitCode: 2, stderr: ENC3.encode(`${msg}
+`) })];
+  }
+  const f = parseFlags(opts.flags);
+  const recursive = opts.flags.r === true || opts.flags.R === true;
+  if (recursive && paths.length > 0) {
+    const pat2 = compilePattern(pattern, f.ignoreCase, f.fixedString, f.wholeWord);
+    const expanded = await expandRecursive(accessor, paths);
+    const allResults = [];
+    for (const p of expanded) {
+      const data = splitLinesNoTrailing(DEC.decode(await readFile(accessor, p)));
+      const hits = grepLines(p.original, data, pat2, f);
+      if (f.countOnly) {
+        if (hits.length > 0) allResults.push(`${p.original}:${hits[0] ?? ""}`);
+      } else if (f.filesOnly) {
+        for (const h of hits) allResults.push(h);
+      } else {
+        for (const h of hits) allResults.push(`${p.original}:${h}`);
+      }
+    }
+    if (allResults.length === 0) return [new Uint8Array(0), new IOResult8({ exitCode: 1 })];
+    const out = ENC3.encode(allResults.join("\n"));
+    return [out, new IOResult8()];
+  }
+  if (paths.length > 0) {
+    const pat2 = compilePattern(pattern, f.ignoreCase, f.fixedString, f.wholeWord);
+    if (paths.length > 1) {
+      const allResults = [];
+      for (const p of paths) {
+        const data = splitLinesNoTrailing(DEC.decode(await readFile(accessor, p)));
+        const hits = grepLines(p.original, data, pat2, f);
+        if (f.countOnly) {
+          if (hits.length > 0) allResults.push(`${p.original}:${hits[0] ?? ""}`);
+        } else if (f.filesOnly) {
+          for (const h of hits) allResults.push(h);
+        } else {
+          for (const h of hits) allResults.push(`${p.original}:${h}`);
+        }
+      }
+      if (allResults.length === 0) return [new Uint8Array(0), new IOResult8({ exitCode: 1 })];
+      const out = ENC3.encode(allResults.join("\n"));
+      return [out, new IOResult8()];
+    }
+    const first = paths[0];
+    if (first === void 0) return [null, new IOResult8()];
+    await stat(accessor, first);
+    if (f.filesOnly) {
+      const data = splitLinesNoTrailing(DEC.decode(await readFile(accessor, first)));
+      const hits = grepLines(first.original, data, pat2, f);
+      if (hits.length === 0) return [new Uint8Array(0), new IOResult8({ exitCode: 1 })];
+      return [ENC3.encode(hits.join("\n")), new IOResult8()];
+    }
+    const source2 = stream(accessor, first);
+    const stream3 = grepStream(source2, pat2, f);
+    if (f.quiet) {
+      const io3 = new IOResult8({ exitCode: 1 });
+      return [quietMatch(stream3, io3), io3];
+    }
+    const io2 = new IOResult8();
+    return [exitOnEmpty(stream3, io2), io2];
+  }
+  let source;
+  try {
+    source = resolveSource2(opts.stdin, `${name}: usage: ${name} [flags] pattern [path]`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [null, new IOResult8({ exitCode: 2, stderr: ENC3.encode(`${msg}
+`) })];
+  }
+  const pat = compilePattern(pattern, f.ignoreCase, f.fixedString, f.wholeWord);
+  const stream2 = grepStream(source, pat, f);
+  if (f.quiet) {
+    const io2 = new IOResult8({ exitCode: 1 });
+    return [quietMatch(stream2, io2), io2];
+  }
+  const io = new IOResult8();
+  return [exitOnEmpty(stream2, io), io];
+}
+var grepFn = (accessor, paths, texts, opts) => {
+  return grepImpl("grep", accessor, paths, texts, opts);
+};
+var SSH_GREP = command8({
+  name: "grep",
+  resource: ResourceName8.SSH,
+  spec: specOf8("grep"),
+  fn: grepFn,
+  aggregate: prefixAggregate
+});
+
+// src/commands/builtin/ssh/head/head.ts
+import {
+  AsyncLineIterator as AsyncLineIterator2,
+  IOResult as IOResult9,
+  Precision,
+  ProvisionResult as ProvisionResult2,
+  ResourceName as ResourceName9,
+  command as command9,
+  headerAggregate,
+  resolveSource as resolveSource3,
+  specOf as specOf9
+} from "@struktoai/mirage-core";
+var ENC4 = new TextEncoder();
+async function* headStream(source, lines, bytesMode) {
+  if (bytesMode !== null) {
+    let remaining = bytesMode;
+    for await (const chunk of source) {
+      if (chunk.byteLength <= remaining) {
+        yield chunk;
+        remaining -= chunk.byteLength;
+        if (remaining <= 0) return;
+      } else {
+        yield chunk.slice(0, remaining);
+        return;
+      }
+    }
+    return;
+  }
+  let count = 0;
+  const lineIter = new AsyncLineIterator2(source);
+  for await (const line of lineIter) {
+    const out = new Uint8Array(line.byteLength + 1);
+    out.set(line, 0);
+    out[line.byteLength] = 10;
+    yield out;
+    count += 1;
+    if (count >= lines) return;
+  }
+}
+async function* headMulti(accessor, paths, lines, bytesMode) {
+  for (let i = 0; i < paths.length; i++) {
+    const p = paths[i];
+    if (p === void 0) continue;
+    if (paths.length > 1) {
+      const prefix = i > 0 ? "\n" : "";
+      yield ENC4.encode(`${prefix}==> ${p.original} <==
+`);
+    }
+    const source = stream(accessor, p);
+    for await (const chunk of headStream(source, lines, bytesMode)) yield chunk;
+  }
+}
+async function headProvision(accessor, paths, texts, opts) {
+  const [first] = paths;
+  if (first === void 0) return new ProvisionResult2({ command: "head" });
+  try {
+    const s = await stat(accessor, first);
+    const fileSize = s.size ?? 0;
+    const nFlag = typeof opts.flags.n === "string" ? Number.parseInt(opts.flags.n, 10) : null;
+    const lines = nFlag !== null && Number.isFinite(nFlag) ? nFlag : 10;
+    const avgLine = 80;
+    const low = Math.min(lines * avgLine, fileSize);
+    return new ProvisionResult2({
+      command: `head ${first.original}`,
+      networkReadLow: low,
+      networkReadHigh: fileSize,
+      readOps: 1,
+      precision: Precision.RANGE
+    });
+  } catch {
+    return new ProvisionResult2({ command: "head" });
+  }
+}
+async function headCommand(accessor, paths, texts, opts) {
+  const nRaw = typeof opts.flags.n === "string" ? opts.flags.n : null;
+  const cRaw = typeof opts.flags.c === "string" ? opts.flags.c : null;
+  const lineCount = nRaw !== null ? Number.parseInt(nRaw, 10) : 10;
+  const byteCount = cRaw !== null ? Number.parseInt(cRaw, 10) : null;
+  if (paths.length > 0) {
+    for (const p of paths) await stat(accessor, p);
+    return [headMulti(accessor, paths, lineCount, byteCount), new IOResult9()];
+  }
+  try {
+    const source = resolveSource3(opts.stdin, "head: missing operand");
+    return [headStream(source, lineCount, byteCount), new IOResult9()];
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [null, new IOResult9({ exitCode: 1, stderr: ENC4.encode(`${msg}
+`) })];
+  }
+}
+var SSH_HEAD = command9({
+  name: "head",
+  resource: ResourceName9.SSH,
+  spec: specOf9("head"),
+  fn: headCommand,
+  provision: headProvision,
+  aggregate: headerAggregate
+});
+
+// src/commands/builtin/ssh/jq.ts
+import {
+  IOResult as IOResult10,
+  Precision as Precision2,
+  ProvisionResult as ProvisionResult3,
+  ResourceName as ResourceName10,
+  command as command10,
+  evalJsonlStream,
+  isJsonlPath,
+  isStreamableJsonlExpr,
+  jqEval,
+  materialize as materialize2,
+  parseJsonAuto,
+  parseJsonPath,
+  readStdinAsync,
+  specOf as specOf10
+} from "@struktoai/mirage-core";
+var ENC5 = new TextEncoder();
+async function jqProvision(accessor, paths, texts, _opts) {
+  const [first] = paths;
+  const [expr] = texts;
+  if (first === void 0 || expr === void 0) return new ProvisionResult3({ command: "jq" });
+  try {
+    const s = await stat(accessor, first);
+    const fileSize = s.size ?? 0;
+    if (isJsonlPath(first.original) && isStreamableJsonlExpr(expr)) {
+      return new ProvisionResult3({
+        command: `jq '${expr}' ${first.original}`,
+        networkReadLow: 0,
+        networkReadHigh: fileSize,
+        readOps: 1,
+        precision: Precision2.RANGE
+      });
+    }
+    return new ProvisionResult3({
+      command: `jq '${expr}' ${first.original}`,
+      networkReadLow: fileSize,
+      networkReadHigh: fileSize,
+      readOps: 1,
+      precision: Precision2.EXACT
+    });
+  } catch {
+    return new ProvisionResult3({ command: "jq" });
+  }
+}
+function formatResult(result, raw, compact) {
+  if (raw && typeof result === "string") return ENC5.encode(result + "\n");
+  const json = compact ? JSON.stringify(result) : JSON.stringify(result, null, 2);
+  return ENC5.encode(json + "\n");
+}
+function formatResults(result, raw, compact, spread) {
+  if (spread && Array.isArray(result)) {
+    const parts = [];
+    for (const item of result) parts.push(formatResult(item, raw, compact));
+    return concat(parts);
+  }
+  return formatResult(result, raw, compact);
+}
+function concat(chunks) {
+  let total = 0;
+  for (const c of chunks) total += c.byteLength;
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const c of chunks) {
+    out.set(c, offset);
+    offset += c.byteLength;
+  }
+  return out;
+}
+async function readFile2(accessor, p) {
+  return materialize2(stream(accessor, p));
+}
+async function jqCommand(accessor, paths, texts, opts) {
+  const expression = texts[0];
+  if (expression === void 0) {
+    return [
+      null,
+      new IOResult10({ exitCode: 1, stderr: ENC5.encode("jq: usage: jq EXPRESSION [path]\n") })
+    ];
+  }
+  const raw = opts.flags.r === true;
+  const compact = opts.flags.c === true;
+  const slurp = opts.flags.s === true;
+  if (paths.length > 0) {
+    const first = paths[0];
+    if (first === void 0) return [null, new IOResult10()];
+    if (isJsonlPath(first.original) && isStreamableJsonlExpr(expression)) {
+      return [evalJsonlStream(stream(accessor, first), expression), new IOResult10()];
+    }
+    const outputs = [];
+    for (const p of paths) {
+      const bytes2 = await readFile2(accessor, p);
+      let data2 = parseJsonPath(bytes2, p.original);
+      if (slurp) data2 = Array.isArray(data2) ? data2 : [data2];
+      const result2 = await jqEval(data2, expression.trim());
+      const spread2 = expression.includes("[]");
+      outputs.push(formatResults(result2, raw, compact, spread2));
+    }
+    const out = concat(outputs);
+    return [out, new IOResult10()];
+  }
+  const bytes = await readStdinAsync(opts.stdin);
+  if (bytes === null) return [null, new IOResult10()];
+  let data = parseJsonAuto(bytes);
+  if (slurp && !Array.isArray(data)) data = [data];
+  const result = await jqEval(data, expression.trim());
+  const spread = expression.includes("[]");
+  return [formatResults(result, raw, compact, spread), new IOResult10()];
+}
+var SSH_JQ = command10({
+  name: "jq",
+  resource: ResourceName10.SSH,
+  spec: specOf10("jq"),
+  fn: jqCommand,
+  provision: jqProvision
+});
+
+// src/commands/builtin/ssh/ls/ls.ts
+import {
+  FileType as FileType4,
+  IOResult as IOResult11,
+  PathSpec as PathSpec5,
+  ResourceName as ResourceName11,
+  command as command11,
+  specOf as specOf11
+} from "@struktoai/mirage-core";
+
+// src/core/ssh/readdir.ts
+async function readdir(accessor, p) {
+  const sftp = await accessor.sftp();
+  const virtual = p.pattern !== null ? p.directory.slice(p.prefix.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(enoent(virtual));
+        else rejectFn(err);
+        return;
+      }
+      resolveFn(entries);
+    });
+  });
+  const base = `/${virtual.replace(/^\/+|\/+$/g, "")}`;
+  const dirPrefix = base === "/" ? "/" : `${base}/`;
+  const mountPrefix = p.prefix;
+  const names = [];
+  for (const entry of list) {
+    if (entry.filename === "." || entry.filename === "..") continue;
+    names.push(`${mountPrefix}${dirPrefix}${entry.filename}`);
+  }
+  names.sort();
+  return names;
+}
+
+// src/commands/builtin/ssh/ls/ls.ts
+function humanSize2(n) {
+  const units = ["B", "K", "M", "G", "T"];
+  let v = n;
+  let i = 0;
+  while (v >= 1024 && i < units.length - 1) {
+    v /= 1024;
+    i += 1;
+  }
+  const s = v >= 10 || i === 0 ? Math.round(v).toString() : v.toFixed(1);
+  return `${s}${units[i] ?? ""}`;
+}
+function childSpec(entryPath, prefix) {
+  return new PathSpec5({
+    original: entryPath,
+    directory: entryPath,
+    resolved: false,
+    prefix
+  });
+}
+function formatEntry(s, long, human, classify) {
+  if (long) {
+    const size = human ? humanSize2(s.size ?? 0) : String(s.size ?? 0);
+    return `${s.type ?? "-"}	${size}	${s.modified ?? ""}	${s.name}`;
+  }
+  const suffix = classify && s.type === FileType4.DIRECTORY ? "/" : "";
+  return `${s.name}${suffix}`;
+}
+function sortStats(stats, sortBy, reverse) {
+  const sorted = [...stats].sort((a, b) => {
+    if (sortBy === "time") return (b.modified ?? "").localeCompare(a.modified ?? "");
+    if (sortBy === "size") return (b.size ?? 0) - (a.size ?? 0);
+    return a.name.localeCompare(b.name);
+  });
+  if (reverse) sorted.reverse();
+  return sorted;
+}
+async function listDir(accessor, dir, all) {
+  const entries = await readdir(accessor, dir);
+  const stats = await Promise.all(entries.map((p) => stat(accessor, childSpec(p, dir.prefix))));
+  return all ? stats : stats.filter((s) => !s.name.startsWith("."));
+}
+async function walkRecursive(accessor, dir, opts, header, lines, warnings) {
+  let stats;
+  try {
+    stats = await listDir(accessor, dir, opts.all);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    warnings.push(`ls: cannot access '${dir.original}': ${msg}`);
+    return;
+  }
+  if (header) lines.push(`${dir.stripPrefix}:`);
+  const sorted = sortStats(stats, opts.sortBy, opts.reverse);
+  for (const s of sorted) lines.push(formatEntry(s, opts.long, opts.human, opts.classify));
+  const subdirs = sorted.filter((s) => s.type === FileType4.DIRECTORY);
+  for (const sub of subdirs) {
+    lines.push("");
+    const base = dir.stripPrefix.replace(/\/+$/, "");
+    const childPath = `${base}/${sub.name}`;
+    await walkRecursive(accessor, childSpec(childPath, dir.prefix), opts, true, lines, warnings);
+  }
+}
+async function lsCommand(accessor, paths, _texts, opts) {
+  const targets = paths.length > 0 ? paths : [
+    new PathSpec5({
+      original: opts.cwd,
+      directory: opts.cwd,
+      resolved: false,
+      prefix: opts.mountPrefix ?? ""
+    })
+  ];
+  const long = opts.flags.args_l === true;
+  const all = opts.flags.a === true || opts.flags.A === true;
+  const human = opts.flags.h === true;
+  const reverse = opts.flags.r === true;
+  const classify = opts.flags.F === true;
+  const recursive = opts.flags.R === true;
+  const listDirItself = opts.flags.d === true;
+  const sortBy = opts.flags.t === true ? "time" : opts.flags.S === true ? "size" : "name";
+  const warnings = [];
+  const lines = [];
+  if (listDirItself) {
+    for (const p of targets) {
+      try {
+        const s = await stat(accessor, p);
+        lines.push(formatEntry(s, long, human, classify));
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        warnings.push(`ls: cannot access '${p.original}': ${msg}`);
+      }
+    }
+    const out2 = new TextEncoder().encode(lines.join("\n"));
+    const exitCode2 = warnings.length > 0 && lines.length === 0 ? 1 : 0;
+    if (warnings.length > 0) {
+      const stderr = new TextEncoder().encode(warnings.join("\n"));
+      return [out2, new IOResult11({ stderr, exitCode: exitCode2 })];
+    }
+    return [out2, new IOResult11({ exitCode: exitCode2 })];
+  }
+  if (recursive) {
+    const walkOpts = { all, long, human, classify, sortBy, reverse };
+    for (let i = 0; i < targets.length; i++) {
+      const p = targets[i];
+      if (p === void 0) continue;
+      if (i > 0) lines.push("");
+      await walkRecursive(accessor, p, walkOpts, true, lines, warnings);
+    }
+    const out2 = new TextEncoder().encode(lines.join("\n"));
+    const exitCode2 = warnings.length > 0 && lines.length === 0 ? 1 : 0;
+    if (warnings.length > 0) {
+      const stderr = new TextEncoder().encode(warnings.join("\n"));
+      return [out2, new IOResult11({ stderr, exitCode: exitCode2 })];
+    }
+    return [out2, new IOResult11({ exitCode: exitCode2 })];
+  }
+  for (const p of targets) {
+    let stats;
+    try {
+      stats = await listDir(accessor, p, all);
+    } catch (err) {
+      try {
+        stats = [await stat(accessor, p)];
+      } catch {
+        const msg = err instanceof Error ? err.message : String(err);
+        warnings.push(`ls: cannot access '${p.original}': ${msg}`);
+        continue;
+      }
+    }
+    for (const s of sortStats(stats, sortBy, reverse))
+      lines.push(formatEntry(s, long, human, classify));
+  }
+  const out = new TextEncoder().encode(lines.join("\n"));
+  const exitCode = warnings.length > 0 && lines.length === 0 ? 1 : 0;
+  if (warnings.length > 0) {
+    const stderr = new TextEncoder().encode(warnings.join("\n"));
+    return [out, new IOResult11({ stderr, exitCode })];
+  }
+  return [out, new IOResult11({ exitCode })];
+}
+var SSH_LS = command11({
+  name: "ls",
+  resource: ResourceName11.SSH,
+  spec: specOf11("ls"),
+  fn: lsCommand
+});
+
+// src/commands/builtin/ssh/mkdir.ts
+import {
+  IOResult as IOResult12,
+  ResourceName as ResourceName12,
+  command as command12,
+  specOf as specOf12
+} from "@struktoai/mirage-core";
+
+// src/core/ssh/mkdir.ts
+async function statRemote2(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 enoent(virtual);
+      throw err;
+    }
+    return;
+  }
+  const cleaned = virtual.replace(/^\/+|\/+$/g, "");
+  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 statRemote2(sftp, stepRemote);
+    if (existing?.isDirectory()) continue;
+    await mkdirOne(sftp, stepRemote, true);
+  }
+}
+
+// src/commands/builtin/ssh/mkdir.ts
+async function mkdirCommand(accessor, paths, _texts, opts) {
+  const parents = opts.flags.p === true;
+  const verbose = opts.flags.v === true;
+  if (paths.length === 0) {
+    return [
+      null,
+      new IOResult12({
+        exitCode: 1,
+        stderr: new TextEncoder().encode("mkdir: missing operand\n")
+      })
+    ];
+  }
+  const lines = [];
+  for (const p of paths) {
+    await mkdir(accessor, p, parents);
+    if (verbose) lines.push(`mkdir: created directory '${p.original}'`);
+  }
+  const out = lines.length > 0 ? new TextEncoder().encode(lines.join("\n") + "\n") : null;
+  return [out, new IOResult12()];
+}
+var SSH_MKDIR = command12({
+  name: "mkdir",
+  resource: ResourceName12.SSH,
+  spec: specOf12("mkdir"),
+  fn: mkdirCommand,
+  write: true
+});
+
+// src/commands/builtin/ssh/mv.ts
+import {
+  IOResult as IOResult13,
+  ResourceName as ResourceName13,
+  command as command13,
+  specOf as specOf13
+} from "@struktoai/mirage-core";
+
+// src/core/ssh/rename.ts
+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) => {
+    sftp.rename(remoteSrc, remoteDst, (err) => {
+      if (!err) {
+        resolveFn();
+        return;
+      }
+      if (isNoSuchFile(err)) rejectFn(enoent(srcVirtual));
+      else rejectFn(err);
+    });
+  });
+}
+
+// src/commands/builtin/ssh/mv.ts
+async function exists2(accessor, path) {
+  try {
+    await stat(accessor, path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function mvCommand(accessor, paths, _texts, opts) {
+  if (paths.length < 2) {
+    return [
+      null,
+      new IOResult13({
+        exitCode: 1,
+        stderr: new TextEncoder().encode("mv: missing operand\n")
+      })
+    ];
+  }
+  const noClobber = opts.flags.n === true;
+  const verbose = opts.flags.v === true;
+  const sources = paths.slice(0, -1);
+  const dst = paths[paths.length - 1];
+  if (dst === void 0) return [null, new IOResult13()];
+  const lines = [];
+  for (const src of sources) {
+    if (noClobber && await exists2(accessor, dst)) continue;
+    await rename(accessor, src, dst);
+    if (verbose) lines.push(`'${src.original}' -> '${dst.original}'`);
+  }
+  const out = lines.length > 0 ? new TextEncoder().encode(lines.join("\n") + "\n") : null;
+  return [out, new IOResult13()];
+}
+var SSH_MV = command13({
+  name: "mv",
+  resource: ResourceName13.SSH,
+  spec: specOf13("mv"),
+  fn: mvCommand,
+  write: true
+});
+
+// src/commands/builtin/ssh/realpath.ts
+import {
+  IOResult as IOResult14,
+  ResourceName as ResourceName14,
+  command as command14,
+  specOf as specOf14
+} from "@struktoai/mirage-core";
+function normalize(p, cwd) {
+  const path = p.startsWith("/") ? p : `${cwd.replace(/\/+$/, "")}/${p}`;
+  const parts = path.split("/").filter((s) => s !== "" && s !== ".");
+  const out = [];
+  for (const part of parts) {
+    if (part === "..") out.pop();
+    else out.push(part);
+  }
+  return "/" + out.join("/");
+}
+async function existsSsh(accessor, p) {
+  try {
+    await stat(accessor, p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function realpathCommand(accessor, paths, texts, opts) {
+  const requireExists = opts.flags.e === true;
+  const lines = [];
+  if (paths.length > 0) {
+    for (const p of paths) {
+      if (requireExists && !await existsSsh(accessor, p)) {
+        throw new Error(`realpath: '${p.original}': No such file or directory`);
+      }
+      lines.push(normalize(p.original, opts.cwd));
+    }
+  } else {
+    for (const t of texts) lines.push(normalize(t, opts.cwd));
+  }
+  const out = new TextEncoder().encode(lines.join("\n") + "\n");
+  return [out, new IOResult14()];
+}
+var SSH_REALPATH = command14({
+  name: "realpath",
+  resource: ResourceName14.SSH,
+  spec: specOf14("realpath"),
+  fn: realpathCommand
+});
+
+// src/commands/builtin/ssh/rg.ts
+import {
+  FileType as FileType5,
+  IOResult as IOResult15,
+  PathSpec as PathSpec6,
+  ResourceName as ResourceName15,
+  command as command15,
+  compilePattern as compilePattern2,
+  exitOnEmpty as exitOnEmpty2,
+  grepStream as grepStream2,
+  materialize as materialize3,
+  resolveSource as resolveSource4,
+  rgFolderFiletype,
+  rgFull,
+  specOf as specOf15
+} from "@struktoai/mirage-core";
+var ENC6 = new TextEncoder();
+function parseRgFlags(flags) {
+  const toInt = (v) => typeof v === "string" ? Number.parseInt(v, 10) : null;
+  const a = toInt(flags.A);
+  const b = toInt(flags.B);
+  const c = toInt(flags.C);
+  return {
+    ignoreCase: flags.i === true,
+    invert: flags.v === true,
+    lineNumbers: flags.n === true,
+    countOnly: flags.c === true,
+    filesOnly: flags.args_l === true,
+    wholeWord: flags.w === true,
+    fixedString: flags.F === true,
+    onlyMatching: flags.o === true,
+    maxCount: toInt(flags.m),
+    afterContext: a ?? c ?? 0,
+    beforeContext: b ?? c ?? 0,
+    fileType: typeof flags.type === "string" ? flags.type : null,
+    globPattern: typeof flags.glob === "string" ? flags.glob : null,
+    hidden: flags.hidden === true
+  };
+}
+async function rgCommand(accessor, paths, texts, opts) {
+  const [exprText] = texts;
+  if (exprText === void 0) {
+    return [
+      null,
+      new IOResult15({ exitCode: 2, stderr: ENC6.encode("rg: usage: rg [flags] pattern [path]\n") })
+    ];
+  }
+  const flags = parseRgFlags(opts.flags);
+  const [first] = paths;
+  if (first === void 0) {
+    const source = resolveSource4(opts.stdin, "rg: usage: rg [flags] pattern [path]");
+    const pat = compilePattern2(exprText, flags.ignoreCase, flags.fixedString, flags.wholeWord);
+    const stream2 = grepStream2(source, pat, {
+      invert: flags.invert,
+      lineNumbers: flags.lineNumbers,
+      countOnly: flags.countOnly,
+      onlyMatching: flags.onlyMatching,
+      maxCount: flags.maxCount,
+      afterContext: flags.afterContext,
+      beforeContext: flags.beforeContext
+    });
+    const io = new IOResult15();
+    return [exitOnEmpty2(stream2, io), io];
+  }
+  let isDir = false;
+  try {
+    const s = await stat(accessor, first);
+    isDir = s.type === FileType5.DIRECTORY;
+  } catch {
+    try {
+      await readdir(accessor, first);
+      isDir = true;
+    } catch {
+    }
+  }
+  if (isDir && opts.filetypeFns !== null && Object.keys(opts.filetypeFns).length > 0) {
+    const readdirFn = async (p) => {
+      const keys = await find(accessor, makeSpec(p, first), { type: null });
+      return keys;
+    };
+    const statFn = (p) => stat(accessor, makeSpec(p, first));
+    const readBytesFn = (p) => materialize3(stream(accessor, makeSpec(p, first)));
+    const warnings = [];
+    const results = await rgFolderFiletype(
+      readdirFn,
+      statFn,
+      readBytesFn,
+      first.original,
+      exprText,
+      {},
+      {
+        ignoreCase: flags.ignoreCase,
+        invert: flags.invert,
+        lineNumbers: flags.lineNumbers,
+        countOnly: flags.countOnly,
+        filesOnly: flags.filesOnly,
+        onlyMatching: flags.onlyMatching,
+        maxCount: flags.maxCount,
+        fixedString: flags.fixedString,
+        wholeWord: flags.wholeWord,
+        fileType: flags.fileType,
+        globPattern: flags.globPattern,
+        hidden: flags.hidden
+      },
+      warnings
+    );
+    const stderr = warnings.length > 0 ? ENC6.encode(warnings.join("\n")) : void 0;
+    if (results.length === 0) {
+      const io2 = new IOResult15({ exitCode: 1, ...stderr !== void 0 ? { stderr } : {} });
+      return [new Uint8Array(0), io2];
+    }
+    const out = ENC6.encode(results.join("\n"));
+    const io = new IOResult15(stderr !== void 0 ? { stderr } : {});
+    return [out, io];
+  }
+  const needsFull = flags.filesOnly || flags.beforeContext > 0 || flags.afterContext > 0 || flags.fileType !== null || flags.globPattern !== null;
+  if (needsFull) {
+    const readdirFn = async (p) => {
+      const keys = await find(accessor, makeSpec(p, first), { type: null });
+      return keys;
+    };
+    const statFn = (p) => stat(accessor, makeSpec(p, first));
+    const readBytesFn = (p) => materialize3(stream(accessor, makeSpec(p, first)));
+    const warnings = [];
+    const results = await rgFull(
+      readdirFn,
+      statFn,
+      readBytesFn,
+      first.original,
+      exprText,
+      {
+        ignoreCase: flags.ignoreCase,
+        invert: flags.invert,
+        lineNumbers: flags.lineNumbers,
+        countOnly: flags.countOnly,
+        filesOnly: flags.filesOnly,
+        fixedString: flags.fixedString,
+        onlyMatching: flags.onlyMatching,
+        maxCount: flags.maxCount,
+        wholeWord: flags.wholeWord,
+        contextBefore: flags.beforeContext,
+        contextAfter: flags.afterContext,
+        fileType: flags.fileType,
+        globPattern: flags.globPattern,
+        hidden: flags.hidden
+      },
+      warnings
+    );
+    const stderr = warnings.length > 0 ? ENC6.encode(warnings.join("\n")) : void 0;
+    if (results.length === 0) {
+      const io2 = new IOResult15({ exitCode: 1, ...stderr !== void 0 ? { stderr } : {} });
+      return [new Uint8Array(0), io2];
+    }
+    const out = ENC6.encode(results.join("\n"));
+    const io = new IOResult15(stderr !== void 0 ? { stderr } : {});
+    return [out, io];
+  }
+  return grepImpl("rg", accessor, paths, texts, opts);
+}
+function makeSpec(path, template) {
+  return new PathSpec6({
+    original: path,
+    directory: path,
+    resolved: false,
+    prefix: template.prefix
+  });
+}
+var SSH_RG = command15({
+  name: "rg",
+  resource: ResourceName15.SSH,
+  spec: specOf15("rg"),
+  fn: rgCommand
+});
+
+// src/commands/builtin/ssh/rm.ts
+import {
+  FileType as FileType6,
+  IOResult as IOResult16,
+  ResourceName as ResourceName16,
+  command as command16,
+  specOf as specOf16
+} from "@struktoai/mirage-core";
+
+// src/core/ssh/rmdir.ts
+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(enoent(virtual));
+      else rejectFn(err);
+    });
+  });
+}
+
+// src/core/ssh/unlink.ts
+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(enoent(virtual));
+      else rejectFn(err);
+    });
+  });
+}
+
+// src/core/ssh/rm.ts
+async function statRemote3(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 statRemote3(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 enoent(virtual);
+    throw err;
+  }
+}
+
+// src/commands/builtin/ssh/rm.ts
+async function rmCommand(accessor, paths, _texts, opts) {
+  if (paths.length === 0) {
+    return [
+      null,
+      new IOResult16({
+        exitCode: 1,
+        stderr: new TextEncoder().encode("rm: missing operand\n")
+      })
+    ];
+  }
+  const recursive = opts.flags.r === true || opts.flags.R === true;
+  const force = opts.flags.f === true;
+  const verbose = opts.flags.v === true;
+  const lines = [];
+  for (const p of paths) {
+    let isDir = false;
+    try {
+      const st = await stat(accessor, p);
+      isDir = st.type === FileType6.DIRECTORY;
+    } catch {
+      if (force) continue;
+      throw new Error(`rm: cannot remove '${p.original}': No such file or directory`);
+    }
+    if (isDir) {
+      if (recursive) {
+        await rmR(accessor, p);
+      } else {
+        await rmdir(accessor, p);
+      }
+    } else {
+      await unlink(accessor, p);
+    }
+    if (verbose) lines.push(`removed '${p.original}'`);
+  }
+  const out = lines.length > 0 ? new TextEncoder().encode(lines.join("\n")) : null;
+  return [out, new IOResult16()];
+}
+var SSH_RM = command16({
+  name: "rm",
+  resource: ResourceName16.SSH,
+  spec: specOf16("rm"),
+  fn: rmCommand,
+  write: true
+});
+
+// src/commands/builtin/ssh/stat/stat.ts
+import {
+  FileType as FileType7,
+  IOResult as IOResult17,
+  ProvisionResult as ProvisionResult4,
+  ResourceName as ResourceName17,
+  command as command17,
+  specOf as specOf17
+} from "@struktoai/mirage-core";
+var TYPE_LABELS = {
+  [FileType7.DIRECTORY]: "directory",
+  [FileType7.TEXT]: "regular file",
+  [FileType7.BINARY]: "regular file",
+  [FileType7.JSON]: "regular file",
+  [FileType7.CSV]: "regular file"
+};
+function formatStat(fmt, s) {
+  return fmt.replace(/%(.)/g, (_, spec) => {
+    if (spec === "n") return s.name;
+    if (spec === "s") return String(s.size ?? 0);
+    if (spec === "F") return s.type ? TYPE_LABELS[s.type] ?? "regular file" : "regular file";
+    if (spec === "y") return s.modified ?? "";
+    return "?";
+  });
+}
+function statProvision(accessor, paths, _texts, _opts) {
+  const [first] = paths;
+  return new ProvisionResult4({
+    command: first !== void 0 ? `stat ${first.original}` : "stat"
+  });
+}
+async function statCommand(accessor, paths, texts, opts) {
+  if (paths.length === 0) {
+    return [
+      null,
+      new IOResult17({
+        exitCode: 1,
+        stderr: new TextEncoder().encode("stat: missing operand\n")
+      })
+    ];
+  }
+  const fmt = typeof opts.flags.c === "string" ? opts.flags.c : typeof opts.flags.f === "string" ? opts.flags.f : null;
+  const lines = [];
+  for (const p of paths) {
+    const s = await stat(accessor, p);
+    if (fmt !== null) {
+      lines.push(formatStat(fmt, s));
+    } else {
+      const sizeStr = s.size === null ? "None" : String(s.size);
+      const modStr = s.modified ?? "None";
+      const typeStr = s.type ?? "None";
+      lines.push(`name=${s.name} size=${sizeStr} modified=${modStr} type=${typeStr}`);
+    }
+  }
+  const out = new TextEncoder().encode(lines.join("\n"));
+  return [out, new IOResult17()];
+}
+var SSH_STAT = command17({
+  name: "stat",
+  resource: ResourceName17.SSH,
+  spec: specOf17("stat"),
+  fn: statCommand,
+  provision: statProvision
+});
+
+// src/commands/builtin/ssh/tail/tail.ts
+import {
+  IOResult as IOResult18,
+  ResourceName as ResourceName18,
+  command as command18,
+  countNewlines,
+  headerAggregate as headerAggregate2,
+  materialize as materialize4,
+  parseN,
+  readStdinAsync as readStdinAsync2,
+  specOf as specOf18,
+  tailBytes
+} from "@struktoai/mirage-core";
+var ENC7 = new TextEncoder();
+async function readFile3(accessor, p) {
+  return materialize4(stream(accessor, p));
+}
+async function tailCommand(accessor, paths, texts, opts) {
+  const nRaw = typeof opts.flags.n === "string" ? opts.flags.n : null;
+  const cRaw = typeof opts.flags.c === "string" ? opts.flags.c : null;
+  const qFlag = opts.flags.q === true;
+  const vFlag = opts.flags.v === true;
+  const [lines, plusMode] = parseN(nRaw);
+  const bytesMode = cRaw !== null ? Number.parseInt(cRaw, 10) : null;
+  if (paths.length > 0) {
+    const chunks = [];
+    const cache = [];
+    const showHeaders = (vFlag || paths.length > 1) && !qFlag;
+    for (let i = 0; i < paths.length; i++) {
+      const p = paths[i];
+      if (p === void 0) continue;
+      const raw2 = await readFile3(accessor, p);
+      if (showHeaders) {
+        const header = i > 0 ? `
+==> ${p.original} <==
+` : `==> ${p.original} <==
+`;
+        chunks.push(ENC7.encode(header));
+      }
+      if (bytesMode !== null) {
+        chunks.push(bytesMode === 0 ? new Uint8Array(0) : raw2.slice(-bytesMode));
+        if (bytesMode >= raw2.byteLength) cache.push(p.original);
+      } else {
+        chunks.push(tailBytes(raw2, lines, null, plusMode));
+        if (!plusMode && lines >= countNewlines(raw2)) cache.push(p.original);
+      }
+    }
+    const out = concat2(chunks);
+    return [out, new IOResult18({ cache })];
+  }
+  const raw = await readStdinAsync2(opts.stdin);
+  if (raw === null) {
+    return [null, new IOResult18({ exitCode: 1, stderr: ENC7.encode("tail: missing operand\n") })];
+  }
+  if (bytesMode !== null) {
+    const out = bytesMode === 0 ? new Uint8Array(0) : raw.slice(-bytesMode);
+    return [out, new IOResult18()];
+  }
+  return [tailBytes(raw, lines, null, plusMode), new IOResult18()];
+}
+function concat2(chunks) {
+  let total = 0;
+  for (const c of chunks) total += c.byteLength;
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const c of chunks) {
+    out.set(c, offset);
+    offset += c.byteLength;
+  }
+  return out;
+}
+var SSH_TAIL = command18({
+  name: "tail",
+  resource: ResourceName18.SSH,
+  spec: specOf18("tail"),
+  fn: tailCommand,
+  aggregate: headerAggregate2
+});
+
+// src/commands/builtin/ssh/touch.ts
+import {
+  IOResult as IOResult19,
+  ResourceName as ResourceName19,
+  command as command19,
+  specOf as specOf19
+} from "@struktoai/mirage-core";
+
+// src/core/ssh/exists.ts
+async function exists3(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/commands/builtin/ssh/touch.ts
+var ENC8 = new TextEncoder();
+async function touchCommand(accessor, paths, texts, opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult19({ exitCode: 1, stderr: ENC8.encode("touch: missing operand\n") })];
+  }
+  const createOnly = opts.flags.c === true;
+  for (const p of paths) {
+    if (createOnly) continue;
+    if (!await exists3(accessor, p)) {
+      await writeBytes(accessor, p, new Uint8Array(0));
+    }
+  }
+  return [null, new IOResult19()];
+}
+var SSH_TOUCH = command19({
+  name: "touch",
+  resource: ResourceName19.SSH,
+  spec: specOf19("touch"),
+  fn: touchCommand,
+  write: true
+});
+
+// src/commands/builtin/ssh/tree.ts
+import {
+  FileType as FileType8,
+  IOResult as IOResult20,
+  PathSpec as PathSpec7,
+  ResourceName as ResourceName20,
+  command as command20,
+  specOf as specOf20
+} from "@struktoai/mirage-core";
+function fnmatch2(name, pattern) {
+  let re = "^";
+  for (const ch of pattern) {
+    if (ch === "*") re += ".*";
+    else if (ch === "?") re += ".";
+    else if (/[.+^${}()|[\]\\]/.test(ch)) re += "\\" + ch;
+    else re += ch;
+  }
+  re += "$";
+  return new RegExp(re).test(name);
+}
+async function walkTree(accessor, path, prefix, lines, treeOpts, depth) {
+  let entries;
+  try {
+    entries = await readdir(accessor, path);
+  } catch {
+    return;
+  }
+  entries.sort();
+  const filtered = [];
+  for (const childPath of entries) {
+    const name = childPath.slice(childPath.lastIndexOf("/") + 1);
+    if (!treeOpts.showHidden && name.startsWith(".")) continue;
+    if (treeOpts.ignorePattern !== null && fnmatch2(name, treeOpts.ignorePattern)) continue;
+    const sub = new PathSpec7({
+      original: childPath,
+      directory: childPath,
+      resolved: false,
+      prefix: path.prefix
+    });
+    let isDir;
+    try {
+      const s = await stat(accessor, sub);
+      isDir = s.type === FileType8.DIRECTORY;
+    } catch {
+      continue;
+    }
+    if (treeOpts.dirsOnly && !isDir) continue;
+    if (treeOpts.matchPattern !== null && !isDir && !fnmatch2(name, treeOpts.matchPattern)) continue;
+    filtered.push({ spec: sub, name, isDir });
+  }
+  for (let i = 0; i < filtered.length; i++) {
+    const entry = filtered[i];
+    if (entry === void 0) continue;
+    const last = i === filtered.length - 1;
+    const connector = last ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    lines.push(`${prefix}${connector}${entry.name}`);
+    if (entry.isDir) {
+      if (treeOpts.maxDepth !== null && depth >= treeOpts.maxDepth) continue;
+      const nextPrefix = prefix + (last ? "    " : "\u2502   ");
+      await walkTree(accessor, entry.spec, nextPrefix, lines, treeOpts, depth + 1);
+    }
+  }
+}
+async function treeCommand(accessor, paths, texts, opts) {
+  const targets = paths.length > 0 ? paths : [
+    new PathSpec7({
+      original: opts.cwd,
+      directory: opts.cwd,
+      resolved: false,
+      prefix: opts.mountPrefix ?? ""
+    })
+  ];
+  const depthRaw = typeof opts.flags.L === "string" ? opts.flags.L : null;
+  const ignoreRaw = typeof opts.flags.args_I === "string" ? opts.flags.args_I : null;
+  const matchRaw = typeof opts.flags.P === "string" ? opts.flags.P : null;
+  const treeOpts = {
+    showHidden: opts.flags.a === true,
+    maxDepth: depthRaw === null ? null : Number.parseInt(depthRaw, 10),
+    ignorePattern: ignoreRaw,
+    dirsOnly: opts.flags.d === true,
+    matchPattern: matchRaw
+  };
+  const lines = [];
+  for (const p of targets) {
+    await walkTree(accessor, p, "", lines, treeOpts, 0);
+  }
+  const out = new TextEncoder().encode(lines.join("\n"));
+  return [out, new IOResult20()];
+}
+var SSH_TREE = command20({
+  name: "tree",
+  resource: ResourceName20.SSH,
+  spec: specOf20("tree"),
+  fn: treeCommand
+});
+
+// src/commands/builtin/ssh/wc/wc.ts
+import {
+  IOResult as IOResult21,
+  ResourceName as ResourceName21,
+  command as command21,
+  materialize as materialize5,
+  resolveSource as resolveSource5,
+  specOf as specOf21,
+  wcAggregate
+} from "@struktoai/mirage-core";
+var ENC9 = new TextEncoder();
+var DEC2 = new TextDecoder("utf-8", { fatal: false });
+async function* wcLinesStream(source) {
+  let count = 0;
+  for await (const chunk of source) {
+    for (let i = 0; i < chunk.byteLength; i++) if (chunk[i] === 10) count += 1;
+  }
+  yield ENC9.encode(String(count));
+}
+async function readStream(accessor, p) {
+  return materialize5(stream(accessor, p));
+}
+async function wcCommand(accessor, paths, texts, opts) {
+  const f = opts.flags;
+  const lFlag = f.args_l === true;
+  const wFlag = f.w === true;
+  const cFlag = f.c === true;
+  const mFlag = f.m === true;
+  const LFlag = f.L === true;
+  if (paths.length > 0) {
+    const outputs = [];
+    let totalLines = 0;
+    let totalWords = 0;
+    let totalBytes = 0;
+    for (const p of paths) {
+      const data = await readStream(accessor, p);
+      const text2 = DEC2.decode(data);
+      const lineCount = countChar(text2, "\n");
+      const wordCount = text2.split(/\s+/).filter((s) => s !== "").length;
+      const byteCount = data.byteLength;
+      if (LFlag) {
+        const maxLen = text2.split(/\r?\n/).reduce((m, l) => Math.max(m, l.length), 0);
+        outputs.push(`${String(maxLen)}	${p.original}`);
+      } else if (lFlag) {
+        outputs.push(`${String(lineCount)}	${p.original}`);
+        totalLines += lineCount;
+      } else if (wFlag) {
+        outputs.push(`${String(wordCount)}	${p.original}`);
+        totalWords += wordCount;
+      } else if (cFlag) {
+        outputs.push(`${String(byteCount)}	${p.original}`);
+        totalBytes += byteCount;
+      } else if (mFlag) {
+        const charCount = text2.length;
+        outputs.push(`${String(charCount)}	${p.original}`);
+        totalBytes += charCount;
+      } else {
+        outputs.push(
+          `${String(lineCount)}	${String(wordCount)}	${String(byteCount)}	${p.original}`
+        );
+        totalLines += lineCount;
+        totalWords += wordCount;
+        totalBytes += byteCount;
+      }
+    }
+    if (paths.length > 1) {
+      if (lFlag) outputs.push(`${String(totalLines)}	total`);
+      else if (wFlag) outputs.push(`${String(totalWords)}	total`);
+      else if (cFlag) outputs.push(`${String(totalBytes)}	total`);
+      else if (mFlag) outputs.push(`${String(totalBytes)}	total`);
+      else
+        outputs.push(`${String(totalLines)}	${String(totalWords)}	${String(totalBytes)}	total`);
+    }
+    const out = ENC9.encode(outputs.join("\n"));
+    return [out, new IOResult21()];
+  }
+  let source;
+  try {
+    source = resolveSource5(opts.stdin, "wc: missing operand");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return [null, new IOResult21({ exitCode: 1, stderr: ENC9.encode(`${msg}
+`) })];
+  }
+  if (lFlag) return [wcLinesStream(source), new IOResult21()];
+  const raw = await materialize5(source);
+  const text = DEC2.decode(raw);
+  const lc = countChar(text, "\n");
+  const wcVal = text.split(/\s+/).filter((s) => s !== "").length;
+  const bc = raw.byteLength;
+  const cc = text.length;
+  if (LFlag) {
+    const maxLen = text.split(/\r?\n/).reduce((m, l) => Math.max(m, l.length), 0);
+    return [ENC9.encode(String(maxLen)), new IOResult21()];
+  }
+  if (wFlag) return [ENC9.encode(String(wcVal)), new IOResult21()];
+  if (mFlag) return [ENC9.encode(String(cc)), new IOResult21()];
+  if (cFlag) return [ENC9.encode(String(bc)), new IOResult21()];
+  return [ENC9.encode(`${String(lc)}	${String(wcVal)}	${String(bc)}`), new IOResult21()];
+}
+function countChar(text, ch) {
+  let n = 0;
+  for (const c of text) if (c === ch) n += 1;
+  return n;
+}
+var SSH_WC = command21({
+  name: "wc",
+  resource: ResourceName21.SSH,
+  spec: specOf21("wc"),
+  fn: wcCommand,
+  aggregate: wcAggregate
+});
+
+// src/commands/builtin/ssh/index.ts
+var SSH_COMMANDS = [
+  ...SSH_LS,
+  ...SSH_TREE,
+  ...SSH_CAT,
+  ...SSH_HEAD,
+  ...SSH_TAIL,
+  ...SSH_WC,
+  ...SSH_FIND,
+  ...SSH_GREP,
+  ...SSH_RG,
+  ...SSH_STAT,
+  ...SSH_JQ,
+  ...SSH_DU,
+  ...SSH_FILE,
+  ...SSH_BASENAME,
+  ...SSH_DIRNAME,
+  ...SSH_REALPATH,
+  ...SSH_CP,
+  ...SSH_MV,
+  ...SSH_RM,
+  ...SSH_MKDIR,
+  ...SSH_TOUCH
+];
+
+// src/core/ssh/append.ts
+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();
+    });
+  });
+}
+
+// src/core/ssh/create.ts
+function create(accessor, path) {
+  return writeBytes(accessor, path, new Uint8Array());
+}
+
+// src/core/ssh/glob.ts
+import { PathSpec as PathSpec8 } from "@struktoai/mirage-core";
+function fnmatch3(name, pattern) {
+  let re = "^";
+  for (const ch of pattern) {
+    if (ch === "*") re += ".*";
+    else if (ch === "?") re += ".";
+    else if (/[.+^${}()|[\]\\]/.test(ch)) re += "\\" + ch;
+    else re += ch;
+  }
+  re += "$";
+  return new RegExp(re).test(name);
+}
+function basenameOf(p) {
+  return p.slice(p.lastIndexOf("/") + 1);
+}
+async function resolveGlob(accessor, paths) {
+  const result = [];
+  for (const p of paths) {
+    if (p.resolved) {
+      result.push(p);
+    } else if (p.pattern !== null && p.pattern !== "") {
+      const dirSpec = new PathSpec8({
+        original: p.directory,
+        directory: p.directory,
+        resolved: true,
+        prefix: p.prefix
+      });
+      const entries = await readdir(accessor, dirSpec);
+      const matched = [];
+      for (const e of entries) {
+        if (fnmatch3(basenameOf(e), p.pattern)) {
+          matched.push(
+            new PathSpec8({
+              original: e,
+              directory: p.directory,
+              resolved: true,
+              prefix: p.prefix
+            })
+          );
+        }
+      }
+      if (matched.length > SCOPE_ERROR) matched.length = SCOPE_ERROR;
+      result.push(...matched);
+    } else {
+      result.push(p);
+    }
+  }
+  return result;
+}
+
+// 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/ops/ssh/append.ts
+import { ResourceName as ResourceName22 } from "@struktoai/mirage-core";
+var appendOp = {
+  name: "append",
+  resource: ResourceName22.SSH,
+  filetype: null,
+  write: true,
+  fn: (accessor, path, args) => {
+    const data = args[0];
+    if (!(data instanceof Uint8Array)) {
+      throw new TypeError("append op requires a Uint8Array as the first arg");
+    }
+    return appendBytes(accessor, path, data);
+  }
+};
+
+// src/ops/ssh/create.ts
+import { ResourceName as ResourceName23 } from "@struktoai/mirage-core";
+var createOp = {
+  name: "create",
+  resource: ResourceName23.SSH,
+  filetype: null,
+  write: true,
+  fn: (accessor, path) => {
+    return create(accessor, path);
+  }
+};
+
+// src/ops/ssh/mkdir.ts
+import { ResourceName as ResourceName24 } from "@struktoai/mirage-core";
+var mkdirOp = {
+  name: "mkdir",
+  resource: ResourceName24.SSH,
+  filetype: null,
+  write: true,
+  fn: (accessor, path) => {
+    return mkdir(accessor, path, true);
+  }
+};
+
+// src/ops/ssh/read.ts
+import { ResourceName as ResourceName25 } from "@struktoai/mirage-core";
+var readOp = {
+  name: "read",
+  resource: ResourceName25.SSH,
+  filetype: null,
+  write: false,
+  fn: (accessor, path) => {
+    return read(accessor, path);
+  }
+};
+
+// src/ops/ssh/readdir.ts
+import { ResourceName as ResourceName26 } from "@struktoai/mirage-core";
+var readdirOp = {
+  name: "readdir",
+  resource: ResourceName26.SSH,
+  filetype: null,
+  write: false,
+  fn: (accessor, path) => {
+    return readdir(accessor, path);
+  }
+};
+
+// src/ops/ssh/rename.ts
+import { ResourceName as ResourceName27 } from "@struktoai/mirage-core";
+var renameOp = {
+  name: "rename",
+  resource: ResourceName27.SSH,
+  filetype: null,
+  write: true,
+  fn: (accessor, path, args) => {
+    const dst = args[0];
+    if (dst === void 0 || dst === null || typeof dst !== "object" || !("original" in dst)) {
+      throw new TypeError("rename op requires a PathSpec destination as the first arg");
+    }
+    return rename(accessor, path, dst);
+  }
+};
+
+// src/ops/ssh/rmdir.ts
+import { ResourceName as ResourceName28 } from "@struktoai/mirage-core";
+var rmdirOp = {
+  name: "rmdir",
+  resource: ResourceName28.SSH,
+  filetype: null,
+  write: true,
+  fn: (accessor, path) => {
+    return rmdir(accessor, path);
+  }
+};
+
+// src/ops/ssh/stat.ts
+import { ResourceName as ResourceName29 } from "@struktoai/mirage-core";
+var statOp = {
+  name: "stat",
+  resource: ResourceName29.SSH,
+  filetype: null,
+  write: false,
+  fn: (accessor, path) => {
+    return stat(accessor, path);
+  }
+};
+
+// src/ops/ssh/truncate.ts
+import { ResourceName as ResourceName30 } from "@struktoai/mirage-core";
+var truncateOp = {
+  name: "truncate",
+  resource: ResourceName30.SSH,
+  filetype: null,
+  write: true,
+  fn: (accessor, path, args) => {
+    const length = args[0];
+    if (typeof length !== "number") {
+      throw new TypeError("truncate op requires a number length as the first arg");
+    }
+    return truncate(accessor, path, length);
+  }
+};
+
+// src/ops/ssh/unlink.ts
+import { ResourceName as ResourceName31 } from "@struktoai/mirage-core";
+var unlinkOp = {
+  name: "unlink",
+  resource: ResourceName31.SSH,
+  filetype: null,
+  write: true,
+  fn: (accessor, path) => {
+    return unlink(accessor, path);
+  }
+};
+
+// src/ops/ssh/write.ts
+import { extractWriteData } from "@struktoai/mirage-core";
+import { ResourceName as ResourceName32 } from "@struktoai/mirage-core";
+var writeOp = {
+  name: "write",
+  resource: ResourceName32.SSH,
+  filetype: null,
+  write: true,
+  fn: (accessor, path, args) => {
+    const data = extractWriteData(args);
+    return writeBytes(accessor, path, data);
+  }
+};
+
+// src/ops/ssh/index.ts
+var SSH_OPS = [
+  appendOp,
+  createOp,
+  mkdirOp,
+  readOp,
+  readdirOp,
+  renameOp,
+  rmdirOp,
+  statOp,
+  truncateOp,
+  unlinkOp,
+  writeOp
+];
+
+// 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 SSHResource = class {
+  kind = ResourceName33.SSH;
+  isRemote = true;
+  indexTtl = 60;
+  prompt = SSH_PROMPT;
+  config;
+  accessor;
+  index;
+  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: exists3,
+    find_flat: find,
+    append: appendBytes
+  };
+  constructor(config) {
+    this.config = config;
+    this.accessor = new SSHAccessor(config);
+    this.index = new RAMIndexCacheStore({ ttl: this.indexTtl });
+  }
+  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 exists3(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);
+  }
+  async fingerprint(p) {
+    try {
+      const remote = await stat(this.accessor, p);
+      const mtime = remote.modified ?? "";
+      const size = String(remote.size ?? 0);
+      return `${mtime}:${size}`;
+    } catch (err) {
+      if (err.code === "ENOENT") return null;
+      throw err;
+    }
+  }
+  glob(paths, prefix = "") {
+    const effective = prefix ? paths.map(
+      (p) => p.prefix ? p : new PathSpec9({
+        original: p.original,
+        directory: p.directory,
+        ...p.pattern !== null ? { pattern: p.pattern } : {},
+        resolved: p.resolved,
+        prefix
+      })
+    ) : paths;
+    return resolveGlob(this.accessor, effective);
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async getState() {
+    return {
+      type: this.kind,
+      needsOverride: false,
+      redactedFields: ["password", "passphrase"],
+      config: redactSshConfig(this.config)
+    };
+  }
+  loadState(_state) {
+    return Promise.resolve();
+  }
+};
+
+export {
+  SSHAccessor,
+  SSH_COMMANDS,
+  SSH_OPS,
+  SSH_PROMPT,
+  SSHResource
+};
+//# sourceMappingURL=chunk-M42JTWPR.js.map