@qodalis/cli-scp 2.0.0-beta.1

package/public-api.js

@@ -0,0 +1,900 @@
+'use strict';
+
+var cliCore = require('@qodalis/cli-core');
+
+// src/lib/processors/cli-scp-command-processor.ts
+
+// src/lib/version.ts
+var LIBRARY_VERSION = "2.0.0-beta.1";
+var API_VERSION = 2;
+
+// src/lib/interfaces/index.ts
+var IScpTransferService_TOKEN = "scp-transfer-service";
+
+// src/lib/processors/scp-utils.ts
+function resolveServer(serverName, context) {
+  const servers = context.options?.servers;
+  if (!servers || servers.length === 0) {
+    context.writer.writeError("No servers configured. Add servers to CLI options.");
+    return null;
+  }
+  if (!serverName) {
+    if (servers.length === 1) {
+      return servers[0];
+    }
+    context.writer.writeError("Multiple servers configured. Specify server name.");
+    context.writer.writeInfo("Available: " + servers.map((s) => s.name).join(", "));
+    return null;
+  }
+  const server = servers.find((s) => s.name.toLowerCase() === serverName.toLowerCase());
+  if (!server) {
+    context.writer.writeError(`Unknown server: ${serverName}`);
+    context.writer.writeInfo("Available: " + servers.map((s) => s.name).join(", "));
+    return null;
+  }
+  return server;
+}
+function serverUrl(server) {
+  return server.url.replace(/\/+$/, "");
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+function parseServerAndPath(value, context, args) {
+  const serverArg = args?.["server"];
+  const pathArg = args?.["path"];
+  if (serverArg && pathArg) {
+    return [String(serverArg), String(pathArg)];
+  }
+  if (!value?.trim()) {
+    return null;
+  }
+  const parts = value.trim().split(/\s+/);
+  if (parts.length < 2) {
+    if (serverArg && parts.length >= 1) {
+      return [String(serverArg), parts.join(" ")];
+    }
+    if (pathArg && parts.length >= 1) {
+      return [parts[0], String(pathArg)];
+    }
+    return null;
+  }
+  return [parts[0], parts.slice(1).join(" ")];
+}
+
+// src/lib/processors/cli-scp-ls-processor.ts
+var CliScpLsProcessor = class {
+  constructor() {
+    this.command = "ls";
+    this.description = "List files and directories on a remote server";
+    this.acceptsRawInput = true;
+    this.valueRequired = true;
+    this.parameters = [
+      {
+        name: "server",
+        description: "Server name",
+        required: true,
+        type: "string"
+      },
+      {
+        name: "path",
+        description: "Remote directory path",
+        required: true,
+        type: "string"
+      }
+    ];
+  }
+  async processCommand(command, context) {
+    const parsed = parseServerAndPath(command.value, context, command.args);
+    if (!parsed) {
+      context.writer.writeError("Usage: scp ls <server> <path>");
+      return;
+    }
+    const [serverName, path] = parsed;
+    const server = resolveServer(serverName, context);
+    if (!server) return;
+    const transferService = context.services.get(
+      IScpTransferService_TOKEN
+    );
+    if (!transferService) {
+      context.writer.writeError("SCP transfer service not available.");
+      return;
+    }
+    context.spinner?.show(`Listing ${path} on ${server.name}...`);
+    try {
+      const entries = await transferService.ls(
+        serverUrl(server),
+        path,
+        server.headers
+      );
+      context.spinner?.hide();
+      if (entries.length === 0) {
+        context.writer.writeInfo(`Directory is empty: ${path}`);
+        return;
+      }
+      const headers = ["Name", "Type", "Size", "Modified"];
+      const rows = entries.map((entry) => [
+        entry.name,
+        entry.type,
+        entry.type === "file" ? formatBytes(entry.size) : "-",
+        entry.modified || "-"
+      ]);
+      context.writer.writeTable(headers, rows);
+      context.writer.writeInfo(`${entries.length} item(s)`);
+    } catch (err) {
+      context.spinner?.hide();
+      context.writer.writeError(err.message || "Failed to list directory");
+    }
+  }
+  writeDescription(context) {
+    context.writer.writeln("List files and directories on a remote server.");
+  }
+};
+
+// src/lib/processors/cli-scp-cat-processor.ts
+var CliScpCatProcessor = class {
+  constructor() {
+    this.command = "cat";
+    this.description = "Display contents of a remote file";
+    this.acceptsRawInput = true;
+    this.valueRequired = true;
+    this.parameters = [
+      {
+        name: "server",
+        description: "Server name",
+        required: true,
+        type: "string"
+      },
+      {
+        name: "path",
+        description: "Remote file path",
+        required: true,
+        type: "string"
+      }
+    ];
+  }
+  async processCommand(command, context) {
+    const parsed = parseServerAndPath(command.value, context, command.args);
+    if (!parsed) {
+      context.writer.writeError("Usage: scp cat <server> <path>");
+      return;
+    }
+    const [serverName, path] = parsed;
+    const server = resolveServer(serverName, context);
+    if (!server) return;
+    const transferService = context.services.get(
+      IScpTransferService_TOKEN
+    );
+    if (!transferService) {
+      context.writer.writeError("SCP transfer service not available.");
+      return;
+    }
+    context.spinner?.show(`Reading ${path} on ${server.name}...`);
+    try {
+      const content = await transferService.cat(
+        serverUrl(server),
+        path,
+        server.headers
+      );
+      context.spinner?.hide();
+      context.writer.writeln(content);
+    } catch (err) {
+      context.spinner?.hide();
+      context.writer.writeError(err.message || "Failed to read file");
+    }
+  }
+  writeDescription(context) {
+    context.writer.writeln("Display the contents of a remote file.");
+  }
+};
+var CliScpDownloadProcessor = class {
+  constructor() {
+    this.command = "download";
+    this.aliases = ["get"];
+    this.description = "Download a file from a remote server";
+    this.acceptsRawInput = true;
+    this.valueRequired = true;
+    this.parameters = [
+      {
+        name: "server",
+        description: "Server name",
+        required: false,
+        type: "string"
+      },
+      {
+        name: "remote-path",
+        aliases: ["path"],
+        description: "Remote file path",
+        required: false,
+        type: "string"
+      },
+      {
+        name: "local-path",
+        description: "Local destination path",
+        required: false,
+        type: "string"
+      },
+      {
+        name: "save",
+        description: "Save directly to browser downloads instead of virtual filesystem",
+        required: false,
+        type: "boolean"
+      }
+    ];
+  }
+  async processCommand(command, context) {
+    const args = command.args || {};
+    let serverName;
+    let remotePath;
+    let localPath;
+    if (args["server"] && (args["remote-path"] || args["path"])) {
+      serverName = String(args["server"]);
+      remotePath = String(args["remote-path"] || args["path"]);
+      localPath = args["local-path"] ? String(args["local-path"]) : void 0;
+    } else {
+      const value = command.value?.trim();
+      if (!value) {
+        context.writer.writeError("Usage: scp download <server> <remote-path> [local-path]");
+        return;
+      }
+      const parts = value.split(/\s+/);
+      if (parts.length < 2) {
+        context.writer.writeError("Usage: scp download <server> <remote-path> [local-path]");
+        return;
+      }
+      serverName = parts[0];
+      remotePath = parts[1];
+      localPath = parts[2];
+    }
+    if (!serverName || !remotePath) {
+      context.writer.writeError("Usage: scp download <server> <remote-path> [local-path]");
+      return;
+    }
+    localPath = localPath || remotePath.split("/").pop() || "download";
+    const server = resolveServer(serverName, context);
+    if (!server) return;
+    const transferService = context.services.get(
+      IScpTransferService_TOKEN
+    );
+    if (!transferService) {
+      context.writer.writeError("SCP transfer service not available.");
+      return;
+    }
+    const useBrowserDownload = command.args?.["save"] === true;
+    context.spinner?.show(`Downloading ${remotePath} from ${server.name}...`);
+    const abortController = new AbortController();
+    const abortSub = context.onAbort.subscribe(() => abortController.abort());
+    try {
+      let lastProgressUpdate = 0;
+      const { content, size } = await transferService.download(
+        serverUrl(server),
+        remotePath,
+        server.headers,
+        (received, total) => {
+          const now = Date.now();
+          if (now - lastProgressUpdate < 200) return;
+          lastProgressUpdate = now;
+          if (total > 0) {
+            const pct = Math.round(received / total * 100);
+            context.spinner?.show(
+              `Downloading ${remotePath}... ${pct}% (${formatBytes(received)}/${formatBytes(total)})`
+            );
+          } else {
+            context.spinner?.show(
+              `Downloading ${remotePath}... ${formatBytes(received)}`
+            );
+          }
+        },
+        abortController.signal
+      );
+      context.spinner?.hide();
+      if (useBrowserDownload) {
+        const fileService = context.services.get(
+          cliCore.ICliFileTransferService_TOKEN
+        );
+        if (fileService) {
+          fileService.downloadToBrowser(localPath, content);
+          context.writer.writeSuccess(
+            `Downloaded ${formatBytes(size)} to browser downloads as "${localPath}"`
+          );
+        } else {
+          context.writer.writeError("File transfer service not available for browser download.");
+        }
+      } else {
+        const fileService = context.services.get(
+          cliCore.ICliFileTransferService_TOKEN
+        );
+        if (fileService) {
+          await fileService.writeFile(localPath, content);
+          context.writer.writeSuccess(
+            `Downloaded ${formatBytes(size)} to "${localPath}"`
+          );
+        } else {
+          context.writer.writeError("File transfer service not available.");
+        }
+      }
+    } catch (err) {
+      context.spinner?.hide();
+      context.writer.writeError(err.message || "Download failed");
+    } finally {
+      abortSub.unsubscribe();
+    }
+  }
+  writeDescription(context) {
+    context.writer.writeln("Download a file from a remote server.");
+    context.writer.writeln("Usage: scp download <server> <remote-path> [local-path]");
+    context.writer.writeln("  --save  Save directly to browser downloads");
+  }
+};
+var CliScpUploadProcessor = class {
+  constructor() {
+    this.command = "upload";
+    this.aliases = ["put"];
+    this.description = "Upload a local file to a remote server";
+    this.acceptsRawInput = true;
+    this.valueRequired = true;
+    this.parameters = [
+      {
+        name: "server",
+        description: "Server name",
+        required: true,
+        type: "string"
+      },
+      {
+        name: "local-path",
+        description: "Local file path",
+        required: true,
+        type: "string"
+      },
+      {
+        name: "remote-path",
+        description: "Remote destination path",
+        required: true,
+        type: "string"
+      }
+    ];
+  }
+  async processCommand(command, context) {
+    const args = command.args || {};
+    let serverName;
+    let localPath;
+    let remotePath;
+    if (args["server"] && args["local-path"] && args["remote-path"]) {
+      serverName = String(args["server"]);
+      localPath = String(args["local-path"]);
+      remotePath = String(args["remote-path"]);
+    } else {
+      const value = command.value?.trim();
+      if (!value) {
+        context.writer.writeError("Usage: scp upload <server> <local-path> <remote-path>");
+        return;
+      }
+      const parts = value.split(/\s+/);
+      if (parts.length < 3) {
+        context.writer.writeError("Usage: scp upload <server> <local-path> <remote-path>");
+        return;
+      }
+      serverName = parts[0];
+      localPath = parts[1];
+      remotePath = parts[2];
+    }
+    if (!serverName || !localPath || !remotePath) {
+      context.writer.writeError("Usage: scp upload <server> <local-path> <remote-path>");
+      return;
+    }
+    const server = resolveServer(serverName, context);
+    if (!server) return;
+    const fileService = context.services.get(
+      cliCore.ICliFileTransferService_TOKEN
+    );
+    if (!fileService) {
+      context.writer.writeError("File transfer service not available.");
+      return;
+    }
+    const transferService = context.services.get(
+      IScpTransferService_TOKEN
+    );
+    if (!transferService) {
+      context.writer.writeError("SCP transfer service not available.");
+      return;
+    }
+    context.spinner?.show(`Reading local file "${localPath}"...`);
+    try {
+      const content = await fileService.readFile(localPath);
+      if (content === null) {
+        context.spinner?.hide();
+        context.writer.writeError(`Local file not found: ${localPath}`);
+        return;
+      }
+      const filename = localPath.split("/").pop() || "file";
+      context.spinner?.show(
+        `Uploading "${filename}" (${formatBytes(content.length)}) to ${server.name}:${remotePath}...`
+      );
+      await transferService.upload(
+        serverUrl(server),
+        remotePath,
+        content,
+        filename,
+        server.headers
+      );
+      context.spinner?.hide();
+      context.writer.writeSuccess(
+        `Uploaded "${filename}" (${formatBytes(content.length)}) to ${server.name}:${remotePath}`
+      );
+    } catch (err) {
+      context.spinner?.hide();
+      context.writer.writeError(err.message || "Upload failed");
+    }
+  }
+  writeDescription(context) {
+    context.writer.writeln("Upload a local file to a remote server.");
+    context.writer.writeln("Usage: scp upload <server> <local-path> <remote-path>");
+  }
+};
+
+// src/lib/processors/cli-scp-rm-processor.ts
+var CliScpRmProcessor = class {
+  constructor() {
+    this.command = "rm";
+    this.description = "Delete a file on a remote server";
+    this.acceptsRawInput = true;
+    this.valueRequired = true;
+    this.parameters = [
+      {
+        name: "server",
+        description: "Server name",
+        required: true,
+        type: "string"
+      },
+      {
+        name: "path",
+        description: "Remote file path to delete",
+        required: true,
+        type: "string"
+      }
+    ];
+  }
+  async processCommand(command, context) {
+    const parsed = parseServerAndPath(command.value, context, command.args);
+    if (!parsed) {
+      context.writer.writeError("Usage: scp rm <server> <path>");
+      return;
+    }
+    const [serverName, path] = parsed;
+    const server = resolveServer(serverName, context);
+    if (!server) return;
+    const transferService = context.services.get(
+      IScpTransferService_TOKEN
+    );
+    if (!transferService) {
+      context.writer.writeError("SCP transfer service not available.");
+      return;
+    }
+    context.spinner?.show(`Deleting ${path} on ${server.name}...`);
+    try {
+      await transferService.rm(
+        serverUrl(server),
+        path,
+        server.headers
+      );
+      context.spinner?.hide();
+      context.writer.writeSuccess(`Deleted: ${server.name}:${path}`);
+    } catch (err) {
+      context.spinner?.hide();
+      context.writer.writeError(err.message || "Failed to delete file");
+    }
+  }
+  writeDescription(context) {
+    context.writer.writeln("Delete a file on a remote server.");
+  }
+};
+
+// src/lib/processors/cli-scp-mkdir-processor.ts
+var CliScpMkdirProcessor = class {
+  constructor() {
+    this.command = "mkdir";
+    this.description = "Create a directory on a remote server";
+    this.acceptsRawInput = true;
+    this.valueRequired = true;
+    this.parameters = [
+      {
+        name: "server",
+        description: "Server name",
+        required: true,
+        type: "string"
+      },
+      {
+        name: "path",
+        description: "Remote directory path to create",
+        required: true,
+        type: "string"
+      }
+    ];
+  }
+  async processCommand(command, context) {
+    const parsed = parseServerAndPath(command.value, context, command.args);
+    if (!parsed) {
+      context.writer.writeError("Usage: scp mkdir <server> <path>");
+      return;
+    }
+    const [serverName, path] = parsed;
+    const server = resolveServer(serverName, context);
+    if (!server) return;
+    const transferService = context.services.get(
+      IScpTransferService_TOKEN
+    );
+    if (!transferService) {
+      context.writer.writeError("SCP transfer service not available.");
+      return;
+    }
+    context.spinner?.show(`Creating directory ${path} on ${server.name}...`);
+    try {
+      await transferService.mkdir(
+        serverUrl(server),
+        path,
+        server.headers
+      );
+      context.spinner?.hide();
+      context.writer.writeSuccess(`Created directory: ${server.name}:${path}`);
+    } catch (err) {
+      context.spinner?.hide();
+      context.writer.writeError(err.message || "Failed to create directory");
+    }
+  }
+  writeDescription(context) {
+    context.writer.writeln("Create a directory on a remote server.");
+  }
+};
+
+// src/lib/processors/cli-scp-stat-processor.ts
+var CliScpStatProcessor = class {
+  constructor() {
+    this.command = "stat";
+    this.description = "Show file or directory information on a remote server";
+    this.acceptsRawInput = true;
+    this.valueRequired = true;
+    this.parameters = [
+      {
+        name: "server",
+        description: "Server name",
+        required: true,
+        type: "string"
+      },
+      {
+        name: "path",
+        description: "Remote file or directory path",
+        required: true,
+        type: "string"
+      }
+    ];
+  }
+  async processCommand(command, context) {
+    const parsed = parseServerAndPath(command.value, context, command.args);
+    if (!parsed) {
+      context.writer.writeError("Usage: scp stat <server> <path>");
+      return;
+    }
+    const [serverName, path] = parsed;
+    const server = resolveServer(serverName, context);
+    if (!server) return;
+    const transferService = context.services.get(
+      IScpTransferService_TOKEN
+    );
+    if (!transferService) {
+      context.writer.writeError("SCP transfer service not available.");
+      return;
+    }
+    context.spinner?.show(`Getting info for ${path} on ${server.name}...`);
+    try {
+      const stat = await transferService.stat(
+        serverUrl(server),
+        path,
+        server.headers
+      );
+      context.spinner?.hide();
+      const entries = {
+        Name: stat.name,
+        Type: stat.type,
+        Size: formatBytes(stat.size),
+        Modified: stat.modified || "-",
+        Created: stat.created || "-"
+      };
+      if (stat.permissions) {
+        entries["Permissions"] = stat.permissions;
+      }
+      context.writer.writeKeyValue(entries);
+    } catch (err) {
+      context.spinner?.hide();
+      context.writer.writeError(err.message || "Failed to get file info");
+    }
+  }
+  writeDescription(context) {
+    context.writer.writeln("Show file or directory information on a remote server.");
+  }
+};
+
+// src/lib/processors/cli-scp-command-processor.ts
+var CliScpCommandCommandProcessor = class {
+  constructor() {
+    this.command = "scp";
+    this.description = "SCP-like file transfer between browser and remote servers";
+    this.author = cliCore.DefaultLibraryAuthor;
+    this.version = LIBRARY_VERSION;
+    this.acceptsRawInput = true;
+    this.processors = [
+      new CliScpLsProcessor(),
+      new CliScpCatProcessor(),
+      new CliScpDownloadProcessor(),
+      new CliScpUploadProcessor(),
+      new CliScpRmProcessor(),
+      new CliScpMkdirProcessor(),
+      new CliScpStatProcessor()
+    ];
+  }
+  async processCommand(command, context) {
+    const value = command.value?.trim();
+    if (value && value.includes(":") && !value.startsWith("-")) {
+      const colonIdx = value.indexOf(":");
+      const spaceBeforeColon = value.lastIndexOf(" ", colonIdx);
+      if (spaceBeforeColon === -1) {
+        const serverName = value.substring(0, colonIdx);
+        const rest = value.substring(colonIdx + 1);
+        const parts2 = rest.trim().split(/\s+/);
+        const remotePath = parts2[0];
+        const localPath = parts2[1] || remotePath.split("/").pop() || "download";
+        if (remotePath) {
+          await this.doDownload(serverName, remotePath, localPath, command, context);
+          return;
+        }
+      }
+      const parts = value.split(/\s+/);
+      if (parts.length >= 2) {
+        const secondPart = parts[1];
+        if (secondPart.includes(":")) {
+          const localPath = parts[0];
+          const srvColonIdx = secondPart.indexOf(":");
+          const serverName = secondPart.substring(0, srvColonIdx);
+          const remotePath = secondPart.substring(srvColonIdx + 1);
+          if (remotePath) {
+            await this.doUpload(serverName, localPath, remotePath, context);
+            return;
+          }
+        }
+      }
+    }
+    context.executor.showHelp(command, context);
+  }
+  writeDescription(context) {
+    context.writer.writeln(this.description);
+  }
+  async doDownload(serverName, remotePath, localPath, command, context) {
+    const server = resolveServer(serverName, context);
+    if (!server) return;
+    const transferService = context.services.get(
+      IScpTransferService_TOKEN
+    );
+    if (!transferService) {
+      context.writer.writeError("SCP transfer service not available.");
+      return;
+    }
+    const useBrowserDownload = command.args?.["save"] === true;
+    context.spinner?.show(`Downloading ${remotePath} from ${server.name}...`);
+    try {
+      let lastProgressUpdate = 0;
+      const { content, size } = await transferService.download(
+        serverUrl(server),
+        remotePath,
+        server.headers,
+        (received, total) => {
+          const now = Date.now();
+          if (now - lastProgressUpdate < 200) return;
+          lastProgressUpdate = now;
+          if (total > 0) {
+            const pct = Math.round(received / total * 100);
+            context.spinner?.show(
+              `Downloading ${remotePath}... ${pct}% (${formatBytes(received)}/${formatBytes(total)})`
+            );
+          } else {
+            context.spinner?.show(
+              `Downloading ${remotePath}... ${formatBytes(received)}`
+            );
+          }
+        }
+      );
+      context.spinner?.hide();
+      const fileService = context.services.get(
+        cliCore.ICliFileTransferService_TOKEN
+      );
+      if (!fileService) {
+        context.writer.writeError("File transfer service not available.");
+        return;
+      }
+      if (useBrowserDownload) {
+        fileService.downloadToBrowser(localPath, content);
+        context.writer.writeSuccess(
+          `Downloaded ${formatBytes(size)} to browser downloads as "${localPath}"`
+        );
+      } else {
+        await fileService.writeFile(localPath, content);
+        context.writer.writeSuccess(
+          `Downloaded ${formatBytes(size)} to "${localPath}"`
+        );
+      }
+    } catch (err) {
+      context.spinner?.hide();
+      context.writer.writeError(err.message || "Download failed");
+    }
+  }
+  async doUpload(serverName, localPath, remotePath, context) {
+    const server = resolveServer(serverName, context);
+    if (!server) return;
+    const fileService = context.services.get(
+      cliCore.ICliFileTransferService_TOKEN
+    );
+    if (!fileService) {
+      context.writer.writeError("File transfer service not available.");
+      return;
+    }
+    const transferService = context.services.get(
+      IScpTransferService_TOKEN
+    );
+    if (!transferService) {
+      context.writer.writeError("SCP transfer service not available.");
+      return;
+    }
+    context.spinner?.show(`Reading local file "${localPath}"...`);
+    try {
+      const content = await fileService.readFile(localPath);
+      if (content === null) {
+        context.spinner?.hide();
+        context.writer.writeError(`Local file not found: ${localPath}`);
+        return;
+      }
+      const filename = localPath.split("/").pop() || "file";
+      context.spinner?.show(
+        `Uploading "${filename}" (${formatBytes(content.length)}) to ${server.name}:${remotePath}...`
+      );
+      await transferService.upload(
+        serverUrl(server),
+        remotePath,
+        content,
+        filename,
+        server.headers
+      );
+      context.spinner?.hide();
+      context.writer.writeSuccess(
+        `Uploaded "${filename}" (${formatBytes(content.length)}) to ${server.name}:${remotePath}`
+      );
+    } catch (err) {
+      context.spinner?.hide();
+      context.writer.writeError(err.message || "Upload failed");
+    }
+  }
+};
+
+// src/lib/services/scp-transfer.service.ts
+var ScpTransferService = class {
+  async ls(serverUrl2, path, headers) {
+    const res = await this._fetch(`${serverUrl2}/api/cli/fs/ls?path=${encodeURIComponent(path)}`, {
+      headers
+    });
+    const data = await res.json();
+    return data.entries;
+  }
+  async cat(serverUrl2, path, headers) {
+    const res = await this._fetch(`${serverUrl2}/api/cli/fs/cat?path=${encodeURIComponent(path)}`, {
+      headers
+    });
+    const data = await res.json();
+    return data.content;
+  }
+  async stat(serverUrl2, path, headers) {
+    const res = await this._fetch(`${serverUrl2}/api/cli/fs/stat?path=${encodeURIComponent(path)}`, {
+      headers
+    });
+    return await res.json();
+  }
+  async download(serverUrl2, path, headers, onProgress, signal) {
+    const res = await this._fetch(`${serverUrl2}/api/cli/fs/download?path=${encodeURIComponent(path)}`, {
+      headers,
+      signal
+    });
+    const contentLength = parseInt(res.headers.get("content-length") || "0", 10);
+    const reader = res.body?.getReader();
+    if (!reader) {
+      const text = await res.text();
+      return { content: text, size: text.length };
+    }
+    const chunks = [];
+    let receivedBytes = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+      receivedBytes += value.length;
+      onProgress?.(receivedBytes, contentLength);
+    }
+    const combined = new Uint8Array(receivedBytes);
+    let offset = 0;
+    for (const chunk of chunks) {
+      combined.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return {
+      content: new TextDecoder().decode(combined),
+      size: receivedBytes
+    };
+  }
+  async upload(serverUrl2, remotePath, content, filename, headers) {
+    const formData = new FormData();
+    formData.append("path", remotePath);
+    formData.append("file", new Blob([content]), filename);
+    await this._fetch(`${serverUrl2}/api/cli/fs/upload`, {
+      method: "POST",
+      body: formData,
+      headers
+    });
+  }
+  async mkdir(serverUrl2, path, headers) {
+    await this._fetch(`${serverUrl2}/api/cli/fs/mkdir`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...headers },
+      body: JSON.stringify({ path })
+    });
+  }
+  async rm(serverUrl2, path, headers) {
+    await this._fetch(`${serverUrl2}/api/cli/fs/rm?path=${encodeURIComponent(path)}`, {
+      method: "DELETE",
+      headers
+    });
+  }
+  async _fetch(url, init) {
+    const res = await fetch(url, init);
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      if (res.status === 403) {
+        throw new Error(`Permission denied: ${body || "path is not in server's allowed paths"}`);
+      }
+      if (res.status === 404) {
+        throw new Error(`Not found: ${body || "file or directory does not exist"}`);
+      }
+      throw new Error(`Server error (${res.status}): ${body || res.statusText}`);
+    }
+    return res;
+  }
+};
+
+// src/public-api.ts
+var scpModule = {
+  apiVersion: API_VERSION,
+  name: "@qodalis/cli-scp",
+  processors: [new CliScpCommandCommandProcessor()],
+  services: [
+    {
+      provide: IScpTransferService_TOKEN,
+      useValue: new ScpTransferService()
+    }
+  ],
+  translations: {
+    es: { "cli.scp.description": "Transferencia de archivos tipo SCP" },
+    fr: { "cli.scp.description": "Transfert de fichiers de type SCP" },
+    de: { "cli.scp.description": "SCP-\xE4hnliche Datei\xFCbertragung" },
+    pt: { "cli.scp.description": "Transfer\xEAncia de arquivos tipo SCP" },
+    it: { "cli.scp.description": "Trasferimento file di tipo SCP" },
+    ja: { "cli.scp.description": "SCP\u98A8\u30D5\u30A1\u30A4\u30EB\u8EE2\u9001" },
+    ko: { "cli.scp.description": "SCP \uBC29\uC2DD \uD30C\uC77C \uC804\uC1A1" },
+    zh: { "cli.scp.description": "SCP \u98CE\u683C\u6587\u4EF6\u4F20\u8F93" },
+    ru: { "cli.scp.description": "\u041F\u0435\u0440\u0435\u0434\u0430\u0447\u0430 \u0444\u0430\u0439\u043B\u043E\u0432 \u0432 \u0441\u0442\u0438\u043B\u0435 SCP" },
+    ro: { "cli.scp.description": "Transfer de fi\u0219iere de tip SCP" }
+  }
+};
+
+exports.API_VERSION = API_VERSION;
+exports.CliScpCommandCommandProcessor = CliScpCommandCommandProcessor;
+exports.LIBRARY_VERSION = LIBRARY_VERSION;
+exports.scpModule = scpModule;
+//# sourceMappingURL=public-api.js.map
+//# sourceMappingURL=public-api.js.map