@struktoai/mirage-node 0.0.1 → 0.0.2

package/dist/chunk-5HCVKTP3.js

@@ -0,0 +1,2086 @@
+import {
+  redactSshConfig
+} from "./chunk-UGK4TAVK.js";
+import {
+  SCOPE_ERROR
+} from "./chunk-U6QSXTUS.js";
+
+// src/resource/ssh/ssh.ts
+import {
+  BaseResource,
+  PathSpec as PathSpec2,
+  ResourceName as ResourceName75
+} 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 { ResourceName, command, specOf, basenameFn } from "@struktoai/mirage-core";
+var SSH_BASENAME = command({
+  name: "basename",
+  resource: ResourceName.SSH,
+  spec: specOf("basename"),
+  fn: basenameFn
+});
+
+// src/commands/builtin/ssh/cat/cat.ts
+import {
+  ResourceName as ResourceName2,
+  catGeneric,
+  catProvisionGeneric,
+  command as command2,
+  concatAggregate,
+  specOf as specOf2
+} from "@struktoai/mirage-core";
+
+// src/core/ssh/glob.ts
+import { PathSpec } from "@struktoai/mirage-core";
+
+// src/core/ssh/utils.ts
+import { lstripSlash, rstripSlash } from "@struktoai/mirage-core";
+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 = 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/readdir.ts
+import { enoent, stripSlash } from "@struktoai/mirage-core";
+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(p));
+        else rejectFn(err);
+        return;
+      }
+      resolveFn(entries);
+    });
+  });
+  const base = `/${stripSlash(virtual)}`;
+  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/core/ssh/glob.ts
+import { fnmatch } from "@struktoai/mirage-core";
+import { gnuBasename } from "@struktoai/mirage-core";
+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 PathSpec({
+        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 (fnmatch(gnuBasename(e), p.pattern)) {
+          matched.push(
+            new PathSpec({
+              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/stream.ts
+import { enoent as enoent2 } from "@struktoai/mirage-core";
+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 enoent2(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 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 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/commands/builtin/ssh/cat/cat.ts
+async function catCommand(accessor, paths, texts, opts) {
+  const resolved = paths.length > 0 ? await resolveGlob(accessor, paths) : [];
+  return catGeneric(
+    resolved,
+    texts,
+    opts,
+    (p) => stat(accessor, p),
+    (p) => stream(accessor, p)
+  );
+}
+var SSH_CAT = command2({
+  name: "cat",
+  resource: ResourceName2.SSH,
+  spec: specOf2("cat"),
+  fn: catCommand,
+  provision: (accessor, paths) => catProvisionGeneric(paths, (p) => stat(accessor, p)),
+  aggregate: concatAggregate
+});
+
+// src/commands/builtin/ssh/cp.ts
+import {
+  IOResult,
+  ResourceName as ResourceName3,
+  command as command3,
+  cpGeneric,
+  specOf as specOf3
+} from "@struktoai/mirage-core";
+
+// src/core/ssh/read.ts
+import { enoent as enoent4 } from "@struktoai/mirage-core";
+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(enoent4(p));
+        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
+import { norm } from "@struktoai/mirage-core";
+import { buildTree, keep } 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 (!isDir) {
+    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 statRemote(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 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 (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 = norm(stripPrefix(p));
+  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 (virtual !== "/" && (options.maxDepth == null || options.maxDepth >= 0)) {
+    const st = await statRemote(accessor, joinRoot(accessor.config.root ?? "/", virtual));
+    if (st !== null && keep(
+      {
+        key: virtual,
+        name: virtual.slice(virtual.lastIndexOf("/") + 1),
+        kind: st.isDir ? "d" : "f",
+        depth: 0,
+        isEmpty: st.isDir ? false : st.size === 0
+      },
+      tree,
+      options.minDepth
+    )) {
+      results.push(virtual);
+    }
+  }
+  await walk({ accessor, options, results, baseDepth, tree }, virtual, 0);
+  results.sort();
+  return results;
+}
+
+// src/commands/builtin/ssh/cp.ts
+function cpCommand(accessor, paths, _texts, opts) {
+  if (paths.length < 2) {
+    return Promise.resolve([
+      null,
+      new IOResult({ exitCode: 1, stderr: new TextEncoder().encode("cp: missing operand\n") })
+    ]);
+  }
+  const recursive = opts.flags.r === true || opts.flags.R === true || opts.flags.a === true;
+  return cpGeneric(
+    paths,
+    (src, target) => copy(accessor, src, target),
+    (src, options) => find(accessor, src, options),
+    (p) => stat(accessor, p),
+    recursive,
+    opts.flags.n === true,
+    opts.flags.v === true,
+    opts.index ?? void 0
+  );
+}
+var SSH_CP = command3({
+  name: "cp",
+  resource: ResourceName3.SSH,
+  spec: specOf3("cp"),
+  fn: cpCommand,
+  write: true
+});
+
+// src/commands/builtin/ssh/dirname.ts
+import { ResourceName as ResourceName4, command as command4, specOf as specOf4, dirnameFn } from "@struktoai/mirage-core";
+var SSH_DIRNAME = command4({
+  name: "dirname",
+  resource: ResourceName4.SSH,
+  spec: specOf4("dirname"),
+  fn: dirnameFn
+});
+
+// src/commands/builtin/ssh/du.ts
+import {
+  ResourceName as ResourceName5,
+  command as command5,
+  duGeneric,
+  specOf as specOf5
+} from "@struktoai/mirage-core";
+
+// src/core/ssh/du.ts
+import { norm as norm2 } from "@struktoai/mirage-core";
+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.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 statRemote2(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 statRemote2(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
+async function duCommand(accessor, paths, _texts, opts) {
+  const resolved = paths.length > 0 ? await resolveGlob(accessor, paths) : [];
+  return duGeneric(
+    resolved,
+    opts,
+    (p) => du(accessor, p),
+    (p) => duAll(accessor, p)
+  );
+}
+var SSH_DU = command5({
+  name: "du",
+  resource: ResourceName5.SSH,
+  spec: specOf5("du"),
+  fn: duCommand
+});
+
+// src/commands/builtin/ssh/file/file.ts
+import {
+  ResourceName as ResourceName6,
+  command as command6,
+  fileGeneric,
+  specOf as specOf6
+} from "@struktoai/mirage-core";
+async function fileCommand(accessor, paths, _texts, opts) {
+  const resolved = paths.length > 0 ? await resolveGlob(accessor, paths) : [];
+  return fileGeneric(
+    resolved,
+    opts,
+    (p) => stat(accessor, p),
+    (p) => read(accessor, p)
+  );
+}
+var SSH_FILE = command6({
+  name: "file",
+  resource: ResourceName6.SSH,
+  spec: specOf6("file"),
+  fn: fileCommand
+});
+
+// src/commands/builtin/ssh/find.ts
+import { ResourceName as ResourceName7, command as command7, findGeneric, specOf as specOf7 } from "@struktoai/mirage-core";
+var SSH_FIND = command7({
+  name: "find",
+  resource: ResourceName7.SSH,
+  spec: specOf7("find"),
+  fn: (accessor, paths, texts, opts) => findGeneric(paths, texts, opts, (root, options) => find(accessor, root, options))
+});
+
+// src/commands/builtin/ssh/grep/grep.ts
+import {
+  ResourceName as ResourceName8,
+  command as command8,
+  grepGeneric,
+  prefixAggregate,
+  specOf as specOf8
+} from "@struktoai/mirage-core";
+async function grepFn(accessor, paths, texts, opts) {
+  const resolved = paths.length > 0 ? await resolveGlob(accessor, paths) : [];
+  const stat2 = (p) => stat(accessor, p);
+  const readdir2 = (p) => readdir(accessor, p);
+  return grepGeneric("grep", resolved, texts, opts, stat2, readdir2, (p) => stream(accessor, p));
+}
+var SSH_GREP = command8({
+  name: "grep",
+  resource: ResourceName8.SSH,
+  spec: specOf8("grep"),
+  fn: grepFn,
+  aggregate: prefixAggregate
+});
+
+// src/commands/builtin/ssh/head/head.ts
+import {
+  ResourceName as ResourceName9,
+  command as command9,
+  headGeneric,
+  headProvisionGeneric,
+  headerAggregate,
+  specOf as specOf9
+} from "@struktoai/mirage-core";
+var SSH_HEAD = command9({
+  name: "head",
+  resource: ResourceName9.SSH,
+  spec: specOf9("head"),
+  fn: (accessor, paths, texts, opts) => headGeneric(
+    paths,
+    texts,
+    opts,
+    (p) => stat(accessor, p),
+    (p) => stream(accessor, p)
+  ),
+  provision: (accessor, paths, texts, opts) => headProvisionGeneric(paths, texts, opts, (p) => stat(accessor, p)),
+  aggregate: headerAggregate
+});
+
+// src/commands/builtin/ssh/jq.ts
+import {
+  ResourceName as ResourceName10,
+  command as command10,
+  jqGeneric,
+  jqProvisionGeneric,
+  specOf as specOf10
+} from "@struktoai/mirage-core";
+async function jqCommand(accessor, paths, texts, opts) {
+  const resolved = paths.length > 0 ? await resolveGlob(accessor, paths) : [];
+  return jqGeneric(resolved, texts, opts, (p) => stream(accessor, p));
+}
+var SSH_JQ = command10({
+  name: "jq",
+  resource: ResourceName10.SSH,
+  spec: specOf10("jq"),
+  fn: jqCommand,
+  provision: (accessor, paths, texts) => jqProvisionGeneric(paths, texts, (p) => stat(accessor, p))
+});
+
+// src/commands/builtin/ssh/ls/ls.ts
+import { ResourceName as ResourceName11, command as command11, lsGeneric, specOf as specOf11 } from "@struktoai/mirage-core";
+var SSH_LS = command11({
+  name: "ls",
+  resource: ResourceName11.SSH,
+  spec: specOf11("ls"),
+  fn: (accessor, paths, _texts, opts) => lsGeneric(
+    paths,
+    opts,
+    (p) => readdir(accessor, p),
+    (p) => stat(accessor, p)
+  )
+});
+
+// src/commands/builtin/ssh/mkdir.ts
+import {
+  IOResult as IOResult2,
+  ResourceName as ResourceName12,
+  command as command12,
+  specOf as specOf12
+} from "@struktoai/mirage-core";
+
+// src/core/ssh/mkdir.ts
+import { enoent as enoent5, stripSlash as stripSlash2 } 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 enoent5(p);
+      throw err;
+    }
+    return;
+  }
+  const cleaned = stripSlash2(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);
+  }
+}
+
+// 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 IOResult2({
+        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 IOResult2()];
+}
+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 IOResult3,
+  ResourceName as ResourceName13,
+  command as command13,
+  mvGeneric,
+  specOf as specOf13
+} from "@struktoai/mirage-core";
+
+// src/core/ssh/rename.ts
+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) => {
+    sftp.rename(remoteSrc, remoteDst, (err) => {
+      if (!err) {
+        resolveFn();
+        return;
+      }
+      if (isNoSuchFile(err)) rejectFn(enoent6(src));
+      else rejectFn(err);
+    });
+  });
+}
+
+// src/commands/builtin/ssh/mv.ts
+function mvCommand(accessor, paths, _texts, opts) {
+  if (paths.length < 2) {
+    return Promise.resolve([
+      null,
+      new IOResult3({ exitCode: 1, stderr: new TextEncoder().encode("mv: missing operand\n") })
+    ]);
+  }
+  return mvGeneric(
+    paths,
+    (src, target) => rename(accessor, src, target),
+    (p) => stat(accessor, p),
+    opts.flags.n === true,
+    opts.flags.v === true,
+    opts.index ?? void 0
+  );
+}
+var SSH_MV = command13({
+  name: "mv",
+  resource: ResourceName13.SSH,
+  spec: specOf13("mv"),
+  fn: mvCommand,
+  write: true
+});
+
+// src/commands/builtin/ssh/realpath.ts
+import { ResourceName as ResourceName14, command as command14, realpathGeneric, specOf as specOf14 } from "@struktoai/mirage-core";
+var SSH_REALPATH = command14({
+  name: "realpath",
+  resource: ResourceName14.SSH,
+  spec: specOf14("realpath"),
+  fn: (accessor, paths, texts, opts) => realpathGeneric(paths, texts, opts, (p) => stat(accessor, p))
+});
+
+// src/commands/builtin/ssh/rg.ts
+import {
+  ResourceName as ResourceName15,
+  command as command15,
+  rgGeneric,
+  specOf as specOf15
+} from "@struktoai/mirage-core";
+async function rgCommand(accessor, paths, texts, opts) {
+  const resolved = paths.length > 0 ? await resolveGlob(accessor, paths) : [];
+  const stat2 = (p) => stat(accessor, p);
+  const readdir2 = (p) => readdir(accessor, p);
+  return rgGeneric(resolved, texts, opts, stat2, readdir2, (p) => stream(accessor, p));
+}
+var SSH_RG = command15({
+  name: "rg",
+  resource: ResourceName15.SSH,
+  spec: specOf15("rg"),
+  fn: rgCommand
+});
+
+// src/commands/builtin/ssh/rm.ts
+import {
+  FileType as FileType2,
+  IOResult as IOResult4,
+  ResourceName as ResourceName16,
+  command as command16,
+  specOf as specOf16,
+  formatRecords
+} from "@struktoai/mirage-core";
+
+// src/core/ssh/rmdir.ts
+import { enoent as enoent7 } 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(enoent7(p));
+      else rejectFn(err);
+    });
+  });
+}
+
+// src/core/ssh/unlink.ts
+import { enoent as enoent8 } 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(enoent8(p));
+      else rejectFn(err);
+    });
+  });
+}
+
+// src/core/ssh/rm.ts
+import { enoent as enoent9 } 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 enoent9(p);
+    throw err;
+  }
+}
+
+// src/commands/builtin/ssh/rm.ts
+async function rmCommand(accessor, paths, _texts, opts) {
+  if (paths.length === 0) {
+    return [
+      null,
+      new IOResult4({
+        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 === FileType2.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 ? formatRecords(lines) : null;
+  return [out, new IOResult4()];
+}
+var SSH_RM = command16({
+  name: "rm",
+  resource: ResourceName16.SSH,
+  spec: specOf16("rm"),
+  fn: rmCommand,
+  write: true
+});
+
+// src/commands/builtin/ssh/stat/stat.ts
+import {
+  ResourceName as ResourceName17,
+  command as command17,
+  specOf as specOf17,
+  statGeneric,
+  statProvisionGeneric
+} from "@struktoai/mirage-core";
+async function statCommand(accessor, paths, _texts, opts) {
+  const resolved = paths.length > 0 ? await resolveGlob(accessor, paths) : [];
+  return statGeneric(resolved, opts, (p) => stat(accessor, p));
+}
+var SSH_STAT = command17({
+  name: "stat",
+  resource: ResourceName17.SSH,
+  spec: specOf17("stat"),
+  fn: statCommand,
+  provision: statProvisionGeneric
+});
+
+// src/commands/builtin/ssh/tail/tail.ts
+import { ResourceName as ResourceName18, command as command18, headerAggregate as headerAggregate2, specOf as specOf18, tailGeneric } from "@struktoai/mirage-core";
+var SSH_TAIL = command18({
+  name: "tail",
+  resource: ResourceName18.SSH,
+  spec: specOf18("tail"),
+  fn: (accessor, paths, texts, opts) => tailGeneric(paths, texts, opts, (p) => stream(accessor, p)),
+  aggregate: headerAggregate2
+});
+
+// src/commands/builtin/ssh/touch.ts
+import {
+  IOResult as IOResult5,
+  ResourceName as ResourceName19,
+  command as command19,
+  specOf as specOf19
+} from "@struktoai/mirage-core";
+
+// 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/commands/builtin/ssh/touch.ts
+var ENC = new TextEncoder();
+async function touchCommand(accessor, paths, texts, opts) {
+  if (paths.length === 0) {
+    return [null, new IOResult5({ exitCode: 1, stderr: ENC.encode("touch: missing operand\n") })];
+  }
+  const createOnly = opts.flags.c === true;
+  for (const p of paths) {
+    if (createOnly) continue;
+    if (!await exists(accessor, p)) {
+      await writeBytes(accessor, p, new Uint8Array(0));
+    }
+  }
+  return [null, new IOResult5()];
+}
+var SSH_TOUCH = command19({
+  name: "touch",
+  resource: ResourceName19.SSH,
+  spec: specOf19("touch"),
+  fn: touchCommand,
+  write: true
+});
+
+// src/commands/builtin/ssh/tree.ts
+import {
+  ResourceName as ResourceName20,
+  command as command20,
+  specOf as specOf20,
+  treeGeneric
+} from "@struktoai/mirage-core";
+async function treeCommand(accessor, paths, _texts, opts) {
+  const resolved = await resolveGlob(accessor, paths);
+  return treeGeneric(
+    resolved,
+    opts,
+    (p) => readdir(accessor, p),
+    (p) => stat(accessor, p)
+  );
+}
+var SSH_TREE = command20({
+  name: "tree",
+  resource: ResourceName20.SSH,
+  spec: specOf20("tree"),
+  fn: treeCommand
+});
+
+// src/commands/builtin/ssh/wc/wc.ts
+import { ResourceName as ResourceName21, command as command21, specOf as specOf21, wcAggregate, wcGeneric } from "@struktoai/mirage-core";
+var SSH_WC = command21({
+  name: "wc",
+  resource: ResourceName21.SSH,
+  spec: specOf21("wc"),
+  fn: (accessor, paths, texts, opts) => wcGeneric(paths, texts, opts, (p) => stream(accessor, p)),
+  aggregate: wcAggregate
+});
+
+// src/commands/builtin/ssh/awk.ts
+import { ResourceName as ResourceName22, awkGeneric, command as command22, specOf as specOf22 } from "@struktoai/mirage-core";
+var SSH_AWK = command22({
+  name: "awk",
+  resource: ResourceName22.SSH,
+  spec: specOf22("awk"),
+  fn: (accessor, paths, texts, opts) => awkGeneric(paths, texts, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/base64_cmd.ts
+import { ResourceName as ResourceName23, command as command23, specOf as specOf23, base64Generic } from "@struktoai/mirage-core";
+var SSH_BASE64 = command23({
+  name: "base64",
+  resource: ResourceName23.SSH,
+  spec: specOf23("base64"),
+  fn: (accessor, paths, _texts, opts) => base64Generic(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/cmp.ts
+import { ResourceName as ResourceName24, command as command24, specOf as specOf24, cmpGeneric } from "@struktoai/mirage-core";
+var SSH_CMP = command24({
+  name: "cmp",
+  resource: ResourceName24.SSH,
+  spec: specOf24("cmp"),
+  fn: (accessor, paths, _texts, opts) => cmpGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/column.ts
+import { ResourceName as ResourceName25, command as command25, specOf as specOf25, columnGeneric } from "@struktoai/mirage-core";
+var SSH_COLUMN = command25({
+  name: "column",
+  resource: ResourceName25.SSH,
+  spec: specOf25("column"),
+  fn: (accessor, paths, _texts, opts) => columnGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/comm.ts
+import { ResourceName as ResourceName26, command as command26, specOf as specOf26, commGeneric } from "@struktoai/mirage-core";
+var SSH_COMM = command26({
+  name: "comm",
+  resource: ResourceName26.SSH,
+  spec: specOf26("comm"),
+  fn: (accessor, paths, _texts, opts) => commGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/csplit.ts
+import { ResourceName as ResourceName27, command as command27, specOf as specOf27, csplitGeneric } from "@struktoai/mirage-core";
+var SSH_CSPLIT = command27({
+  name: "csplit",
+  resource: ResourceName27.SSH,
+  spec: specOf27("csplit"),
+  fn: (accessor, paths, texts, opts) => csplitGeneric(
+    paths,
+    texts,
+    opts,
+    (p) => stream(accessor, p),
+    (p, d) => writeBytes(accessor, p, d)
+  ),
+  write: true
+});
+
+// src/commands/builtin/ssh/cut.ts
+import { ResourceName as ResourceName28, command as command28, cutGeneric, specOf as specOf28 } from "@struktoai/mirage-core";
+var SSH_CUT = command28({
+  name: "cut",
+  resource: ResourceName28.SSH,
+  spec: specOf28("cut"),
+  fn: (accessor, paths, _texts, opts) => cutGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/diff.ts
+import { ResourceName as ResourceName29, command as command29, diffGeneric, specOf as specOf29 } from "@struktoai/mirage-core";
+var SSH_DIFF = command29({
+  name: "diff",
+  resource: ResourceName29.SSH,
+  spec: specOf29("diff"),
+  fn: (accessor, paths, _texts, opts) => diffGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/expand.ts
+import { ResourceName as ResourceName30, command as command30, specOf as specOf30, expandGeneric } from "@struktoai/mirage-core";
+var SSH_EXPAND = command30({
+  name: "expand",
+  resource: ResourceName30.SSH,
+  spec: specOf30("expand"),
+  fn: (accessor, paths, _texts, opts) => expandGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/fmt.ts
+import {
+  ResourceName as ResourceName31,
+  command as command31,
+  fmtGeneric,
+  specOf as specOf31
+} from "@struktoai/mirage-core";
+async function fmtCommand(accessor, paths, _texts, opts) {
+  return fmtGeneric(paths, opts, (p) => stream(accessor, p));
+}
+var SSH_FMT = command31({
+  name: "fmt",
+  resource: ResourceName31.SSH,
+  spec: specOf31("fmt"),
+  fn: fmtCommand
+});
+
+// src/commands/builtin/ssh/fold.ts
+import { ResourceName as ResourceName32, command as command32, specOf as specOf32, foldGeneric } from "@struktoai/mirage-core";
+var SSH_FOLD = command32({
+  name: "fold",
+  resource: ResourceName32.SSH,
+  spec: specOf32("fold"),
+  fn: (accessor, paths, _texts, opts) => foldGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/gunzip.ts
+import { ResourceName as ResourceName33, command as command33, specOf as specOf33, gunzipGeneric } from "@struktoai/mirage-core";
+var SSH_GUNZIP = command33({
+  name: "gunzip",
+  resource: ResourceName33.SSH,
+  spec: specOf33("gunzip"),
+  fn: (accessor, paths, _texts, opts) => gunzipGeneric(
+    paths,
+    opts,
+    (p) => stream(accessor, p),
+    (p, d) => writeBytes(accessor, p, d),
+    (p) => unlink(accessor, p)
+  ),
+  write: true
+});
+
+// src/commands/builtin/ssh/gzip.ts
+import { ResourceName as ResourceName34, command as command34, specOf as specOf34, gzipGeneric } from "@struktoai/mirage-core";
+var SSH_GZIP = command34({
+  name: "gzip",
+  resource: ResourceName34.SSH,
+  spec: specOf34("gzip"),
+  fn: (accessor, paths, _texts, opts) => gzipGeneric(
+    paths,
+    opts,
+    (p) => stream(accessor, p),
+    (p, d) => writeBytes(accessor, p, d),
+    (p) => unlink(accessor, p)
+  ),
+  write: true
+});
+
+// src/commands/builtin/ssh/iconv.ts
+import { ResourceName as ResourceName35, command as command35, specOf as specOf35, iconvGeneric } from "@struktoai/mirage-core";
+var SSH_ICONV = command35({
+  name: "iconv",
+  resource: ResourceName35.SSH,
+  spec: specOf35("iconv"),
+  fn: (accessor, paths, _texts, opts) => iconvGeneric(
+    paths,
+    opts,
+    (p) => stream(accessor, p),
+    (p, d) => writeBytes(accessor, p, d)
+  ),
+  write: true
+});
+
+// src/commands/builtin/ssh/join.ts
+import { ResourceName as ResourceName36, command as command36, specOf as specOf36, joinGeneric } from "@struktoai/mirage-core";
+var SSH_JOIN = command36({
+  name: "join",
+  resource: ResourceName36.SSH,
+  spec: specOf36("join"),
+  fn: (accessor, paths, _texts, opts) => joinGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/ln.ts
+import {
+  IOResult as IOResult6,
+  ResourceName as ResourceName37,
+  command as command37,
+  materialize,
+  specOf as specOf37
+} from "@struktoai/mirage-core";
+var ENC2 = new TextEncoder();
+async function lnCommand(accessor, paths, texts, opts) {
+  if (paths.length < 2) {
+    return [
+      null,
+      new IOResult6({ exitCode: 1, stderr: ENC2.encode("ln: usage: ln [-s] [-f] source dest\n") })
+    ];
+  }
+  const source = paths[0];
+  const dest = paths[1];
+  if (source === void 0 || dest === void 0) return [null, new IOResult6()];
+  if (opts.flags.n === true && await exists(accessor, dest)) {
+    return [null, new IOResult6()];
+  }
+  const data = await materialize(stream(accessor, source));
+  await writeBytes(accessor, dest, data);
+  const out = opts.flags.v === true ? ENC2.encode(`'${source.original}' -> '${dest.original}'
+`) : null;
+  return [out, new IOResult6({ writes: { [dest.stripPrefix]: data } })];
+}
+var SSH_LN = command37({
+  name: "ln",
+  resource: ResourceName37.SSH,
+  spec: specOf37("ln"),
+  fn: lnCommand,
+  write: true
+});
+
+// src/commands/builtin/ssh/look.ts
+import { ResourceName as ResourceName38, command as command38, specOf as specOf38, lookGeneric } from "@struktoai/mirage-core";
+var SSH_LOOK = command38({
+  name: "look",
+  resource: ResourceName38.SSH,
+  spec: specOf38("look"),
+  fn: (accessor, paths, texts, opts) => lookGeneric(paths, texts, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/md5.ts
+import { ResourceName as ResourceName39, command as command39, specOf as specOf39, md5Generic } from "@struktoai/mirage-core";
+var SSH_MD5 = command39({
+  name: "md5",
+  resource: ResourceName39.SSH,
+  spec: specOf39("md5"),
+  fn: (accessor, paths, _texts, opts) => md5Generic(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/mktemp.ts
+import { ResourceName as ResourceName40, command as command40, mktempGeneric, specOf as specOf40 } from "@struktoai/mirage-core";
+var SSH_MKTEMP = command40({
+  name: "mktemp",
+  resource: ResourceName40.SSH,
+  spec: specOf40("mktemp"),
+  fn: (accessor, _paths, texts, opts) => mktempGeneric(
+    texts,
+    opts,
+    (p, parents) => mkdir(accessor, p, parents ?? false),
+    (p, d) => writeBytes(accessor, p, d)
+  ),
+  write: true
+});
+
+// src/commands/builtin/ssh/nl.ts
+import { ResourceName as ResourceName41, command as command41, specOf as specOf41, nlGeneric } from "@struktoai/mirage-core";
+var SSH_NL = command41({
+  name: "nl",
+  resource: ResourceName41.SSH,
+  spec: specOf41("nl"),
+  fn: (accessor, paths, _texts, opts) => nlGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/paste.ts
+import { ResourceName as ResourceName42, command as command42, specOf as specOf42, pasteGeneric } from "@struktoai/mirage-core";
+var SSH_PASTE = command42({
+  name: "paste",
+  resource: ResourceName42.SSH,
+  spec: specOf42("paste"),
+  fn: (accessor, paths, _texts, opts) => pasteGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/patch.ts
+import { ResourceName as ResourceName43, command as command43, specOf as specOf43, patchGeneric } from "@struktoai/mirage-core";
+var SSH_PATCH = command43({
+  name: "patch",
+  resource: ResourceName43.SSH,
+  spec: specOf43("patch"),
+  fn: (accessor, paths, _texts, opts) => patchGeneric(
+    paths,
+    opts,
+    (p) => stream(accessor, p),
+    (p, d) => writeBytes(accessor, p, d)
+  ),
+  write: true
+});
+
+// src/commands/builtin/ssh/readlink.ts
+import {
+  ResourceName as ResourceName44,
+  command as command44,
+  readlinkGeneric,
+  specOf as specOf44
+} from "@struktoai/mirage-core";
+var SSH_READLINK = command44({
+  name: "readlink",
+  resource: ResourceName44.SSH,
+  spec: specOf44("readlink"),
+  fn: (_accessor, paths, texts, opts) => readlinkGeneric(paths, texts, opts)
+});
+
+// src/commands/builtin/ssh/rev.ts
+import { ResourceName as ResourceName45, command as command45, specOf as specOf45, revGeneric } from "@struktoai/mirage-core";
+var SSH_REV = command45({
+  name: "rev",
+  resource: ResourceName45.SSH,
+  spec: specOf45("rev"),
+  fn: (accessor, paths, _texts, opts) => revGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/sed.ts
+import { ResourceName as ResourceName46, command as command46, specOf as specOf46, sedGeneric } from "@struktoai/mirage-core";
+var SSH_SED = command46({
+  name: "sed",
+  resource: ResourceName46.SSH,
+  spec: specOf46("sed"),
+  fn: (accessor, paths, texts, opts) => sedGeneric(
+    paths,
+    texts,
+    opts,
+    (p) => stream(accessor, p),
+    (p, d) => writeBytes(accessor, p, d)
+  )
+});
+
+// src/commands/builtin/ssh/sha256sum.ts
+import { ResourceName as ResourceName47, command as command47, sha256sumGeneric, specOf as specOf47 } from "@struktoai/mirage-core";
+var SSH_SHA256SUM = command47({
+  name: "sha256sum",
+  resource: ResourceName47.SSH,
+  spec: specOf47("sha256sum"),
+  fn: (accessor, paths, _texts, opts) => sha256sumGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/shuf.ts
+import { ResourceName as ResourceName48, command as command48, specOf as specOf48, shufGeneric } from "@struktoai/mirage-core";
+var SSH_SHUF = command48({
+  name: "shuf",
+  resource: ResourceName48.SSH,
+  spec: specOf48("shuf"),
+  fn: (accessor, paths, texts, opts) => shufGeneric(paths, texts, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/sort.ts
+import { ResourceName as ResourceName49, command as command49, specOf as specOf49, sortGeneric } from "@struktoai/mirage-core";
+var SSH_SORT = command49({
+  name: "sort",
+  resource: ResourceName49.SSH,
+  spec: specOf49("sort"),
+  fn: (accessor, paths, _texts, opts) => sortGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/split.ts
+import { ResourceName as ResourceName50, command as command50, specOf as specOf50, splitGeneric } from "@struktoai/mirage-core";
+var SSH_SPLIT = command50({
+  name: "split",
+  resource: ResourceName50.SSH,
+  spec: specOf50("split"),
+  fn: (accessor, paths, _texts, opts) => splitGeneric(
+    paths,
+    opts,
+    (p) => stream(accessor, p),
+    (p, d) => writeBytes(accessor, p, d)
+  ),
+  write: true
+});
+
+// src/commands/builtin/ssh/strings.ts
+import { ResourceName as ResourceName51, command as command51, specOf as specOf51, stringsGeneric } from "@struktoai/mirage-core";
+var SSH_STRINGS = command51({
+  name: "strings",
+  resource: ResourceName51.SSH,
+  spec: specOf51("strings"),
+  fn: (accessor, paths, _texts, opts) => stringsGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/tac.ts
+import { ResourceName as ResourceName52, command as command52, specOf as specOf52, tacGeneric } from "@struktoai/mirage-core";
+var SSH_TAC = command52({
+  name: "tac",
+  resource: ResourceName52.SSH,
+  spec: specOf52("tac"),
+  fn: (accessor, paths, _texts, opts) => tacGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/tar.ts
+import { ResourceName as ResourceName53, command as command53, specOf as specOf53, tarGeneric } from "@struktoai/mirage-core";
+var SSH_TAR = command53({
+  name: "tar",
+  resource: ResourceName53.SSH,
+  spec: specOf53("tar"),
+  fn: (accessor, paths, _texts, opts) => tarGeneric(
+    paths,
+    opts,
+    (p) => stream(accessor, p),
+    (p, data) => writeBytes(accessor, p, data),
+    (p) => mkdir(accessor, p, false)
+  ),
+  write: true
+});
+
+// src/commands/builtin/ssh/tee.ts
+import { ResourceName as ResourceName54, command as command54, specOf as specOf54, teeGeneric } from "@struktoai/mirage-core";
+var SSH_TEE = command54({
+  name: "tee",
+  resource: ResourceName54.SSH,
+  spec: specOf54("tee"),
+  fn: (accessor, paths, texts, opts) => teeGeneric(
+    paths,
+    texts,
+    opts,
+    (p) => stream(accessor, p),
+    (p, d) => writeBytes(accessor, p, d)
+  ),
+  write: true
+});
+
+// src/commands/builtin/ssh/tr.ts
+import { ResourceName as ResourceName55, command as command55, specOf as specOf55, trGeneric } from "@struktoai/mirage-core";
+var SSH_TR = command55({
+  name: "tr",
+  resource: ResourceName55.SSH,
+  spec: specOf55("tr"),
+  fn: (accessor, paths, texts, opts) => trGeneric(paths, texts, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/tsort.ts
+import { ResourceName as ResourceName56, command as command56, specOf as specOf56, tsortGeneric } from "@struktoai/mirage-core";
+var SSH_TSORT = command56({
+  name: "tsort",
+  resource: ResourceName56.SSH,
+  spec: specOf56("tsort"),
+  fn: (accessor, paths, _texts, opts) => tsortGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/unexpand.ts
+import { ResourceName as ResourceName57, command as command57, specOf as specOf57, unexpandGeneric } from "@struktoai/mirage-core";
+var SSH_UNEXPAND = command57({
+  name: "unexpand",
+  resource: ResourceName57.SSH,
+  spec: specOf57("unexpand"),
+  fn: (accessor, paths, _texts, opts) => unexpandGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/uniq.ts
+import { ResourceName as ResourceName58, command as command58, specOf as specOf58, uniqGeneric } from "@struktoai/mirage-core";
+var SSH_UNIQ = command58({
+  name: "uniq",
+  resource: ResourceName58.SSH,
+  spec: specOf58("uniq"),
+  fn: (accessor, paths, _texts, opts) => uniqGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/unzip.ts
+import { ResourceName as ResourceName59, command as command59, specOf as specOf59, unzipGeneric } from "@struktoai/mirage-core";
+var SSH_UNZIP = command59({
+  name: "unzip",
+  resource: ResourceName59.SSH,
+  spec: specOf59("unzip"),
+  fn: (accessor, paths, _texts, opts) => unzipGeneric(
+    paths,
+    opts,
+    (p) => stream(accessor, p),
+    (p, d) => writeBytes(accessor, p, d),
+    (p, parents) => mkdir(accessor, p, parents ?? false)
+  ),
+  write: true
+});
+
+// src/commands/builtin/ssh/xxd.ts
+import { ResourceName as ResourceName60, command as command60, specOf as specOf60, xxdGeneric } from "@struktoai/mirage-core";
+var SSH_XXD = command60({
+  name: "xxd",
+  resource: ResourceName60.SSH,
+  spec: specOf60("xxd"),
+  fn: (accessor, paths, _texts, opts) => xxdGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/zcat.ts
+import { ResourceName as ResourceName61, command as command61, specOf as specOf61, zcatGeneric } from "@struktoai/mirage-core";
+var SSH_ZCAT = command61({
+  name: "zcat",
+  resource: ResourceName61.SSH,
+  spec: specOf61("zcat"),
+  fn: (accessor, paths, _texts, opts) => zcatGeneric(paths, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/zgrep.ts
+import { ResourceName as ResourceName62, command as command62, specOf as specOf62, zgrepGeneric } from "@struktoai/mirage-core";
+var SSH_ZGREP = command62({
+  name: "zgrep",
+  resource: ResourceName62.SSH,
+  spec: specOf62("zgrep"),
+  fn: (accessor, paths, texts, opts) => zgrepGeneric(paths, texts, opts, (p) => stream(accessor, p))
+});
+
+// src/commands/builtin/ssh/zip_cmd.ts
+import { ResourceName as ResourceName63, command as command63, specOf as specOf63, zipGeneric } from "@struktoai/mirage-core";
+var SSH_ZIP = command63({
+  name: "zip",
+  resource: ResourceName63.SSH,
+  spec: specOf63("zip"),
+  fn: (accessor, paths, _texts, opts) => zipGeneric(
+    paths,
+    opts,
+    (p) => stream(accessor, p),
+    (p, d) => writeBytes(accessor, p, d)
+  ),
+  write: true
+});
+
+// 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,
+  ...SSH_AWK,
+  ...SSH_BASE64,
+  ...SSH_CMP,
+  ...SSH_COLUMN,
+  ...SSH_COMM,
+  ...SSH_CSPLIT,
+  ...SSH_CUT,
+  ...SSH_DIFF,
+  ...SSH_EXPAND,
+  ...SSH_FMT,
+  ...SSH_FOLD,
+  ...SSH_GUNZIP,
+  ...SSH_GZIP,
+  ...SSH_ICONV,
+  ...SSH_JOIN,
+  ...SSH_LN,
+  ...SSH_LOOK,
+  ...SSH_MD5,
+  ...SSH_MKTEMP,
+  ...SSH_NL,
+  ...SSH_PASTE,
+  ...SSH_PATCH,
+  ...SSH_READLINK,
+  ...SSH_REV,
+  ...SSH_SED,
+  ...SSH_SHA256SUM,
+  ...SSH_SHUF,
+  ...SSH_SORT,
+  ...SSH_SPLIT,
+  ...SSH_STRINGS,
+  ...SSH_TAC,
+  ...SSH_TAR,
+  ...SSH_TEE,
+  ...SSH_TR,
+  ...SSH_TSORT,
+  ...SSH_UNEXPAND,
+  ...SSH_UNIQ,
+  ...SSH_UNZIP,
+  ...SSH_XXD,
+  ...SSH_ZCAT,
+  ...SSH_ZGREP,
+  ...SSH_ZIP
+];
+
+// 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/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 ResourceName64 } from "@struktoai/mirage-core";
+var appendOp = {
+  name: "append",
+  resource: ResourceName64.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 ResourceName65 } from "@struktoai/mirage-core";
+var createOp = {
+  name: "create",
+  resource: ResourceName65.SSH,
+  filetype: null,
+  write: true,
+  fn: (accessor, path) => {
+    return create(accessor, path);
+  }
+};
+
+// src/ops/ssh/mkdir.ts
+import { ResourceName as ResourceName66 } from "@struktoai/mirage-core";
+var mkdirOp = {
+  name: "mkdir",
+  resource: ResourceName66.SSH,
+  filetype: null,
+  write: true,
+  fn: (accessor, path) => {
+    return mkdir(accessor, path, true);
+  }
+};
+
+// src/ops/ssh/read.ts
+import { ResourceName as ResourceName67 } from "@struktoai/mirage-core";
+var readOp = {
+  name: "read",
+  resource: ResourceName67.SSH,
+  filetype: null,
+  write: false,
+  fn: (accessor, path) => {
+    return read(accessor, path);
+  }
+};
+
+// src/ops/ssh/readdir.ts
+import { ResourceName as ResourceName68 } from "@struktoai/mirage-core";
+var readdirOp = {
+  name: "readdir",
+  resource: ResourceName68.SSH,
+  filetype: null,
+  write: false,
+  fn: (accessor, path) => {
+    return readdir(accessor, path);
+  }
+};
+
+// src/ops/ssh/rename.ts
+import { ResourceName as ResourceName69 } from "@struktoai/mirage-core";
+var renameOp = {
+  name: "rename",
+  resource: ResourceName69.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 ResourceName70 } from "@struktoai/mirage-core";
+var rmdirOp = {
+  name: "rmdir",
+  resource: ResourceName70.SSH,
+  filetype: null,
+  write: true,
+  fn: (accessor, path) => {
+    return rmdir(accessor, path);
+  }
+};
+
+// src/ops/ssh/stat.ts
+import { ResourceName as ResourceName71 } from "@struktoai/mirage-core";
+var statOp = {
+  name: "stat",
+  resource: ResourceName71.SSH,
+  filetype: null,
+  write: false,
+  fn: (accessor, path) => {
+    return stat(accessor, path);
+  }
+};
+
+// src/ops/ssh/truncate.ts
+import { ResourceName as ResourceName72 } from "@struktoai/mirage-core";
+var truncateOp = {
+  name: "truncate",
+  resource: ResourceName72.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 ResourceName73 } from "@struktoai/mirage-core";
+var unlinkOp = {
+  name: "unlink",
+  resource: ResourceName73.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 ResourceName74 } from "@struktoai/mirage-core";
+var writeOp = {
+  name: "write",
+  resource: ResourceName74.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 extends BaseResource {
+  kind = ResourceName75.SSH;
+  isRemote = 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);
+  }
+  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 PathSpec2({
+        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,
+      config: redactSshConfig(this.config)
+    };
+  }
+  loadState(_state) {
+    return Promise.resolve();
+  }
+};
+
+export {
+  SSHAccessor,
+  SSH_COMMANDS,
+  SSH_OPS,
+  SSH_PROMPT,
+  SSHResource
+};
+//# sourceMappingURL=chunk-5HCVKTP3.js.map