feat: update proxy ui to accept credential outside url too

2026-07-25 13:50:51 +02:00 · 2025-06-11 01:55:54 +04:00
parent 4d7bbe719f
commit 29c329b432
10 changed files with 375 additions and 236 deletions
@@ -1,8 +1,8 @@
 import { program } from "commander";
 import {
  startProxyProcess,
-  stopProxyProcess,
  stopAllProxyProcesses,
+  stopProxyProcess,
 } from "./proxy-runner";
 import { listProxyConfigs } from "./proxy-storage";
 import { runProxyWorker } from "./proxy-worker";
@@ -11,22 +11,22 @@ import { runProxyWorker } from "./proxy-worker";
 program
  .command("proxy")
  .argument("<action>", "start, stop, or list proxies")
-  .option("-h, --host <host>", "upstream proxy host")
-  .option("-P, --proxy-port <port>", "upstream proxy port", Number.parseInt)
-  .option(
-    "-t, --type <type>",
-    "upstream proxy type (http, https, socks4, socks5)",
-    "http"
-  )
-  .option("-u, --username <username>", "upstream proxy username")
-  .option("-w, --password <password>", "upstream proxy password")
+  .option("--host <host>", "upstream proxy host")
+  .option("--proxy-port <port>", "upstream proxy port", Number.parseInt)
+  .option("--type <type>", "proxy type (http, https, socks4, socks5)")
+  .option("--username <username>", "proxy username")
+  .option("--password <password>", "proxy password")
  .option(
    "-p, --port <number>",
    "local port to use (random if not specified)",
-    Number.parseInt
+    Number.parseInt,
  )
  .option("--ignore-certificate", "ignore certificate errors for HTTPS proxies")
  .option("--id <id>", "proxy ID for stop command")
+  .option(
+    "-u, --upstream <url>",
+    "upstream proxy URL (protocol://[username:password@]host:port)",
+  )
  .description("manage proxy servers")
  .action(
    async (
@@ -40,78 +40,98 @@ program
        port?: number;
        ignoreCertificate?: boolean;
        id?: string;
-      }
+        upstream?: string;
+      },
    ) => {
      if (action === "start") {
-        if (!options.host || !options.proxyPort) {
-          console.error("Error: Upstream proxy host and port are required");
-          console.log(
-            "Example: proxy start -h proxy.example.com -P 8080 -t http -u username -w password"
+        let upstreamUrl: string;
+
+        // Build upstream URL from individual components if provided
+        if (options.host && options.proxyPort && options.type) {
+          const protocol =
+            options.type === "socks4" || options.type === "socks5"
+              ? options.type
+              : "http";
+          const auth =
+            options.username && options.password
+              ? `${encodeURIComponent(options.username)}:${encodeURIComponent(
+                  options.password,
+                )}@`
+              : "";
+          upstreamUrl = `${protocol}://${auth}${options.host}:${options.proxyPort}`;
+        } else if (options.upstream) {
+          upstreamUrl = options.upstream;
+        } else {
+          console.error(
+            "Error: Either --upstream URL or --host, --proxy-port, and --type are required",
          );
+          console.log(
+            "Example: proxy start --host datacenter.proxyempire.io --proxy-port 9000 --type http --username user --password pass",
+          );
+          process.exit(1);
          return;
        }

        try {
-          // Construct the upstream URL with credentials if provided
-          let upstreamProxyUrl: string;
-          if (options.username && options.password) {
-            upstreamProxyUrl = `${options.type}://${options.username}:${options.password}@${options.host}:${options.proxyPort}`;
-          } else {
-            upstreamProxyUrl = `${options.type}://${options.host}:${options.proxyPort}`;
-          }
-
-          const config = await startProxyProcess(upstreamProxyUrl, {
+          const config = await startProxyProcess(upstreamUrl, {
            port: options.port,
            ignoreProxyCertificate: options.ignoreCertificate,
          });
-          console.log(JSON.stringify(config));
+
+          // Output the configuration as JSON for the Rust side to parse
+          console.log(
+            JSON.stringify({
+              id: config.id,
+              localPort: config.localPort,
+              localUrl: config.localUrl,
+              upstreamUrl: config.upstreamUrl,
+            }),
+          );
+
+          // Exit successfully to allow the process to detach
+          process.exit(0);
        } catch (error: unknown) {
-          console.error(`Failed to start proxy: ${JSON.stringify(error)}`);
+          console.error(
+            `Failed to start proxy: ${
+              error instanceof Error ? error.message : JSON.stringify(error)
+            }`,
+          );
+          process.exit(1);
        }
      } else if (action === "stop") {
        if (options.id) {
          const stopped = await stopProxyProcess(options.id);
-          console.log(`{
-            "success": ${stopped}}`);
-        } else if (options.host && options.proxyPort && options.type) {
-          // Find proxies with matching upstream details
-          const configs = listProxyConfigs().filter((config) => {
-            try {
-              const url = new URL(config.upstreamUrl);
-              return (
-                url.hostname === options.host &&
-                Number.parseInt(url.port) === options.proxyPort &&
-                url.protocol.replace(":", "") === options.type
-              );
-            } catch {
-              return false;
-            }
-          });
+          console.log(JSON.stringify({ success: stopped }));
+        } else if (options.upstream) {
+          // Find proxies with this upstream URL
+          const configs = listProxyConfigs().filter(
+            (config) => config.upstreamUrl === options.upstream,
+          );

          if (configs.length === 0) {
-            console.error(
-              `No proxies found for ${options.host}:${options.proxyPort}`
-            );
+            console.error(`No proxies found for ${options.upstream}`);
+            process.exit(1);
            return;
          }

          for (const config of configs) {
            const stopped = await stopProxyProcess(config.id);
-            console.log(`{
-            "success": ${stopped}}`);
+            console.log(JSON.stringify({ success: stopped }));
          }
        } else {
          await stopAllProxyProcesses();
-          console.log(`{
-            "success": true}`);
+          console.log(JSON.stringify({ success: true }));
        }
+        process.exit(0);
      } else if (action === "list") {
        const configs = listProxyConfigs();
        console.log(JSON.stringify(configs));
+        process.exit(0);
      } else {
        console.error("Invalid action. Use 'start', 'stop', or 'list'");
+        process.exit(1);
      }
-    }
+    },
  );

 // Command for proxy worker (internal use)
@@ -3,12 +3,12 @@ import path from "node:path";
 import getPort from "get-port";
 import {
  type ProxyConfig,
-  saveProxyConfig,
-  getProxyConfig,
  deleteProxyConfig,
-  isProcessRunning,
  generateProxyId,
+  getProxyConfig,
+  isProcessRunning,
  listProxyConfigs,
+  saveProxyConfig,
 } from "./proxy-storage";

 /**
@@ -19,50 +19,53 @@ import {
 */
 export async function startProxyProcess(
  upstreamUrl: string,
-  options: { port?: number; ignoreProxyCertificate?: boolean } = {}
+  options: { port?: number; ignoreProxyCertificate?: boolean } = {},
 ): Promise<ProxyConfig> {
  // Generate a unique ID for this proxy
  const id = generateProxyId();

  // Get a random available port if not specified
-  const port = options.port || (await getPort());
+  const port = options.port ?? (await getPort());

  // Create the proxy configuration
  const config: ProxyConfig = {
    id,
    upstreamUrl,
    localPort: port,
-    ignoreProxyCertificate: options.ignoreProxyCertificate || false,
+    ignoreProxyCertificate: options.ignoreProxyCertificate ?? false,
  };

  // Save the configuration before starting the process
  saveProxyConfig(config);

  // Build the command arguments
-  const args = ["proxy-worker", "start", "--id", id];
+  const args = [
+    path.join(__dirname, "index.js"),
+    "proxy-worker",
+    "start",
+    "--id",
+    id,
+  ];

-  // Spawn the process
-  const child = spawn(
-    process.execPath,
-    [path.join(__dirname, "index.js"), ...args],
-    {
-      detached: true,
-      stdio: "ignore",
-    }
-  );
+  // Spawn the process with proper detachment
+  const child = spawn(process.execPath, args, {
+    detached: true,
+    stdio: ["ignore", "ignore", "ignore"], // Completely ignore all stdio
+    cwd: process.cwd(),
+  });

  // Unref the child to allow the parent to exit independently
  child.unref();

-  // Store the process ID
+  // Store the process ID and local URL
  config.pid = child.pid;
-  config.localUrl = `http://localhost:${port}`;
+  config.localUrl = `http://127.0.0.1:${port}`;

  // Update the configuration with the process ID
  saveProxyConfig(config);

-  // Wait a bit to ensure the proxy has started
-  await new Promise((resolve) => setTimeout(resolve, 500));
+  // Give the worker a moment to start before returning
+  await new Promise((resolve) => setTimeout(resolve, 100));

  return config;
 }
@@ -76,6 +79,8 @@ export async function stopProxyProcess(id: string): Promise<boolean> {
  const config = getProxyConfig(id);

  if (!config || !config.pid) {
+    // Try to delete the config anyway in case it exists without a PID
+    deleteProxyConfig(id);
    return false;
  }

@@ -83,10 +88,16 @@ export async function stopProxyProcess(id: string): Promise<boolean> {
    // Check if the process is running
    if (isProcessRunning(config.pid)) {
      // Send SIGTERM to the process
-      process.kill(config.pid);
+      process.kill(config.pid, "SIGTERM");

      // Wait a bit to ensure the process has terminated
-      await new Promise((resolve) => setTimeout(resolve, 300));
+      await new Promise((resolve) => setTimeout(resolve, 500));
+
+      // If still running, send SIGKILL
+      if (isProcessRunning(config.pid)) {
+        process.kill(config.pid, "SIGKILL");
+        await new Promise((resolve) => setTimeout(resolve, 200));
+      }
    }

    // Delete the configuration
@@ -95,6 +106,8 @@ export async function stopProxyProcess(id: string): Promise<boolean> {
    return true;
  } catch (error) {
    console.error(`Error stopping proxy ${id}:`, error);
+    // Delete the configuration even if stopping failed
+    deleteProxyConfig(id);
    return false;
  }
 }
@@ -106,7 +119,6 @@ export async function stopProxyProcess(id: string): Promise<boolean> {
 export async function stopAllProxyProcesses(): Promise<void> {
  const configs = listProxyConfigs();

-  for (const config of configs) {
-    await stopProxyProcess(config.id);
-  }
+  const stopPromises = configs.map((config) => stopProxyProcess(config.id));
+  await Promise.all(stopPromises);
 }
@@ -1,5 +1,5 @@
 import { Server } from "proxy-chain";
-import { getProxyConfig } from "./proxy-storage";
+import { getProxyConfig, updateProxyConfig } from "./proxy-storage";

 /**
 * Run a proxy server as a worker process
@@ -8,44 +8,68 @@ import { getProxyConfig } from "./proxy-storage";
 export async function runProxyWorker(id: string): Promise<void> {
  // Get the proxy configuration
  const config = getProxyConfig(id);
-  
+
  if (!config) {
    console.error(`Proxy configuration ${id} not found`);
    process.exit(1);
  }
-  
+
  // Create a new proxy server
  const server = new Server({
    port: config.localPort,
-    host: "localhost",
+    host: "127.0.0.1",
    prepareRequestFunction: () => {
      return {
        upstreamProxyUrl: config.upstreamUrl,
-        ignoreUpstreamProxyCertificate: config.ignoreProxyCertificate || false,
+        ignoreUpstreamProxyCertificate: config.ignoreProxyCertificate ?? false,
      };
    },
  });
-  
-  // Handle process termination
-  process.on("SIGTERM", async () => {
-    console.log(`Proxy worker ${id} received SIGTERM, shutting down...`);
-    await server.close(true);
+
+  // Handle process termination gracefully
+  const gracefulShutdown = async (signal: string) => {
+    console.log(`Proxy worker ${id} received ${signal}, shutting down...`);
+    try {
+      await server.close(true);
+      console.log(`Proxy worker ${id} shut down successfully`);
+    } catch (error) {
+      console.error(`Error during shutdown for proxy ${id}:`, error);
+    }
    process.exit(0);
+  };
+
+  process.on("SIGTERM", () => void gracefulShutdown("SIGTERM"));
+  process.on("SIGINT", () => void gracefulShutdown("SIGINT"));
+
+  // Handle uncaught exceptions
+  process.on("uncaughtException", (error) => {
+    console.error(`Uncaught exception in proxy worker ${id}:`, error);
+    process.exit(1);
  });
-  
-  process.on("SIGINT", async () => {
-    console.log(`Proxy worker ${id} received SIGINT, shutting down...`);
-    await server.close(true);
-    process.exit(0);
+
+  process.on("unhandledRejection", (reason) => {
+    console.error(`Unhandled rejection in proxy worker ${id}:`, reason);
+    process.exit(1);
  });
-  
+
  // Start the server
  try {
    await server.listen();
+
+    // Update the config with the actual port (in case it was auto-assigned)
+    config.localPort = server.port;
+    config.localUrl = `http://127.0.0.1:${server.port}`;
+    updateProxyConfig(config);
+
    console.log(`Proxy worker ${id} started on port ${server.port}`);
    console.log(`Forwarding to upstream proxy: ${config.upstreamUrl}`);
+
+    // Keep the process alive
+    setInterval(() => {
+      // Do nothing, just keep the process alive
+    }, 60000);
  } catch (error) {
    console.error(`Failed to start proxy worker ${id}:`, error);
    process.exit(1);
  }
-}
+}
@@ -1,103 +0,0 @@
-import {
-  startProxyProcess,
-  stopProxyProcess,
-  stopAllProxyProcesses,
-} from "./proxy-runner";
-import { listProxyConfigs } from "./proxy-storage";
-
-// Type definitions
-interface ProxyOptions {
-  port?: number;
-  ignoreProxyCertificate?: boolean;
-  username?: string;
-  password?: string;
-}
-
-/**
- * Start a local proxy server that forwards to an upstream proxy
- * @param upstreamProxyHost The upstream proxy host
- * @param upstreamProxyPort The upstream proxy port
- * @param upstreamProxyType The upstream proxy type (http, https, socks4, socks5)
- * @param options Optional configuration including credentials
- * @returns Promise resolving to the local proxy URL
- */
-export async function startProxy(
-  upstreamProxyHost: string,
-  upstreamProxyPort: number,
-  upstreamProxyType: string,
-  options: ProxyOptions = {}
-): Promise<string> {
-  // Construct the upstream proxy URL with credentials if provided
-  let upstreamProxyUrl: string;
-  if (options.username && options.password) {
-    upstreamProxyUrl = `${upstreamProxyType}://${options.username}:${options.password}@${upstreamProxyHost}:${upstreamProxyPort}`;
-  } else {
-    upstreamProxyUrl = `${upstreamProxyType}://${upstreamProxyHost}:${upstreamProxyPort}`;
-  }
-
-  const config = await startProxyProcess(upstreamProxyUrl, {
-    port: options.port,
-    ignoreProxyCertificate: options.ignoreProxyCertificate,
-  });
-
-  return config.localUrl || `http://localhost:${config.localPort}`;
-}
-
-/**
- * Stop a specific proxy by its upstream host, port, and type
- * @param upstreamProxyHost The upstream proxy host
- * @param upstreamProxyPort The upstream proxy port
- * @param upstreamProxyType The upstream proxy type
- * @returns Promise resolving to true if proxy was found and stopped, false otherwise
- */
-export async function stopProxy(
-  upstreamProxyHost: string,
-  upstreamProxyPort: number,
-  upstreamProxyType: string
-): Promise<boolean> {
-  // Find all proxies with matching upstream details (ignoring credentials in URL)
-  const configs = listProxyConfigs().filter((config) => {
-    // Parse the upstream URL to extract host, port, and type
-    try {
-      const url = new URL(config.upstreamUrl);
-      return (
-        url.hostname === upstreamProxyHost &&
-        Number.parseInt(url.port) === upstreamProxyPort &&
-        url.protocol.replace(":", "") === upstreamProxyType
-      );
-    } catch {
-      return false;
-    }
-  });
-
-  if (configs.length === 0) {
-    return false;
-  }
-
-  // Stop all matching proxies
-  let success = true;
-  for (const config of configs) {
-    const stopped = await stopProxyProcess(config.id);
-    if (!stopped) {
-      success = false;
-    }
-  }
-
-  return success;
-}
-
-/**
- * Get a list of all active proxy upstream URLs
- * @returns Array of upstream proxy URLs
- */
-export function getActiveProxies(): string[] {
-  return listProxyConfigs().map((config) => config.upstreamUrl);
-}
-
-/**
- * Stop all active proxies
- * @returns Promise that resolves when all proxies are stopped
- */
-export async function stopAllProxies(): Promise<void> {
-  await stopAllProxyProcesses();
-}