raycast-rsync-extension 1.0.1

package/src/utils/sshConfig.ts

@@ -0,0 +1,212 @@
+import { SSHHostConfig } from "../types/server";
+import * as os from "node:os";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+// Cache for parsed SSH config
+interface CacheEntry {
+  hosts: SSHHostConfig[];
+  mtimeMs: number;
+}
+
+let configCache: CacheEntry | null = null;
+
+/**
+ * Get the absolute path to the SSH config file
+ * @returns The path to ~/.ssh/config
+ */
+export function getSSHConfigPath(): string {
+  return path.join(os.homedir(), ".ssh", "config");
+}
+
+/**
+ * Clear the SSH config cache
+ */
+export function clearCache(): void {
+  configCache = null;
+}
+
+/**
+ * Parse SSH config content string and extract host configurations
+ * @param content The SSH config file content
+ * @returns Array of SSHHostConfig objects (one per host alias)
+ */
+export function parseConfigContent(content: string): SSHHostConfig[] {
+  const hosts: SSHHostConfig[] = [];
+  const lines = content.split("\n");
+
+  let currentHosts: string[] = [];
+  let currentConfig: Partial<SSHHostConfig> = {};
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmedLine = line.trim();
+
+    // Skip empty lines and comments
+    if (!trimmedLine || trimmedLine.startsWith("#")) {
+      continue;
+    }
+
+    // Check if this is a Host line
+    const hostMatch = trimmedLine.match(/^Host\s+(.+)$/i);
+    if (hostMatch) {
+      // Save previous host config if exists
+      if (currentHosts.length > 0) {
+        saveHostConfigs(hosts, currentHosts, currentConfig);
+      }
+
+      // Parse new host aliases (space-separated)
+      const aliases = hostMatch[1].split(/\s+/).filter((alias) => alias.trim());
+
+      // Filter out wildcard hosts
+      currentHosts = aliases.filter(
+        (alias) => alias !== "*" && !alias.includes("*"),
+      );
+      currentConfig = {};
+      continue;
+    }
+
+    // Parse host properties (indented lines)
+    if (currentHosts.length > 0) {
+      const propertyMatch = trimmedLine.match(/^(\w+)\s+(.+)$/);
+      if (propertyMatch) {
+        const [, key, value] = propertyMatch;
+        const lowerKey = key.toLowerCase();
+
+        try {
+          switch (lowerKey) {
+            case "hostname": {
+              currentConfig.hostName = value.trim();
+              break;
+            }
+            case "user": {
+              currentConfig.user = value.trim();
+              break;
+            }
+            case "port": {
+              const portNum = parseInt(value.trim(), 10);
+              if (!isNaN(portNum)) {
+                currentConfig.port = portNum;
+              } else {
+                console.warn(`Invalid port value on line ${i + 1}: ${value}`);
+              }
+              break;
+            }
+            case "identityfile": {
+              // Expand ~ in paths
+              let identityPath = value.trim();
+              if (identityPath.startsWith("~")) {
+                identityPath = path.join(
+                  os.homedir(),
+                  identityPath.substring(1),
+                );
+              }
+              currentConfig.identityFile = identityPath;
+              break;
+            }
+            case "proxyjump": {
+              currentConfig.proxyJump = value.trim();
+              break;
+            }
+          }
+        } catch (error) {
+          // Log malformed entry but continue parsing
+          console.warn(`Skipping malformed entry on line ${i + 1}:`, error);
+        }
+      }
+    }
+  }
+
+  // Save the last host config
+  if (currentHosts.length > 0) {
+    saveHostConfigs(hosts, currentHosts, currentConfig);
+  }
+
+  return hosts;
+}
+
+/**
+ * Parse the SSH config file and extract host configurations
+ * Uses caching based on file modification time
+ * @returns Array of SSHHostConfig objects (one per host alias), or empty array if file doesn't exist or cannot be read
+ */
+export function parseSSHConfig(): SSHHostConfig[] {
+  const configPath = getSSHConfigPath();
+
+  // Check if file exists
+  if (!fs.existsSync(configPath)) {
+    return [];
+  }
+
+  try {
+    // Check file modification time for cache invalidation
+    const stats = fs.statSync(configPath);
+    const mtimeMs = stats.mtimeMs;
+
+    // Return cached result if cache is valid
+    if (configCache && configCache.mtimeMs === mtimeMs) {
+      return configCache.hosts;
+    }
+
+    // Read the config file
+    const content = fs.readFileSync(configPath, "utf-8");
+
+    // Parse the content
+    const hosts = parseConfigContent(content);
+
+    // Update cache
+    configCache = {
+      hosts,
+      mtimeMs,
+    };
+
+    return hosts;
+  } catch (error) {
+    // Handle read errors gracefully - return empty array
+    const nodeError = error as NodeJS.ErrnoException;
+    console.error("Error reading SSH config file:", {
+      code: nodeError.code,
+      message: nodeError.message,
+      path: configPath,
+    });
+    return [];
+  }
+}
+
+/**
+ * Helper function to save host configurations
+ * Creates one SSHHostConfig object per host alias
+ */
+function saveHostConfigs(
+  hosts: SSHHostConfig[],
+  aliases: string[],
+  config: Partial<SSHHostConfig>,
+): void {
+  for (const alias of aliases) {
+    hosts.push({
+      host: alias,
+      hostName: config.hostName,
+      user: config.user,
+      port: config.port,
+      identityFile: config.identityFile,
+      proxyJump: config.proxyJump,
+    });
+  }
+}
+
+/**
+ * Find a specific host configuration by alias
+ * @param alias The host alias to search for
+ * @returns The SSHHostConfig object or null if not found
+ */
+export function getHostConfig(alias: string): SSHHostConfig | null {
+  try {
+    const hosts = parseSSHConfig();
+    return hosts.find((host) => host.host === alias) || null;
+  } catch (error) {
+    // Log error for debugging
+    console.error("Error getting host config:", error);
+    // Return null if config cannot be parsed
+    return null;
+  }
+}

package/src/utils/validation.test.ts

@@ -0,0 +1,224 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import * as fs from "node:fs";
+import {
+  validateLocalPath,
+  validateRemotePath,
+  validatePort,
+  validateHostConfig,
+} from "./validation";
+import { SSHHostConfig } from "../types/server";
+
+// Type definitions for mocked fs module
+type MockedFS = typeof fs & {
+  __setMockFileExists: (exists: boolean) => void;
+};
+
+// Mock fs module
+vi.mock("node:fs", async () => {
+  const actual = await vi.importActual<typeof fs>("node:fs");
+  let mockFileExists = false;
+
+  return {
+    ...actual,
+    existsSync: vi.fn(() => mockFileExists),
+    __setMockFileExists: (exists: boolean) => {
+      mockFileExists = exists;
+    },
+  };
+});
+
+describe("Validation Utilities", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    (fs as unknown as MockedFS).__setMockFileExists(false);
+  });
+
+  describe("validateLocalPath", () => {
+    it("should return valid for existing file", () => {
+      (fs as unknown as MockedFS).__setMockFileExists(true);
+      const result = validateLocalPath("/path/to/file.txt");
+      expect(result.valid).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+
+    it("should return invalid for non-existent file", () => {
+      (fs as unknown as MockedFS).__setMockFileExists(false);
+      const result = validateLocalPath("/path/to/nonexistent.txt");
+      expect(result.valid).toBe(false);
+      expect(result.error).toBe("File not found");
+    });
+
+    it("should return invalid for empty path", () => {
+      const result = validateLocalPath("");
+      expect(result.valid).toBe(false);
+      expect(result.error).toBe("Local path cannot be empty");
+    });
+
+    it("should return invalid for whitespace-only path", () => {
+      const result = validateLocalPath("   ");
+      expect(result.valid).toBe(false);
+      expect(result.error).toBe("Local path cannot be empty");
+    });
+  });
+
+  describe("validateRemotePath", () => {
+    it("should return valid for valid path format", () => {
+      const result = validateRemotePath("/home/user/file.txt");
+      expect(result.valid).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+
+    it("should return valid for relative path", () => {
+      const result = validateRemotePath("./documents/file.txt");
+      expect(result.valid).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+
+    it("should return invalid for empty path", () => {
+      const result = validateRemotePath("");
+      expect(result.valid).toBe(false);
+      expect(result.error).toBe("Remote path cannot be empty");
+    });
+
+    it("should return invalid for path with control characters", () => {
+      const result = validateRemotePath("/path/with\x00null");
+      expect(result.valid).toBe(false);
+      expect(result.error).toContain("Invalid path format");
+    });
+
+    it("should return invalid for path with shell metacharacters (semicolon)", () => {
+      const result = validateRemotePath("/tmp/test; rm -rf /");
+      expect(result.valid).toBe(false);
+      expect(result.error).toContain("shell metacharacters");
+    });
+
+    it("should return invalid for path with shell metacharacters (pipe)", () => {
+      const result = validateRemotePath("/tmp/test | cat");
+      expect(result.valid).toBe(false);
+      expect(result.error).toContain("shell metacharacters");
+    });
+
+    it("should return invalid for path with shell metacharacters (ampersand)", () => {
+      const result = validateRemotePath("/tmp/test & echo");
+      expect(result.valid).toBe(false);
+      expect(result.error).toContain("shell metacharacters");
+    });
+
+    it("should return invalid for path with shell metacharacters (backtick)", () => {
+      const result = validateRemotePath("/tmp/test`whoami`");
+      expect(result.valid).toBe(false);
+      expect(result.error).toContain("shell metacharacters");
+    });
+
+    it("should return invalid for path with shell metacharacters (dollar sign)", () => {
+      const result = validateRemotePath("/tmp/test$HOME");
+      expect(result.valid).toBe(false);
+      expect(result.error).toContain("shell metacharacters");
+    });
+
+    it("should allow parentheses in paths (legitimate filename characters)", () => {
+      const result = validateRemotePath("/tmp/test(file)");
+      // Parentheses are allowed as they can legitimately appear in filenames
+      // and are safely handled by our escaping
+      expect(result.valid).toBe(true);
+    });
+  });
+
+  describe("validatePort", () => {
+    it("should return valid for port in valid range", () => {
+      const result = validatePort(22);
+      expect(result.valid).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+
+    it("should return valid for port 1", () => {
+      const result = validatePort(1);
+      expect(result.valid).toBe(true);
+    });
+
+    it("should return valid for port 65535", () => {
+      const result = validatePort(65535);
+      expect(result.valid).toBe(true);
+    });
+
+    it("should return invalid for port 0", () => {
+      const result = validatePort(0);
+      expect(result.valid).toBe(false);
+      expect(result.error).toBe(
+        "Invalid port number: must be between 1 and 65535",
+      );
+    });
+
+    it("should return invalid for port above 65535", () => {
+      const result = validatePort(65536);
+      expect(result.valid).toBe(false);
+      expect(result.error).toBe(
+        "Invalid port number: must be between 1 and 65535",
+      );
+    });
+
+    it("should return invalid for negative port", () => {
+      const result = validatePort(-1);
+      expect(result.valid).toBe(false);
+      expect(result.error).toBe(
+        "Invalid port number: must be between 1 and 65535",
+      );
+    });
+
+    it("should return invalid for non-integer port", () => {
+      const result = validatePort(22.5);
+      expect(result.valid).toBe(false);
+      expect(result.error).toBe("Port must be an integer");
+    });
+  });
+
+  describe("validateHostConfig", () => {
+    it("should return valid for complete config", () => {
+      const config: SSHHostConfig = {
+        host: "server1",
+        hostName: "example.com",
+        user: "admin",
+        port: 22,
+      };
+      const result = validateHostConfig(config);
+      expect(result.valid).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+
+    it("should return valid for config without optional fields", () => {
+      const config: SSHHostConfig = {
+        host: "server1",
+      };
+      const result = validateHostConfig(config);
+      expect(result.valid).toBe(true);
+    });
+
+    it("should return invalid for missing host alias", () => {
+      const config: SSHHostConfig = {
+        host: "",
+        hostName: "example.com",
+      };
+      const result = validateHostConfig(config);
+      expect(result.valid).toBe(false);
+      expect(result.error).toBe("Host alias is required");
+    });
+
+    it("should return invalid for invalid port", () => {
+      const config: SSHHostConfig = {
+        host: "server1",
+        port: 70000,
+      };
+      const result = validateHostConfig(config);
+      expect(result.valid).toBe(false);
+      expect(result.error).toBe(
+        "Invalid port number: must be between 1 and 65535",
+      );
+    });
+
+    it("should return invalid for null config", () => {
+      const result = validateHostConfig(null as unknown as SSHHostConfig);
+      expect(result.valid).toBe(false);
+      expect(result.error).toBe("Host configuration is required");
+    });
+  });
+});

package/src/utils/validation.ts

@@ -0,0 +1,115 @@
+import { existsSync } from "fs";
+import { SSHHostConfig } from "../types/server";
+
+/**
+ * Validation result structure
+ */
+export interface ValidationResult {
+  valid: boolean;
+  error?: string;
+}
+
+/**
+ * Validates that a local path exists on the filesystem
+ * @param path - The local file or directory path to validate
+ * @returns Validation result with error message if invalid
+ */
+export function validateLocalPath(path: string): ValidationResult {
+  if (!path || path.trim() === "") {
+    return { valid: false, error: "Local path cannot be empty" };
+  }
+
+  if (!existsSync(path)) {
+    return { valid: false, error: "File not found" };
+  }
+
+  return { valid: true };
+}
+
+/**
+ * Validates remote path format
+ * @param path - The remote path to validate
+ * @returns Validation result with error message if invalid
+ */
+export function validateRemotePath(path: string): ValidationResult {
+  if (!path || path.trim() === "") {
+    return { valid: false, error: "Remote path cannot be empty" };
+  }
+
+  // Check for invalid characters that could cause issues
+  // eslint-disable-next-line no-control-regex
+  const invalidChars = /[\x00-\x1F\x7F]/;
+  if (invalidChars.test(path)) {
+    return {
+      valid: false,
+      error: "Invalid path format: contains control characters",
+    };
+  }
+
+  // Defense in depth: Detect dangerous shell metacharacters that could indicate injection attempts
+  // Note: While we now properly escape all paths, this validation provides early detection
+  // of potentially malicious input. We only reject clearly dangerous characters:
+  // - ; (command separator)
+  // - | (pipe)
+  // - & (background execution)
+  // - ` (command substitution)
+  // - $ (variable expansion)
+  // - \ (escape character)
+  // We allow parentheses, brackets, and braces as they can legitimately appear in filenames
+  // and are safely handled by our escaping.
+  const dangerousMetacharacters = /[;&|`$\\]/;
+  if (dangerousMetacharacters.test(path)) {
+    return {
+      valid: false,
+      error:
+        "Invalid path format: contains dangerous shell metacharacters. Paths are now properly escaped, but this input may be unsafe.",
+    };
+  }
+
+  return { valid: true };
+}
+
+/**
+ * Validates that a port number is within valid range (1-65535)
+ * @param port - The port number to validate
+ * @returns Validation result with error message if invalid
+ */
+export function validatePort(port: number): ValidationResult {
+  if (!Number.isInteger(port)) {
+    return { valid: false, error: "Port must be an integer" };
+  }
+
+  if (port < 1 || port > 65535) {
+    return {
+      valid: false,
+      error: "Invalid port number: must be between 1 and 65535",
+    };
+  }
+
+  return { valid: true };
+}
+
+/**
+ * Validates that a host configuration has required fields and valid values
+ * @param config - The SSH host configuration to validate
+ * @returns Validation result with error message if invalid
+ */
+export function validateHostConfig(config: SSHHostConfig): ValidationResult {
+  if (!config) {
+    return { valid: false, error: "Host configuration is required" };
+  }
+
+  if (!config.host || config.host.trim() === "") {
+    return { valid: false, error: "Host alias is required" };
+  }
+
+  // Validate port if present
+  if (config.port !== undefined) {
+    const portValidation = validatePort(config.port);
+    if (!portValidation.valid) {
+      return portValidation;
+    }
+  }
+
+  return { valid: true };
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "target": "ES2021",
+    "module": "commonjs",
+    "lib": ["ES2021"],
+    "jsx": "react",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+  },
+});