ai-remote 0.4.13 → 0.4.15

package/dist/cli-copy-NRXMTHID.mjs

@@ -0,0 +1,718 @@
+import {
+  SshSession,
+  TcpTransport
+} from "./cli-chunk-EYQCDSPT.mjs";
+import {
+  SshReader,
+  SshWriter
+} from "./cli-chunk-XT2FISR5.mjs";
+
+// src/cli/copy.ts
+import { open as openFile, mkdir, readdir, stat as statFile } from "node:fs/promises";
+import { basename, dirname, join, resolve as resolveLocal } from "node:path";
+
+// src/protocols/ssh/sftp.ts
+var FXP = {
+  INIT: 1,
+  VERSION: 2,
+  OPEN: 3,
+  CLOSE: 4,
+  READ: 5,
+  WRITE: 6,
+  LSTAT: 7,
+  FSTAT: 8,
+  SETSTAT: 9,
+  OPENDIR: 11,
+  READDIR: 12,
+  REMOVE: 13,
+  MKDIR: 14,
+  RMDIR: 15,
+  REALPATH: 16,
+  STAT: 17,
+  RENAME: 18,
+  STATUS: 101,
+  HANDLE: 102,
+  DATA: 103,
+  NAME: 104,
+  ATTRS: 105
+};
+var OPEN_FLAGS = {
+  READ: 1,
+  WRITE: 2,
+  APPEND: 4,
+  CREATE: 8,
+  TRUNCATE: 16,
+  EXCLUSIVE: 32
+};
+var ATTR = {
+  SIZE: 1,
+  UIDGID: 2,
+  PERMISSIONS: 4,
+  ACMODTIME: 8,
+  EXTENDED: 2147483648
+};
+var STATUS = {
+  OK: 0,
+  EOF: 1,
+  NO_SUCH_FILE: 2,
+  PERMISSION_DENIED: 3,
+  FAILURE: 4,
+  BAD_MESSAGE: 5,
+  NO_CONNECTION: 6,
+  CONNECTION_LOST: 7,
+  OP_UNSUPPORTED: 8
+};
+var STATUS_TEXT = {
+  [STATUS.EOF]: "the end of the file",
+  [STATUS.NO_SUCH_FILE]: "no such file or directory",
+  [STATUS.PERMISSION_DENIED]: "permission denied",
+  [STATUS.FAILURE]: "the host refused the operation",
+  [STATUS.BAD_MESSAGE]: "the host could not parse the request",
+  [STATUS.NO_CONNECTION]: "no connection",
+  [STATUS.CONNECTION_LOST]: "the connection was lost",
+  [STATUS.OP_UNSUPPORTED]: "the host does not support that operation"
+};
+var SftpError = class extends Error {
+  code;
+  constructor(code, detail, operation) {
+    const meaning = STATUS_TEXT[code] ?? `SFTP status ${code}`;
+    super(detail && detail.toLowerCase() !== "failure" ? `${operation}: ${detail}` : `${operation}: ${meaning}`);
+    this.code = code;
+    this.name = "SftpError";
+  }
+  /** True when the thing simply is not there, which callers treat as a fact rather than a failure. */
+  get missing() {
+    return this.code === STATUS.NO_SUCH_FILE;
+  }
+};
+var S_IFMT = 61440;
+var S_IFDIR = 16384;
+var CHUNK = 32 * 1024;
+function readAttrs(reader) {
+  const flags = reader.u32();
+  const size = flags & ATTR.SIZE ? reader.u64() : null;
+  if (flags & ATTR.UIDGID) {
+    reader.u32();
+    reader.u32();
+  }
+  const permissions = flags & ATTR.PERMISSIONS ? reader.u32() : null;
+  let mtime = null;
+  if (flags & ATTR.ACMODTIME) {
+    reader.u32();
+    mtime = reader.u32();
+  }
+  if (flags & ATTR.EXTENDED) {
+    const count = reader.u32();
+    for (let index = 0; index < count; index++) {
+      reader.stringBytes();
+      reader.stringBytes();
+    }
+  }
+  return {
+    size,
+    permissions,
+    mtime,
+    directory: permissions !== null && (permissions & S_IFMT) === S_IFDIR
+  };
+}
+function writeAttrs(writer, mode) {
+  if (mode === null) return writer.u32(0);
+  return writer.u32(ATTR.PERMISSIONS).u32(mode);
+}
+function expect(reply, kind, operation) {
+  if (reply.kind !== kind) throw new Error(`${operation}: the host answered with ${reply.kind}, not ${kind}`);
+  return reply;
+}
+var Sftp = class {
+  #write;
+  #nextId = 1;
+  #pending = /* @__PURE__ */ new Map();
+  /** Bytes of a packet that has arrived only partly. */
+  #buffer = new Uint8Array(0);
+  #closed = false;
+  version = 0;
+  constructor({ write }) {
+    this.#write = write;
+  }
+  /**
+   * Channel data, in whatever sizes it arrived in.
+   *
+   * SSH hands over what fitted in a packet, which has nothing to do with where
+   * SFTP messages begin and end -- a 32 KB read comes back as several channel
+   * packets, and two small replies can share one. So the length prefix is the
+   * only framing, and the tail of an incomplete message is held here.
+   */
+  receive(bytes) {
+    if (!bytes.length) return;
+    const joined = new Uint8Array(this.#buffer.length + bytes.length);
+    joined.set(this.#buffer);
+    joined.set(bytes, this.#buffer.length);
+    this.#buffer = joined;
+    for (; ; ) {
+      if (this.#buffer.length < 4) return;
+      const reader = new SshReader(this.#buffer);
+      const length = reader.u32();
+      if (this.#buffer.length < 4 + length) return;
+      const packet = this.#buffer.subarray(4, 4 + length);
+      this.#buffer = this.#buffer.subarray(4 + length);
+      try {
+        this.#dispatch(packet);
+      } catch (error) {
+        this.fail(error instanceof Error ? error.message : String(error));
+        return;
+      }
+    }
+  }
+  /** Every request still waiting gives up, because the channel has gone. */
+  fail(message) {
+    this.#closed = true;
+    const waiting = [...this.#pending.values()];
+    this.#pending.clear();
+    for (const request of waiting) request.reject(new Error(message));
+  }
+  #dispatch(packet) {
+    const reader = new SshReader(packet);
+    const type = reader.u8();
+    if (type === FXP.VERSION) {
+      this.version = reader.u32();
+      const waiter2 = this.#pending.get(0);
+      this.#pending.delete(0);
+      waiter2?.resolve({ kind: "version", version: this.version });
+      return;
+    }
+    const id = reader.u32();
+    const waiter = this.#pending.get(id);
+    if (!waiter) return;
+    this.#pending.delete(id);
+    switch (type) {
+      case FXP.STATUS: {
+        const code = reader.u32();
+        const detail = reader.remaining ? reader.string() : "";
+        if (code === STATUS.OK) waiter.resolve({ kind: "ok" });
+        else if (code === STATUS.EOF) waiter.resolve({ kind: "eof" });
+        else waiter.reject(new SftpError(code, detail, waiter.operation));
+        return;
+      }
+      case FXP.HANDLE:
+        waiter.resolve({ kind: "handle", handle: reader.stringBytes() });
+        return;
+      case FXP.DATA:
+        waiter.resolve({ kind: "data", data: reader.stringBytes() });
+        return;
+      case FXP.ATTRS:
+        waiter.resolve({ kind: "attrs", attrs: readAttrs(reader) });
+        return;
+      case FXP.NAME: {
+        const count = reader.u32();
+        const names = [];
+        for (let index = 0; index < count; index++) {
+          const name = reader.string();
+          reader.string();
+          names.push({ name, attrs: readAttrs(reader) });
+        }
+        waiter.resolve({ kind: "names", names });
+        return;
+      }
+      default:
+        waiter.reject(new Error(`${waiter.operation}: unexpected SFTP reply type ${type}`));
+    }
+  }
+  /** Send one request and wait for the reply that carries its id. */
+  #request(type, operation, build) {
+    if (this.#closed) return Promise.reject(new Error(`${operation}: the SFTP channel is closed.`));
+    const id = this.#nextId++;
+    const body = new SshWriter(256).u8(type).u32(id);
+    build(body);
+    return this.#send(id, operation, body.take());
+  }
+  #send(id, operation, packet) {
+    const framed = new SshWriter(packet.length + 4).u32(packet.length).raw(packet).take();
+    return new Promise((resolve, reject) => {
+      this.#pending.set(id, { resolve, reject, operation });
+      try {
+        this.#write(framed);
+      } catch (error) {
+        this.#pending.delete(id);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+  /**
+   * Agree a version. Nothing else can be sent before this.
+   *
+   * The reply carries no request id -- it is the one message in the protocol
+   * that does not -- so it is parked under id 0, which no request uses.
+   */
+  async handshake() {
+    const packet = new SshWriter(16).u8(FXP.INIT).u32(3).take();
+    const reply = await this.#send(0, "SFTP handshake", packet);
+    const { version } = expect(reply, "version", "SFTP handshake");
+    if (version < 3) {
+      throw new Error(`SFTP: the host offered version ${version}, and this client needs 3.`);
+    }
+    return version;
+  }
+  async open(path, flags, mode = null) {
+    const operation = `opening ${path}`;
+    const reply = await this.#request(FXP.OPEN, operation, (writer) => {
+      writeAttrs(writer.string(path).u32(flags), mode);
+    });
+    return expect(reply, "handle", operation).handle;
+  }
+  async close(handle) {
+    await this.#request(FXP.CLOSE, "closing a file", (writer) => {
+      writer.string(handle);
+    });
+  }
+  /** Bytes at an offset, or null at the end of the file. */
+  async read(handle, offset, length) {
+    const reply = await this.#request(FXP.READ, "reading", (writer) => {
+      writer.string(handle).u64(offset).u32(length);
+    });
+    return reply.kind === "eof" ? null : expect(reply, "data", "reading").data;
+  }
+  async writeChunk(handle, offset, data) {
+    await this.#request(FXP.WRITE, "writing", (writer) => {
+      writer.string(handle).u64(offset).string(data);
+    });
+  }
+  /** Attributes, following symlinks. Null when there is nothing at that path. */
+  async stat(path) {
+    const operation = `checking ${path}`;
+    try {
+      const reply = await this.#request(FXP.STAT, operation, (writer) => {
+        writer.string(path);
+      });
+      return expect(reply, "attrs", operation).attrs;
+    } catch (error) {
+      if (error instanceof SftpError && error.missing) return null;
+      throw error;
+    }
+  }
+  async fstat(handle) {
+    const operation = "checking an open file";
+    const reply = await this.#request(FXP.FSTAT, operation, (writer) => {
+      writer.string(handle);
+    });
+    return expect(reply, "attrs", operation).attrs;
+  }
+  async setMode(path, mode) {
+    await this.#request(FXP.SETSTAT, `setting the mode of ${path}`, (writer) => {
+      writeAttrs(writer.string(path), mode);
+    });
+  }
+  /** Create a directory. A directory that already exists is not an error here. */
+  async mkdir(path, mode = 493) {
+    try {
+      await this.#request(FXP.MKDIR, `creating ${path}`, (writer) => {
+        writeAttrs(writer.string(path), mode);
+      });
+    } catch (error) {
+      const existing = await this.stat(path).catch(() => null);
+      if (!existing?.directory) throw error;
+    }
+  }
+  async remove(path) {
+    await this.#request(FXP.REMOVE, `removing ${path}`, (writer) => {
+      writer.string(path);
+    });
+  }
+  async rmdir(path) {
+    await this.#request(FXP.RMDIR, `removing ${path}`, (writer) => {
+      writer.string(path);
+    });
+  }
+  async rename(from, to) {
+    await this.#request(FXP.RENAME, `renaming ${from}`, (writer) => {
+      writer.string(from).string(to);
+    });
+  }
+  /**
+   * Everything in a directory, `.` and `..` left out.
+   *
+   * READDIR is called until it reports the end rather than once, because a
+   * server returns as many names as fitted in its reply and a directory with a
+   * few hundred files in it takes several.
+   */
+  async readdir(path) {
+    const operation = `listing ${path}`;
+    const opened = await this.#request(FXP.OPENDIR, operation, (writer) => {
+      writer.string(path);
+    });
+    const handle = expect(opened, "handle", operation).handle;
+    const entries = [];
+    try {
+      for (; ; ) {
+        const reply = await this.#request(FXP.READDIR, operation, (writer) => {
+          writer.string(handle);
+        });
+        if (reply.kind === "eof") break;
+        for (const entry of expect(reply, "names", operation).names) {
+          if (entry.name !== "." && entry.name !== "..") entries.push(entry);
+        }
+      }
+    } finally {
+      await this.close(handle).catch(() => {
+      });
+    }
+    return entries;
+  }
+  /**
+   * What the host makes of a path, absolute.
+   *
+   * Worth asking rather than guessing: a relative path is resolved against the
+   * account's start directory, which is the server's business and not visible
+   * from here.
+   */
+  async realpath(path) {
+    const operation = `resolving ${path}`;
+    const reply = await this.#request(FXP.REALPATH, operation, (writer) => {
+      writer.string(path);
+    });
+    return expect(reply, "names", operation).names[0]?.name ?? path;
+  }
+  /**
+   * A path as typed, made absolute -- including a leading `~`.
+   *
+   * `~` is a shell convention, and SFTP has no shell in it: sftp-server would
+   * look for a directory actually named `~` and report that there is none. But
+   * a relative path *is* resolved against the account's start directory, which
+   * is the home directory, so `REALPATH .` is the answer to what `~` meant. It
+   * is one extra round trip and only for paths that need it.
+   */
+  async resolve(path) {
+    if (path !== "~" && !path.startsWith("~/")) return path;
+    const home = await this.realpath(".");
+    const rest = path.slice(1).replace(/^\//, "");
+    return rest ? `${home.replace(/\/$/, "")}/${rest}` : home;
+  }
+};
+
+// src/cli/copy.ts
+var PIPELINE = 8;
+function parseEndpoint(token) {
+  const colon = token.indexOf(":");
+  if (colon === -1) return { remote: false, session: "", path: token };
+  const prefix = token.slice(0, colon);
+  if (prefix.length === 1) return { remote: false, session: "", path: token };
+  return { remote: true, session: prefix, path: token.slice(colon + 1) };
+}
+function destinationPath(destination, sourceName, isDirectory) {
+  if (!isDirectory) return destination;
+  const separator = destination.endsWith("/") || destination.endsWith("\\") ? "" : "/";
+  return `${destination}${separator}${sourceName}`;
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  const units = ["KB", "MB", "GB", "TB"];
+  let value = bytes / 1024;
+  let unit = 0;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit++;
+  }
+  return `${value < 10 ? value.toFixed(1) : Math.round(value)} ${units[unit]}`;
+}
+function formatRate(bytes, milliseconds) {
+  if (milliseconds < 50 || bytes === 0) return "";
+  return `${formatBytes(Math.round(bytes * 1e3 / milliseconds))}/s`;
+}
+var SftpConnection = class {
+  sftp;
+  /**
+   * `SshSession` is untyped JavaScript in a `.ts` file, so `any` is the honest
+   * description of it -- the same as `shell.ts` does with the same class. The
+   * listeners below annotate their own events, which is where the shape
+   * actually matters.
+   */
+  #session;
+  #error = "";
+  constructor(options) {
+    this.#session = new SshSession(`tcp://${options.host}:${options.port}`, {
+      username: options.username,
+      password: options.password ?? "",
+      identities: options.identities ?? [],
+      subsystem: "sftp",
+      // To stderr, not stdout: a copy's stdout is its result, and with --json it
+      // is a document something else parses. The handshake is still visible,
+      // and still redirectable on its own.
+      log: (step, detail) => process.stderr.write(`[SSH] ${step} ${JSON.stringify(detail)}
+`),
+      // The same reasoning as the terminal's: the person running the command
+      // named the host, on their own network, and there is no known_hosts here
+      // to compare against yet.
+      verifyHost: async () => true,
+      openTransport: () => new TcpTransport(options.host, options.port)
+    });
+    this.sftp = new Sftp({ write: (bytes) => this.#session.write(bytes) });
+    this.#session.addEventListener("data", (event) => {
+      const bytes = event.detail.bytes;
+      if (bytes?.length) this.sftp.receive(bytes);
+    });
+    this.#session.addEventListener("error", (event) => {
+      this.#error = event.detail?.message || this.#error;
+    });
+    this.#session.addEventListener("close", (event) => {
+      this.sftp.fail(this.#error || event.detail?.message || "The SFTP connection closed.");
+    });
+  }
+  async connect(timeoutMs = 3e4) {
+    await new Promise((resolve, reject) => {
+      let settled = false;
+      const finish = (error) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        if (error) reject(error);
+        else resolve();
+      };
+      const timer = setTimeout(
+        () => finish(new Error(`The host did not open an SFTP channel within ${Math.round(timeoutMs / 1e3)}s.`)),
+        timeoutMs
+      );
+      this.#session.addEventListener("ready", () => finish());
+      this.#session.addEventListener("close", (event) => finish(
+        new Error(this.#error || event.detail?.message || "The SSH connection closed during sign-in.")
+      ));
+      this.#session.connect();
+    });
+    await this.sftp.handshake();
+  }
+  close() {
+    try {
+      this.#session.disconnect();
+    } catch {
+    }
+  }
+};
+async function pipeline(tasks) {
+  const running = /* @__PURE__ */ new Set();
+  let failure = null;
+  const start = (task) => {
+    const tracked = task().then(
+      () => {
+        running.delete(tracked);
+        return void 0;
+      },
+      (error) => {
+        running.delete(tracked);
+        failure ??= error instanceof Error ? error : new Error(String(error));
+        return void 0;
+      }
+    );
+    running.add(tracked);
+  };
+  for (const task of tasks) {
+    if (failure) break;
+    start(task);
+    while (running.size >= PIPELINE) await Promise.race(running);
+  }
+  while (running.size) await Promise.race(running);
+  if (failure) throw failure;
+}
+async function readExact(sftp, handle, offset, length) {
+  const parts = [];
+  let got = 0;
+  while (got < length) {
+    const piece = await sftp.read(handle, offset + got, length - got);
+    if (!piece?.length) break;
+    parts.push(piece);
+    got += piece.length;
+  }
+  if (parts.length === 1) return parts[0];
+  const joined = new Uint8Array(got);
+  let at = 0;
+  for (const part of parts) {
+    joined.set(part, at);
+    at += part.length;
+  }
+  return joined;
+}
+function chunkOffsets(size) {
+  const offsets = [];
+  for (let offset = 0; offset < size; offset += CHUNK) offsets.push(offset);
+  return offsets;
+}
+async function upload(sftp, localPath, remotePath, onProgress = () => {
+}) {
+  const info = await statFile(localPath);
+  const source = await openFile(localPath, "r");
+  const handle = await sftp.open(
+    remotePath,
+    OPEN_FLAGS.WRITE | OPEN_FLAGS.CREATE | OPEN_FLAGS.TRUNCATE,
+    info.mode & 511
+  );
+  let copied = 0;
+  try {
+    await pipeline(chunkOffsets(info.size).map((offset) => async () => {
+      const buffer = new Uint8Array(Math.min(CHUNK, info.size - offset));
+      let filled = 0;
+      while (filled < buffer.length) {
+        const { bytesRead } = await source.read(buffer, filled, buffer.length - filled, offset + filled);
+        if (!bytesRead) break;
+        filled += bytesRead;
+      }
+      await sftp.writeChunk(handle, offset, filled === buffer.length ? buffer : buffer.subarray(0, filled));
+      copied += filled;
+      onProgress(copied, info.size);
+    }));
+  } finally {
+    await source.close().catch(() => {
+    });
+    await sftp.close(handle).catch(() => {
+    });
+  }
+  return copied;
+}
+async function download(sftp, remotePath, localPath, onProgress = () => {
+}) {
+  const handle = await sftp.open(remotePath, OPEN_FLAGS.READ);
+  let copied = 0;
+  try {
+    const attrs = await sftp.fstat(handle);
+    const size = attrs.size;
+    const target = await openFile(localPath, "w");
+    try {
+      if (size === null) {
+        for (let offset = 0; ; ) {
+          const piece = await readExact(sftp, handle, offset, CHUNK);
+          if (!piece.length) break;
+          await target.write(piece, 0, piece.length, offset);
+          offset += piece.length;
+          copied += piece.length;
+          onProgress(copied, null);
+          if (piece.length < CHUNK) break;
+        }
+      } else {
+        await pipeline(chunkOffsets(size).map((offset) => async () => {
+          const piece = await readExact(sftp, handle, offset, Math.min(CHUNK, size - offset));
+          if (piece.length) await target.write(piece, 0, piece.length, offset);
+          copied += piece.length;
+          onProgress(copied, size);
+        }));
+      }
+      if (attrs.permissions !== null) await target.chmod(attrs.permissions & 511).catch(() => {
+      });
+    } finally {
+      await target.close().catch(() => {
+      });
+    }
+  } finally {
+    await sftp.close(handle).catch(() => {
+    });
+  }
+  return copied;
+}
+async function relay(from, fromPath, to, toPath, onProgress = () => {
+}) {
+  const source = await from.open(fromPath, OPEN_FLAGS.READ);
+  let copied = 0;
+  try {
+    const attrs = await from.fstat(source);
+    const target = await to.open(
+      toPath,
+      OPEN_FLAGS.WRITE | OPEN_FLAGS.CREATE | OPEN_FLAGS.TRUNCATE,
+      attrs.permissions === null ? null : attrs.permissions & 511
+    );
+    try {
+      if (attrs.size === null) {
+        for (let offset = 0; ; ) {
+          const piece = await readExact(from, source, offset, CHUNK);
+          if (!piece.length) break;
+          await to.writeChunk(target, offset, piece);
+          offset += piece.length;
+          copied += piece.length;
+          onProgress(copied, null);
+          if (piece.length < CHUNK) break;
+        }
+      } else {
+        const size = attrs.size;
+        await pipeline(chunkOffsets(size).map((offset) => async () => {
+          const piece = await readExact(from, source, offset, Math.min(CHUNK, size - offset));
+          if (piece.length) await to.writeChunk(target, offset, piece);
+          copied += piece.length;
+          onProgress(copied, size);
+        }));
+      }
+    } finally {
+      await to.close(target).catch(() => {
+      });
+    }
+  } finally {
+    await from.close(source).catch(() => {
+    });
+  }
+  return copied;
+}
+async function walkLocal(root, prefix = "") {
+  const found = [];
+  for (const entry of await readdir(root, { withFileTypes: true })) {
+    const here = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.isDirectory()) found.push(...await walkLocal(join(root, entry.name), here));
+    else if (entry.isFile()) found.push({ relative: here, size: (await statFile(join(root, entry.name))).size });
+  }
+  return found;
+}
+async function walkRemote(sftp, root, prefix = "") {
+  const found = [];
+  for (const entry of await sftp.readdir(root)) {
+    const here = prefix ? `${prefix}/${entry.name}` : entry.name;
+    if (entry.attrs.directory) found.push(...await walkRemote(sftp, `${root}/${entry.name}`, here));
+    else found.push({ relative: here, size: entry.attrs.size ?? 0 });
+  }
+  return found;
+}
+async function ensureRemoteDirs(sftp, root, files) {
+  const needed = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const parts = file.relative.split("/").slice(0, -1);
+    for (let depth = 1; depth <= parts.length; depth++) needed.add(parts.slice(0, depth).join("/"));
+  }
+  await sftp.mkdir(root);
+  for (const directory of [...needed].toSorted((a, b) => a.split("/").length - b.split("/").length)) {
+    await sftp.mkdir(`${root}/${directory}`);
+  }
+}
+async function ensureLocalDirs(root, files) {
+  await mkdir(root, { recursive: true });
+  const needed = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const parent = dirname(file.relative);
+    if (parent && parent !== ".") needed.add(parent);
+  }
+  for (const directory of needed) await mkdir(join(root, directory), { recursive: true });
+}
+async function localKind(path) {
+  try {
+    const info = await statFile(path);
+    return info.isDirectory() ? "directory" : "file";
+  } catch {
+    return "missing";
+  }
+}
+async function remoteKind(sftp, path) {
+  const attrs = await sftp.stat(path).catch((error) => {
+    if (error instanceof SftpError && error.missing) return null;
+    throw error;
+  });
+  if (!attrs) return "missing";
+  return attrs.directory ? "directory" : "file";
+}
+export {
+  SftpConnection,
+  destinationPath,
+  download,
+  ensureLocalDirs,
+  ensureRemoteDirs,
+  formatBytes,
+  formatRate,
+  localKind,
+  parseEndpoint,
+  basename as pathName,
+  relay,
+  remoteKind,
+  resolveLocal,
+  upload,
+  walkLocal,
+  walkRemote
+};