raycast-rsync-extension 1.0.1

package/src/download.tsx

@@ -0,0 +1,353 @@
+import {
+  List,
+  ActionPanel,
+  Action,
+  Form,
+  showToast,
+  Toast,
+  popToRoot,
+} from "@raycast/api";
+import React, { useState, useEffect } from "react";
+import { parseSSHConfig } from "./utils/sshConfig";
+import { executeRsync } from "./utils/rsync";
+import { validateRemotePath, validateHostConfig } from "./utils/validation";
+import {
+  SSHHostConfig,
+  TransferDirection,
+  TransferOptions,
+  RsyncOptions,
+} from "./types/server";
+import { getRsyncPreferences } from "./utils/preferences";
+
+/**
+ * Main download command component
+ * Displays list of SSH hosts from config file
+ */
+export default function Command() {
+  const [hosts, setHosts] = useState<SSHHostConfig[]>([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    loadHosts();
+  }, []);
+
+  async function loadHosts() {
+    try {
+      const parsedHosts = parseSSHConfig();
+
+      if (parsedHosts.length === 0) {
+        const errorMsg = "No host entries found in SSH config file";
+        setError(errorMsg);
+        console.warn("SSH config parsed but no hosts found");
+      } else {
+        setHosts(parsedHosts);
+        console.log(`Loaded ${parsedHosts.length} SSH host(s)`);
+      }
+    } catch (err) {
+      const errorMessage =
+        err instanceof Error ? err.message : "Failed to parse SSH config";
+      console.error("Error loading SSH hosts:", err);
+      setError(errorMessage);
+      await showToast({
+        style: Toast.Style.Failure,
+        title: "Error Loading SSH Config",
+        message: errorMessage,
+      });
+    } finally {
+      setIsLoading(false);
+    }
+  }
+
+  if (error) {
+    return (
+      <List>
+        <List.EmptyView title="Error Loading SSH Config" description={error} />
+      </List>
+    );
+  }
+
+  return (
+    <List isLoading={isLoading} searchBarPlaceholder="Search hosts...">
+      {hosts.map((host: SSHHostConfig) => (
+        <List.Item
+          key={host.host}
+          title={host.host}
+          subtitle={host.hostName}
+          accessories={[
+            { text: host.user ? `User: ${host.user}` : "" },
+            { text: host.port ? `Port: ${host.port}` : "" },
+          ]}
+          actions={
+            <ActionPanel>
+              <Action.Push
+                title="Enter Remote Path"
+                target={<RemotePathForm hostConfig={host} />}
+              />
+            </ActionPanel>
+          }
+        />
+      ))}
+    </List>
+  );
+}
+
+/**
+ * Remote path input form
+ * Allows user to specify source path on remote server
+ */
+function RemotePathForm({ hostConfig }: { hostConfig: SSHHostConfig }) {
+  const [remotePath, setRemotePath] = useState<string>("");
+  const [remotePathError, setRemotePathError] = useState<string | undefined>();
+
+  return (
+    <Form
+      actions={
+        <ActionPanel>
+          <Action.Push
+            title="Continue"
+            target={
+              <LocalPathForm hostConfig={hostConfig} remotePath={remotePath} />
+            }
+          />
+        </ActionPanel>
+      }
+    >
+      <Form.TextField
+        id="remotePath"
+        title="Remote Path"
+        placeholder="/path/to/remote/file"
+        value={remotePath}
+        onChange={(value: string) => {
+          setRemotePath(value);
+          setRemotePathError(undefined);
+        }}
+        error={remotePathError}
+        info="Enter the path to the file or directory on the remote server"
+      />
+      <Form.Description
+        title="Host Details"
+        text={`Downloading from: ${hostConfig.host}${hostConfig.hostName ? ` (${hostConfig.hostName})` : ""}`}
+      />
+      {hostConfig.user && (
+        <Form.Description title="User" text={hostConfig.user} />
+      )}
+      {hostConfig.port && (
+        <Form.Description title="Port" text={hostConfig.port.toString()} />
+      )}
+      {hostConfig.identityFile && (
+        <Form.Description
+          title="Identity File"
+          text={hostConfig.identityFile}
+        />
+      )}
+    </Form>
+  );
+}
+
+/**
+ * Local destination path form
+ * Allows user to specify destination directory on local system
+ */
+function LocalPathForm({
+  hostConfig,
+  remotePath,
+}: {
+  hostConfig: SSHHostConfig;
+  remotePath: string;
+}) {
+  const [localPath, setLocalPath] = useState<string>("");
+  const [localPathError, setLocalPathError] = useState<string | undefined>();
+
+  // Initialize rsync options with global preferences
+  const defaultRsyncOptions = getRsyncPreferences();
+  const [humanReadable, setHumanReadable] = useState<boolean>(
+    defaultRsyncOptions.humanReadable ?? false,
+  );
+  const [progress, setProgress] = useState<boolean>(
+    defaultRsyncOptions.progress ?? false,
+  );
+  const [deleteExtra, setDeleteExtra] = useState<boolean>(
+    defaultRsyncOptions.delete ?? false,
+  );
+
+  async function handleSubmit(values: {
+    localPath: string;
+    humanReadable: boolean;
+    progress: boolean;
+    deleteExtra: boolean;
+  }) {
+    const localPathValue = values.localPath.trim();
+
+    if (!localPathValue) {
+      console.error("Local path is empty");
+      setLocalPathError("Local path is required");
+      await showToast({
+        style: Toast.Style.Failure,
+        title: "Invalid Local Path",
+        message: "Please enter a destination path for the downloaded files",
+      });
+      return;
+    }
+
+    // Validate remote path
+    const remoteValidation = validateRemotePath(remotePath);
+    if (!remoteValidation.valid) {
+      console.error("Remote path validation failed:", remoteValidation.error);
+      await showToast({
+        style: Toast.Style.Failure,
+        title: "Invalid Remote Path",
+        message: remoteValidation.error || "The remote path format is invalid",
+      });
+      return;
+    }
+
+    // Validate host config
+    const hostValidation = validateHostConfig(hostConfig);
+    if (!hostValidation.valid) {
+      console.error("Host config validation failed:", hostValidation.error);
+      await showToast({
+        style: Toast.Style.Failure,
+        title: "Invalid Host Configuration",
+        message:
+          hostValidation.error ||
+          "The host configuration is incomplete or invalid",
+      });
+      return;
+    }
+
+    // Execute transfer using form values
+    await executeTransfer(hostConfig, remotePath, localPathValue, {
+      humanReadable: values.humanReadable,
+      progress: values.progress,
+      delete: values.deleteExtra,
+    });
+  }
+
+  async function executeTransfer(
+    hostConfig: SSHHostConfig,
+    remotePath: string,
+    localPath: string,
+    rsyncOptions: RsyncOptions,
+  ) {
+    // Show initial progress toast
+    await showToast({
+      style: Toast.Style.Animated,
+      title: "Transferring files...",
+      message: `Downloading from ${hostConfig.host}`,
+    });
+
+    console.log("Starting download:", {
+      host: hostConfig.host,
+      remotePath,
+      localPath,
+    });
+
+    try {
+      const options: TransferOptions = {
+        hostConfig,
+        localPath,
+        remotePath,
+        direction: TransferDirection.DOWNLOAD,
+        rsyncOptions,
+      };
+
+      // Progress callback to update toast in real-time
+      const progressCallback = async (progressMessage: string) => {
+        await showToast({
+          style: Toast.Style.Animated,
+          title: "Transferring files...",
+          message: progressMessage,
+        });
+      };
+
+      const result = await executeRsync(options, progressCallback);
+
+      if (result.success) {
+        console.log("Download completed successfully");
+        // Show formatted rsync output message (includes file sizes and progress if flags enabled)
+        await showToast({
+          style: Toast.Style.Success,
+          title: "Download Successful",
+          message: result.message,
+        });
+        // Log full output for debugging
+        if (result.stdout) {
+          console.log("Rsync output:", result.stdout);
+        }
+        // Close the extension after successful download
+        await popToRoot();
+      } else {
+        console.error("Download failed:", result.message);
+        await showToast({
+          style: Toast.Style.Failure,
+          title: "Download Failed",
+          message: result.message,
+        });
+      }
+    } catch (err) {
+      const errorMessage =
+        err instanceof Error ? err.message : "Unknown error occurred";
+      console.error("Download error:", err);
+      await showToast({
+        style: Toast.Style.Failure,
+        title: "Download Failed",
+        message: errorMessage,
+      });
+    }
+  }
+
+  return (
+    <Form
+      actions={
+        <ActionPanel>
+          <Action.SubmitForm title="Download" onSubmit={handleSubmit} />
+        </ActionPanel>
+      }
+    >
+      <Form.TextField
+        id="localPath"
+        title="Local Destination Path"
+        placeholder="/path/to/local/destination"
+        value={localPath}
+        onChange={(value: string) => {
+          setLocalPath(value);
+          setLocalPathError(undefined);
+        }}
+        error={localPathError}
+        info="Enter the destination directory on your local system"
+      />
+      <Form.Description title="Remote Path" text={remotePath} />
+      <Form.Description
+        title="Host"
+        text={`${hostConfig.host}${hostConfig.hostName ? ` (${hostConfig.hostName})` : ""}`}
+      />
+      <Form.Separator />
+      <Form.Description
+        title="Rsync Options"
+        text="Configure options for this transfer"
+      />
+      <Form.Checkbox
+        id="humanReadable"
+        label="Human-readable file sizes (-h)"
+        value={humanReadable}
+        onChange={setHumanReadable}
+        info="Display file sizes in human-readable format (e.g., 1.5M, 500K)"
+      />
+      <Form.Checkbox
+        id="progress"
+        label="Show progress (-P)"
+        value={progress}
+        onChange={setProgress}
+        info="Display progress information and support partial transfers"
+      />
+      <Form.Checkbox
+        id="deleteExtra"
+        label="Delete extraneous files (--delete)"
+        value={deleteExtra}
+        onChange={setDeleteExtra}
+        info="Delete files in destination that don't exist in source (use with caution)"
+      />
+    </Form>
+  );
+}

package/src/e2e/browse.e2e.test.ts

@@ -0,0 +1,295 @@
+import { describe, it, expect } from "vitest";
+import { validateRemotePath, validateHostConfig } from "../utils/validation";
+import { SSHHostConfig } from "../types/server";
+
+describe("Browse E2E Flow", () => {
+  const mockHostConfig: SSHHostConfig = {
+    host: "browseserver",
+    hostName: "browse.example.com",
+    user: "browseuser",
+    port: 22,
+    identityFile: "~/.ssh/browse_key",
+  };
+
+  it("should complete full browse workflow with valid inputs", () => {
+    // Step 1: Validate remote path (home directory)
+    const remotePath = "~";
+    const remoteValidation = validateRemotePath(remotePath);
+    expect(remoteValidation.valid).toBe(true);
+    expect(remoteValidation.error).toBeUndefined();
+
+    // Step 2: Validate host config
+    const hostValidation = validateHostConfig(mockHostConfig);
+    expect(hostValidation.valid).toBe(true);
+    expect(hostValidation.error).toBeUndefined();
+
+    // Step 3: Verify path construction for navigation
+    const subdirectory = "documents";
+    const constructedPath = remotePath.endsWith("/")
+      ? `${remotePath}${subdirectory}`
+      : `${remotePath}/${subdirectory}`;
+    expect(constructedPath).toBe("~/documents");
+  });
+
+  it("should handle absolute remote path", () => {
+    const remotePath = "/home/user/documents";
+    const remoteValidation = validateRemotePath(remotePath);
+    expect(remoteValidation.valid).toBe(true);
+    expect(remoteValidation.error).toBeUndefined();
+
+    const hostValidation = validateHostConfig(mockHostConfig);
+    expect(hostValidation.valid).toBe(true);
+  });
+
+  it("should handle relative remote path", () => {
+    const remotePath = "documents/files";
+    const remoteValidation = validateRemotePath(remotePath);
+    expect(remoteValidation.valid).toBe(true);
+    expect(remoteValidation.error).toBeUndefined();
+  });
+
+  it("should handle empty remote path (defaults to ~)", () => {
+    // In the browse form, empty path defaults to "~"
+    const remotePath = "";
+    const remotePathValue = remotePath.trim() || "~";
+    expect(remotePathValue).toBe("~");
+
+    const remoteValidation = validateRemotePath(remotePathValue);
+    expect(remoteValidation.valid).toBe(true);
+  });
+
+  it("should construct paths correctly for directory navigation", () => {
+    const testCases = [
+      { current: "~", subdir: "documents", expected: "~/documents" },
+      {
+        current: "/home/user",
+        subdir: "documents",
+        expected: "/home/user/documents",
+      },
+      {
+        current: "/home/user/",
+        subdir: "documents",
+        expected: "/home/user/documents",
+      },
+      {
+        current: "~/projects",
+        subdir: "my-project",
+        expected: "~/projects/my-project",
+      },
+      { current: "/var/www", subdir: "html", expected: "/var/www/html" },
+    ];
+
+    testCases.forEach(({ current, subdir, expected }) => {
+      const constructedPath = current.endsWith("/")
+        ? `${current}${subdir}`
+        : `${current}/${subdir}`;
+      expect(constructedPath).toBe(expected);
+    });
+  });
+
+  it("should handle invalid remote path in browse workflow", () => {
+    // Try to validate invalid remote path (empty without default)
+    const remoteValidation = validateRemotePath("");
+
+    // Should fail validation
+    expect(remoteValidation.valid).toBe(false);
+    expect(remoteValidation.error).toBeDefined();
+    expect(remoteValidation.error).toContain("cannot be empty");
+  });
+
+  it("should handle invalid remote path with control characters", () => {
+    const invalidPath = "/remote/path\x00/directory";
+    const remoteValidation = validateRemotePath(invalidPath);
+
+    // Should fail validation
+    expect(remoteValidation.valid).toBe(false);
+    expect(remoteValidation.error).toBeDefined();
+    expect(remoteValidation.error).toContain("control characters");
+  });
+
+  it("should validate all inputs before allowing browse", () => {
+    const browseHost: SSHHostConfig = {
+      host: "browseserver",
+      hostName: "browse.example.com",
+      user: "browseuser",
+    };
+
+    // All validations should pass
+    const remoteValidation = validateRemotePath("~");
+    const hostValidation = validateHostConfig(browseHost);
+
+    expect(remoteValidation.valid).toBe(true);
+    expect(hostValidation.valid).toBe(true);
+  });
+
+  it("should handle host without optional properties", () => {
+    const minimalHost: SSHHostConfig = {
+      host: "minimal-server",
+      hostName: "minimal.example.com",
+    };
+
+    // Should validate successfully even without user, port, and identityFile
+    const hostValidation = validateHostConfig(minimalHost);
+    expect(hostValidation.valid).toBe(true);
+  });
+
+  it("should handle various remote path formats for browsing", () => {
+    const validPaths = [
+      "/absolute/path/directory",
+      "relative/path/directory",
+      "/path/with spaces/directory",
+      "/path/with-dashes/directory",
+      "/path/with_underscores/directory",
+      "/path/with.dots/directory",
+      "~/home/path/directory",
+      "~",
+    ];
+
+    validPaths.forEach((remotePath) => {
+      const validation = validateRemotePath(remotePath);
+      expect(validation.valid).toBe(true);
+    });
+  });
+
+  it("should handle path construction for nested directories", () => {
+    // Simulate navigating through multiple directory levels
+    let currentPath = "~";
+    const directories = ["documents", "projects", "my-app"];
+
+    directories.forEach((dir) => {
+      currentPath = currentPath.endsWith("/")
+        ? `${currentPath}${dir}`
+        : `${currentPath}/${dir}`;
+    });
+
+    expect(currentPath).toBe("~/documents/projects/my-app");
+  });
+
+  it("should handle path construction with trailing slashes", () => {
+    const pathsWithTrailingSlash = [
+      {
+        path: "/home/user/",
+        subdir: "documents",
+        expected: "/home/user/documents",
+      },
+      { path: "~/", subdir: "projects", expected: "~/projects" },
+      { path: "/var/www/", subdir: "html", expected: "/var/www/html" },
+    ];
+
+    pathsWithTrailingSlash.forEach(({ path, subdir, expected }) => {
+      const constructedPath = path.endsWith("/")
+        ? `${path}${subdir}`
+        : `${path}/${subdir}`;
+      expect(constructedPath).toBe(expected);
+    });
+  });
+
+  it("should validate host config with invalid port", () => {
+    const invalidHost: SSHHostConfig = {
+      host: "browseserver",
+      hostName: "browse.example.com",
+      port: 99999, // Invalid port
+    };
+
+    const hostValidation = validateHostConfig(invalidHost);
+    expect(hostValidation.valid).toBe(false);
+    expect(hostValidation.error).toBeDefined();
+    expect(hostValidation.error).toContain("must be between 1 and 65535");
+  });
+
+  it("should handle missing hostname in host config", () => {
+    const hostWithoutHostname: SSHHostConfig = {
+      host: "browseserver",
+      // hostName is optional, so this should still be valid
+    };
+
+    const hostValidation = validateHostConfig(hostWithoutHostname);
+    // Hostname is optional, so validation should pass
+    expect(hostValidation.valid).toBe(true);
+  });
+
+  describe("Remote file listing workflow", () => {
+    it("should handle path validation before listing", () => {
+      const remotePath = "/home/user/documents";
+      const remoteValidation = validateRemotePath(remotePath);
+      expect(remoteValidation.valid).toBe(true);
+
+      const hostValidation = validateHostConfig(mockHostConfig);
+      expect(hostValidation.valid).toBe(true);
+
+      // Both validations must pass before attempting to list files
+      expect(remoteValidation.valid && hostValidation.valid).toBe(true);
+    });
+
+    it("should handle home directory path", () => {
+      const remotePath = "~";
+      const remoteValidation = validateRemotePath(remotePath);
+      expect(remoteValidation.valid).toBe(true);
+    });
+
+    it("should construct correct paths for file operations", () => {
+      const basePath = "/home/user";
+      const fileName = "document.txt";
+      const filePath = basePath.endsWith("/")
+        ? `${basePath}${fileName}`
+        : `${basePath}/${fileName}`;
+      expect(filePath).toBe("/home/user/document.txt");
+    });
+
+    it("should construct correct paths for directory operations", () => {
+      const basePath = "/home/user";
+      const dirName = "documents";
+      const dirPath = basePath.endsWith("/")
+        ? `${basePath}${dirName}`
+        : `${basePath}/${dirName}`;
+      expect(dirPath).toBe("/home/user/documents");
+    });
+  });
+
+  describe("Error handling in browse workflow", () => {
+    it("should reject empty remote path", () => {
+      const remoteValidation = validateRemotePath("");
+      expect(remoteValidation.valid).toBe(false);
+      expect(remoteValidation.error).toBeDefined();
+    });
+
+    it("should reject remote path with only whitespace", () => {
+      const remoteValidation = validateRemotePath("   ");
+      expect(remoteValidation.valid).toBe(false);
+      expect(remoteValidation.error).toBeDefined();
+    });
+
+    it("should handle invalid host configuration", () => {
+      const invalidHost: SSHHostConfig = {
+        host: "", // Empty host should fail
+        hostName: "example.com",
+      };
+
+      const hostValidation = validateHostConfig(invalidHost);
+      expect(hostValidation.valid).toBe(false);
+    });
+  });
+
+  describe("Path normalization", () => {
+    it("should handle paths with multiple slashes", () => {
+      // In real usage, paths might have multiple slashes that need normalization
+      const remotePath = "/home//user///documents";
+      const remoteValidation = validateRemotePath(remotePath);
+      // Validation should pass (normalization happens at SSH level)
+      expect(remoteValidation.valid).toBe(true);
+    });
+
+    it("should handle paths with dots", () => {
+      const pathsWithDots = [
+        "/home/user/./documents",
+        "/home/user/../documents",
+        "/home/user/././documents",
+      ];
+
+      pathsWithDots.forEach((path) => {
+        const validation = validateRemotePath(path);
+        expect(validation.valid).toBe(true);
+      });
+    });
+  });
+});