raycast-rsync-extension 1.0.1

package/src/e2e/rsync-options.e2e.test.ts

@@ -0,0 +1,348 @@
+import { describe, it, expect } from "vitest";
+import { buildRsyncCommand } from "../utils/rsync";
+import {
+  TransferOptions,
+  TransferDirection,
+  SSHHostConfig,
+} from "../types/server";
+import { homedir } from "os";
+import { join } from "path";
+
+describe("Rsync Options E2E", () => {
+  const mockHostConfig: SSHHostConfig = {
+    host: "testserver",
+    hostName: "test.example.com",
+    user: "testuser",
+    port: 22,
+  };
+
+  const configPath = join(homedir(), ".ssh", "config");
+
+  describe("Rsync flags and options", () => {
+    it("should include base flags (-avz) by default", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/path",
+        remotePath: "/remote/path",
+        direction: TransferDirection.UPLOAD,
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Base flags are combined into -avz
+      expect(command).toContain("-avz");
+      // Verify individual flags are present in the combined string
+      expect(command).toMatch(/-[avz]+/);
+      // Command now uses single quotes for escaping
+      const flagsMatch = command.match(/rsync -e '[^']+' (-[^ ]+)/);
+      expect(flagsMatch).not.toBeNull();
+      const flags = flagsMatch![1];
+      expect(flags).toContain("a"); // archive
+      expect(flags).toContain("v"); // verbose
+      expect(flags).toContain("z"); // compress
+    });
+
+    it("should include human-readable flag when enabled", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/path",
+        remotePath: "/remote/path",
+        direction: TransferDirection.UPLOAD,
+        rsyncOptions: {
+          humanReadable: true,
+        },
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Flag should be included in the combined flags string (e.g., -avzh)
+      expect(command).toMatch(/-[avz]+h/);
+    });
+
+    it("should include progress flag when enabled", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/path",
+        remotePath: "/remote/path",
+        direction: TransferDirection.UPLOAD,
+        rsyncOptions: {
+          progress: true,
+        },
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Flag should be included in the combined flags string (e.g., -avzP)
+      expect(command).toMatch(/-[avz]+P/);
+    });
+
+    it("should include delete flag when enabled", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/path",
+        remotePath: "/remote/path",
+        direction: TransferDirection.UPLOAD,
+        rsyncOptions: {
+          delete: true,
+        },
+      };
+
+      const command = buildRsyncCommand(options);
+
+      expect(command).toContain("--delete");
+    });
+
+    it("should include all optional flags when all enabled", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/path",
+        remotePath: "/remote/path",
+        direction: TransferDirection.DOWNLOAD,
+        rsyncOptions: {
+          humanReadable: true,
+          progress: true,
+          delete: true,
+        },
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Combined short flags should include h and P (e.g., -avzhP)
+      expect(command).toMatch(/-[avz]+hP/);
+      expect(command).toContain("--delete");
+      // Base flags should be present
+      expect(command).toMatch(/-[avz]+/);
+    });
+
+    it("should not include optional flags when disabled", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/path",
+        remotePath: "/remote/path",
+        direction: TransferDirection.UPLOAD,
+        rsyncOptions: {
+          humanReadable: false,
+          progress: false,
+          delete: false,
+        },
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Extract the flags part (between -e and paths)
+      // Command now uses single quotes for escaping
+      const flagsMatch = command.match(/rsync -e '[^']+' (-[^ ]+)/);
+      expect(flagsMatch).not.toBeNull();
+      const flags = flagsMatch![1];
+
+      // Optional flags should not be present
+      expect(flags).not.toContain("h");
+      expect(flags).not.toContain("P");
+      expect(command).not.toContain("--delete");
+      // Base flags should still be present
+      expect(flags).toContain("a");
+      expect(flags).toContain("v");
+      expect(flags).toContain("z");
+    });
+  });
+
+  describe("Progress and output message handling", () => {
+    it("should build command with progress flag for real-time updates", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/file.txt",
+        remotePath: "/remote/file.txt",
+        direction: TransferDirection.UPLOAD,
+        rsyncOptions: {
+          progress: true,
+          humanReadable: true,
+        },
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Should include both progress and human-readable flags
+      expect(command).toMatch(/-[avz]+hP/);
+      // Paths are now escaped with single quotes
+      expect(command).toContain("'/local/file.txt'");
+      expect(command).toContain("'testserver':");
+      expect(command).toContain("'/remote/file.txt'");
+    });
+
+    it("should handle upload with all options enabled", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/directory",
+        remotePath: "/remote/directory",
+        direction: TransferDirection.UPLOAD,
+        rsyncOptions: {
+          humanReadable: true,
+          progress: true,
+          delete: true,
+        },
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Command now uses single quotes for escaping
+      expect(command).toMatch(
+        /^rsync -e 'ssh -F .+' -[avz]+hP --delete .+ 'testserver':.+$/,
+      );
+      expect(command).toContain("'/local/directory'");
+      expect(command).toContain("'/remote/directory'");
+    });
+
+    it("should handle download with all options enabled", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/destination",
+        remotePath: "/remote/source",
+        direction: TransferDirection.DOWNLOAD,
+        rsyncOptions: {
+          humanReadable: true,
+          progress: true,
+          delete: true,
+        },
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Command now uses single quotes for escaping
+      expect(command).toMatch(
+        /^rsync -e 'ssh -F .+' -[avz]+hP --delete 'testserver':.+ .+$/,
+      );
+      expect(command).toContain("'testserver':");
+      expect(command).toContain("'/remote/source'");
+      // For downloads, local destination should have trailing slash to ensure directory is created
+      expect(command).toContain("'/local/destination/'");
+    });
+  });
+
+  describe("Rsync options workflow", () => {
+    it("should validate workflow with human-readable option", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/path",
+        remotePath: "/remote/path",
+        direction: TransferDirection.UPLOAD,
+        rsyncOptions: {
+          humanReadable: true,
+        },
+      };
+
+      const command = buildRsyncCommand(options);
+      expect(command).toMatch(/-[avz]+h/);
+      expect(command).toContain(configPath);
+    });
+
+    it("should validate workflow with progress option", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/path",
+        remotePath: "/remote/path",
+        direction: TransferDirection.DOWNLOAD,
+        rsyncOptions: {
+          progress: true,
+        },
+      };
+
+      const command = buildRsyncCommand(options);
+      expect(command).toMatch(/-[avz]+P/);
+      expect(command).toContain(configPath);
+    });
+
+    it("should validate workflow with delete option", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/path",
+        remotePath: "/remote/path",
+        direction: TransferDirection.UPLOAD,
+        rsyncOptions: {
+          delete: true,
+        },
+      };
+
+      const command = buildRsyncCommand(options);
+      expect(command).toContain("--delete");
+      expect(command).toContain(configPath);
+    });
+
+    it("should handle partial options (only some enabled)", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/path",
+        remotePath: "/remote/path",
+        direction: TransferDirection.UPLOAD,
+        rsyncOptions: {
+          humanReadable: true,
+          progress: false,
+          delete: false,
+        },
+      };
+
+      const command = buildRsyncCommand(options);
+      expect(command).toMatch(/-[avz]+h/);
+      expect(command).not.toContain("P");
+      expect(command).not.toContain("--delete");
+    });
+  });
+
+  describe("Command structure with options", () => {
+    it("should maintain correct command structure with options", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/file.txt",
+        remotePath: "/remote/file.txt",
+        direction: TransferDirection.UPLOAD,
+        rsyncOptions: {
+          humanReadable: true,
+          progress: true,
+        },
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Verify command structure: rsync -e 'ssh -F config' flags source dest
+      // Command now uses single quotes for escaping
+      expect(command).toMatch(
+        /^rsync -e 'ssh -F .+' -[avz]+hP .+ 'testserver':.+$/,
+      );
+    });
+
+    it("should handle long-form flags correctly", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/path",
+        remotePath: "/remote/path",
+        direction: TransferDirection.UPLOAD,
+        rsyncOptions: {
+          delete: true,
+        },
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // --delete should appear after short flags
+      expect(command).toMatch(/-avz --delete/);
+    });
+
+    it("should combine short and long flags correctly", () => {
+      const options: TransferOptions = {
+        hostConfig: mockHostConfig,
+        localPath: "/local/path",
+        remotePath: "/remote/path",
+        direction: TransferDirection.DOWNLOAD,
+        rsyncOptions: {
+          humanReadable: true,
+          progress: true,
+          delete: true,
+        },
+      };
+
+      const command = buildRsyncCommand(options);
+
+      // Should have short flags combined, then long flags
+      expect(command).toMatch(/-[avz]+hP --delete/);
+    });
+  });
+});

package/src/e2e/upload.e2e.test.ts

@@ -0,0 +1,207 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import {
+  validateLocalPath,
+  validateRemotePath,
+  validateHostConfig,
+} from "../utils/validation";
+import { buildRsyncCommand } from "../utils/rsync";
+import {
+  TransferDirection,
+  TransferOptions,
+  SSHHostConfig,
+} from "../types/server";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+describe("Upload E2E Flow", () => {
+  let testLocalFile: string;
+  let testDir: string;
+
+  beforeAll(() => {
+    // Create test directory
+    testDir = path.join(os.tmpdir(), "rsync-e2e-test-" + Date.now());
+    fs.mkdirSync(testDir, { recursive: true });
+
+    // Create test local file
+    testLocalFile = path.join(testDir, "test-file.txt");
+    fs.writeFileSync(testLocalFile, "Test content for upload");
+  });
+
+  afterAll(() => {
+    // Clean up test directory
+    if (fs.existsSync(testDir)) {
+      fs.rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  it("should complete full upload workflow with valid inputs", () => {
+    // This test verifies the complete upload workflow
+    // After successful execution, the UI will call popToRoot() to close the extension
+
+    // Step 1: Create mock host config
+    const testHost: SSHHostConfig = {
+      host: "testserver",
+      hostName: "test.example.com",
+      user: "testuser",
+      port: 2222,
+      identityFile: "~/.ssh/test_key",
+    };
+
+    // Step 2: Validate local path
+    const localValidation = validateLocalPath(testLocalFile);
+    expect(localValidation.valid).toBe(true);
+    expect(localValidation.error).toBeUndefined();
+
+    // Step 3: Validate remote path
+    const remotePath = "/remote/destination/file.txt";
+    const remoteValidation = validateRemotePath(remotePath);
+    expect(remoteValidation.valid).toBe(true);
+    expect(remoteValidation.error).toBeUndefined();
+
+    // Step 4: Validate host config
+    const hostValidation = validateHostConfig(testHost);
+    expect(hostValidation.valid).toBe(true);
+    expect(hostValidation.error).toBeUndefined();
+
+    // Step 5: Build rsync command
+    const options: TransferOptions = {
+      hostConfig: testHost,
+      localPath: testLocalFile,
+      remotePath: remotePath,
+      direction: TransferDirection.UPLOAD,
+    };
+
+    const command = buildRsyncCommand(options);
+    expect(command).toContain("rsync");
+    expect(command).toContain("-a");
+    // Host alias is now escaped with single quotes
+    expect(command).toContain("'testserver':");
+    // Paths are now escaped with single quotes
+    expect(command).toContain(`'${testLocalFile}'`);
+    expect(command).toContain(`'${remotePath}'`);
+  });
+
+  it("should handle missing local file error in upload workflow", () => {
+    // Try to validate non-existent local path
+    const nonExistentPath = "/path/that/does/not/exist.txt";
+    const localValidation = validateLocalPath(nonExistentPath);
+
+    // Should fail validation
+    expect(localValidation.valid).toBe(false);
+    expect(localValidation.error).toBeDefined();
+    expect(localValidation.error).toContain("File not found");
+  });
+
+  it("should handle invalid remote path in upload workflow", () => {
+    // Validate local path (should pass)
+    const localValidation = validateLocalPath(testLocalFile);
+    expect(localValidation.valid).toBe(true);
+
+    // Try to validate invalid remote path (empty)
+    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 port in host config", () => {
+    // Create host with invalid port
+    const invalidHost: SSHHostConfig = {
+      host: "testserver",
+      hostName: "test.example.com",
+      port: 99999,
+    };
+
+    // Validate host config
+    const hostValidation = validateHostConfig(invalidHost);
+
+    // Should fail validation
+    expect(hostValidation.valid).toBe(false);
+    expect(hostValidation.error).toBeDefined();
+    expect(hostValidation.error).toContain("must be between 1 and 65535");
+  });
+
+  it("should validate all inputs before allowing transfer", () => {
+    const testHost: SSHHostConfig = {
+      host: "testserver",
+      hostName: "test.example.com",
+      user: "testuser",
+      port: 22,
+    };
+
+    // All validations should pass
+    const localValidation = validateLocalPath(testLocalFile);
+    const remoteValidation = validateRemotePath("/remote/path");
+    const hostValidation = validateHostConfig(testHost);
+
+    expect(localValidation.valid).toBe(true);
+    expect(remoteValidation.valid).toBe(true);
+    expect(hostValidation.valid).toBe(true);
+
+    // Should be able to create transfer options
+    const options: TransferOptions = {
+      hostConfig: testHost,
+      localPath: testLocalFile,
+      remotePath: "/remote/path",
+      direction: TransferDirection.UPLOAD,
+    };
+
+    expect(options).toBeDefined();
+    expect(options.direction).toBe(TransferDirection.UPLOAD);
+  });
+
+  it("should handle directory upload", () => {
+    // Create test directory with files
+    const testSubDir = path.join(testDir, "test-dir");
+    fs.mkdirSync(testSubDir, { recursive: true });
+    fs.writeFileSync(path.join(testSubDir, "file1.txt"), "Content 1");
+    fs.writeFileSync(path.join(testSubDir, "file2.txt"), "Content 2");
+
+    // Validate directory path
+    const localValidation = validateLocalPath(testSubDir);
+    expect(localValidation.valid).toBe(true);
+
+    // Create options for directory upload
+    const testHost: SSHHostConfig = {
+      host: "testserver",
+      hostName: "test.example.com",
+    };
+
+    const options: TransferOptions = {
+      hostConfig: testHost,
+      localPath: testSubDir,
+      remotePath: "/remote/dir",
+      direction: TransferDirection.UPLOAD,
+    };
+
+    const command = buildRsyncCommand(options);
+    expect(command).toContain("-a");
+    expect(command).toContain(testSubDir);
+  });
+
+  it("should build correct rsync command for upload", () => {
+    const testHost: SSHHostConfig = {
+      host: "production",
+      hostName: "prod.example.com",
+      user: "produser",
+      port: 2222,
+    };
+
+    const options: TransferOptions = {
+      hostConfig: testHost,
+      localPath: testLocalFile,
+      remotePath: "/var/www/file.txt",
+      direction: TransferDirection.UPLOAD,
+    };
+
+    const command = buildRsyncCommand(options);
+
+    // Verify command structure (now uses single quotes for escaping)
+    expect(command).toMatch(/^rsync -e 'ssh -F .+' -avz .+ 'production':.+$/);
+    expect(command).toContain(`'${testLocalFile}'`);
+    expect(command).toContain("'/var/www/file.txt'");
+  });
+});

package/src/index.tsx

@@ -0,0 +1,21 @@
+/**
+ * Main entry point for the Raycast Rsync Extension
+ *
+ * This file serves as the central export point for all commands in the extension.
+ * The extension provides three main commands:
+ * 1. Upload Files via Rsync - Transfer files from local system to remote servers
+ * 2. Download Files via Rsync - Transfer files from remote servers to local system
+ * 3. Browse Remote Files - Browse and list files on remote servers
+ *
+ * All commands integrate with the user's SSH config file (~/.ssh/config) to
+ * provide a seamless experience for selecting and connecting to remote servers.
+ */
+
+// Export upload command
+export { default as upload } from "./upload";
+
+// Export download command
+export { default as download } from "./download";
+
+// Export browse command
+export { default as browse } from "./browse";

package/src/test-setup.ts

@@ -0,0 +1 @@
+import "@testing-library/jest-dom/vitest";

package/src/types/server.ts

@@ -0,0 +1,60 @@
+/**
+ * SSH host configuration parsed from ~/.ssh/config
+ */
+export interface SSHHostConfig {
+  host: string; // Host alias from config
+  hostName?: string; // Actual hostname or IP
+  user?: string; // SSH username
+  port?: number; // SSH port (default 22)
+  identityFile?: string; // Path to SSH key
+  proxyJump?: string; // Jump host configuration
+}
+
+/**
+ * Direction of file transfer
+ */
+export enum TransferDirection {
+  UPLOAD = "upload",
+  DOWNLOAD = "download",
+}
+
+/**
+ * Rsync-specific options
+ */
+export interface RsyncOptions {
+  humanReadable?: boolean; // -h: human-readable file sizes
+  delete?: boolean; // --delete: delete extraneous files from destination
+  progress?: boolean; // -P: show progress and support partial transfers
+}
+
+/**
+ * Options for rsync transfer operation
+ */
+export interface TransferOptions {
+  hostConfig: SSHHostConfig;
+  localPath: string;
+  remotePath: string;
+  direction: TransferDirection;
+  rsyncOptions?: RsyncOptions;
+}
+
+/**
+ * Result of rsync command execution
+ */
+export interface RsyncResult {
+  success: boolean;
+  message: string;
+  stdout?: string; // rsync output messages
+  stderr?: string;
+}
+
+/**
+ * Remote file information from ls command
+ */
+export interface RemoteFile {
+  name: string;
+  isDirectory: boolean;
+  size?: string;
+  permissions?: string;
+  modifiedDate?: string;
+}