[growab]

Summary

Adds support for 6 new shorthand proxy formats and a protocol-header mode to the proxy Bulk Import feature, alongside the existing pipe-delimited format (fully backward-compatible).

Problem

The proxy bulk import only accepted the pipe-delimited format (NAME|HOST|PORT|USERNAME|PASSWORD|TYPE|REGION|STATUS|NOTES). Users copying proxy lists from common proxy providers (which use ip:port:user:pass, user:pass@ip:port, protocol://user:pass@ip:port, etc.) had to manually reformat each line.

The en.json description already mentioned HOST:PORT shorthand support, but the inline parser in ProxyRegistryManager.tsx never implemented it — it only handled pipe-delimited lines.

Additionally, ProxyRegistryManager.tsx had a duplicate inline parser that shadowed the extracted parseBulkProxyImport.ts module. The inline copy only supported pipe-delimited format, so the shorthand parsing logic in the shared module was never called at runtime.

Changes

1. parseBulkProxyImport.ts — rewritten parser

Supports all formats (one proxy per line):

Format	Example
Pipe-delimited	proxy-us|138.99.147.218|50101|myuser|mypass|socks5|US-East|active|US proxy
ip:port	138.99.147.218:50101
ip:port:user:pass	138.99.147.218:50101:myuser:mypass
user:pass@ip:port	myuser:mypass@138.99.147.218:50101
user:pass:ip:port	myuser:mypass:138.99.147.218:50101
protocol://ip:port	http://10.0.0.50:8080
protocol://user:pass@ip:port	https://admin:secret@proxy.example.com:443

Protocol header mode: A bare protocol name (http, https, socks5) on its own line sets the default type for all subsequent shorthand lines without an explicit protocol:// prefix. The per-line protocol:// prefix always takes precedence over the header default.

socks5
138.99.147.218:50101:myuser:mypass      → type: socks5 (from header)
http://10.0.0.50:8080                    → type: http (explicit prefix overrides header)
200.234.177.62:50101:otheruser:otherpass → type: socks5 (from header)

4-colon disambiguation: For a:b:c:d format, the parser checks if parts[0] looks like an IP/hostname and parts[1] is a valid port → ip:port:user:pass. Otherwise if parts[2] looks like an IP/hostname and parts[3] is a valid port → user:pass:ip:port.

Default type change: Shorthand ip:port (no protocol) now defaults to socks5 instead of http for consistency with the pipe-delimited default.

2. ProxyRegistryManager.tsx — removed inline parser duplicate

• Deleted the inline parseBulkImportText function, VALID_TYPES, VALID_STATUSES, and duplicate ParsedProxyEntry/ParseError types
• Added import { parseBulkImportText, type ParsedProxyEntry, type ParseError } from "./parseBulkProxyImport"
• Now the component uses the shared parser that supports all formats
• Updated BULK_IMPORT_TEMPLATE comment block with full documentation and examples for all 3 format groups

3. en.json — updated description

Updated bulkImportDescription to list all supported formats.

4. Tests — proxy-registry-manager.test.ts

Expanded from 13 → 30 tests covering:

• All 6 shorthand formats (positive + negative cases)
• Protocol header mode (4 tests: default application, prefix override precedence, mixed with pipe, lines-before-header)
• Pipe-delimited regression (5 tests — all existing behavior preserved)
• Edge cases (ambiguous 4-colon, invalid port, bare text)
• Full real-world mixed import block

Commands ran

npx c8 --output-dir coverage --exclude=open-sse --check-coverage --lines 60 --functions 60 --branches 60 node --import tsx/esm --test tests/unit/proxy-registry-manager.test.ts

Changed test files

• tests/unit/proxy-registry-manager.test.ts — expanded from 13 to 30 tests

Coverage result

File                                   | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s
---------------------------------------|---------|----------|---------|---------|-------------------
All files                              |   97.01 |    91.01 |     100 |   97.01 |
 parseBulkProxyImport.ts               |   93.18 |    86.44 |     100 |   93.18 |
 proxy-registry-manager.test.ts         |     100 |      100 |     100 |     100 |
---------------------------------------|---------|----------|---------|---------|-------------------

All metrics exceed the 60% threshold (statements, lines, functions, branches).

[gemini-code-assist]

Code Review

This pull request expands the proxy bulk import feature by adding support for multiple shorthand formats (such as ip:port, ip:port:user:pass, user:pass@ip:port, user:pass:ip:port, and protocol prefixes) as well as a protocol header mode. It also updates the unit tests to cover these new formats. The code reviewer identified two critical issues in the new parsing logic: first, the looksLikeHost helper is too permissive and can lead to incorrect parsing of 4-colon shorthand formats when the password is a valid port number; second, splitting shorthand lines by : breaks support for IPv6 addresses, introducing a regression. Code suggestions were provided to resolve both issues.

Important

The consumer version of Gemini Code Assist on GitHub is being sunset. Starting June 18, 2026, new organization installations will be blocked, and all code review activity will officially cease on July 17, 2026.
For more details on the timeline and next steps, please review the Help Documentation.

[gemini-code-assist]

The current implementation of looksLikeHost is too permissive for hostname validation. Since it matches any alphanumeric string (e.g., "myuser"), it can cause incorrect parsing of 4-colon shorthand formats like user:pass:ip:port when the password is a valid port number (e.g., myuser:1234:1.2.3.4:8080). In this case, looksLikeHost("myuser") returns true and isPort1 is true, causing it to be incorrectly parsed as ip:port:user:pass with host "myuser" and port 1234.\n\nTo prevent this, looksLikeHost should require a dot in the hostname (or explicitly match localhost and bracketed IPv6 addresses).

function looksLikeHost(s: string): boolean {
  if (!s) return false;
  const lower = s.toLowerCase();
  if (lower === "localhost") return true;
  // Bracketed IPv6
  if (s.startsWith("[") && s.endsWith("]")) {
    return true;
  }
  // IPv4: four dot-separated octets, each 0–255
  const ipParts = s.split(".");
  if (ipParts.length === 4 && ipParts.every((o) => /^\d+$/.test(o) && Number(o) >= 0 && Number(o) <= 255)) {
    return true;
  }
  // Hostname: must contain at least one dot, and match alphanumeric + dots/hyphens
  return s.includes(".") && /^[a-zA-Z0-9]([a-zA-Z0-9.-]*[a-zA-Z0-9])?$/.test(s);
}

[gemini-code-assist]

Splitting the shorthand proxy line by : breaks support for IPv6 addresses (e.g., [2001:db8::1]:8080 or user:pass:[2001:db8::1]:8080), which are split into more than 4 parts and fail to parse. This is a regression from the previous simple HOST:PORT parser which used lastIndexOf(":").\n\nWe can handle bracketed IPv6 hosts explicitly before splitting by : to preserve full IPv6 compatibility.

  // No @ — check for bracketed IPv6 hosts first to avoid splitting on IPv6 colons
  if (working.startsWith("[")) {
    const closeBracketIdx = working.indexOf("]");
    if (closeBracketIdx > 0 && working.charAt(closeBracketIdx + 1) === ":") {
      const host = working.slice(0, closeBracketIdx + 1).trim();
      const rest = working.slice(closeBracketIdx + 2).trim();
      const restParts = rest.split(":").map((p) => p.trim());
      if (restParts.length === 1) {
        // [ipv6]:port
        return pushShorthandEntry(entries, errors, lineNum, host, restParts[0], "", "", type);
      }
      if (restParts.length === 3) {
        // [ipv6]:port:user:pass
        return pushShorthandEntry(entries, errors, lineNum, host, restParts[0], restParts[1], restParts[2], type);
      }
    }
  }

  const openBracketIdx = working.indexOf(":[");
  if (openBracketIdx > 0) {
    const closeBracketIdx = working.indexOf("]", openBracketIdx);
    if (closeBracketIdx > 0 && working.charAt(closeBracketIdx + 1) === ":") {
      const authPart = working.slice(0, openBracketIdx).trim();
      const host = working.slice(openBracketIdx + 1, closeBracketIdx + 1).trim();
      const portStr = working.slice(closeBracketIdx + 2).trim();
      const authParts = authPart.split(":").map((p) => p.trim());
      if (authParts.length === 2) {
        // user:pass:[ipv6]:port
        return pushShorthandEntry(entries, errors, lineNum, host, portStr, authParts[0], authParts[1], type);
      }
    }
  }

  const colonParts = working.split(":").map((p) => p.trim());

  if (colonParts.length === 2) {
    // host:port
    const [host, portStr] = colonParts;
    return pushShorthandEntry(entries, errors, lineNum, host, portStr, "", "", type);
  }

  if (colonParts.length === 4) {
    // Two possibilities: ip:port:user:pass OR user:pass:ip:port
    // Require the "host" slot to look like an IP/hostname AND the "port" slot to be a valid port.
    const isPort1 = /^\d+$/.test(colonParts[1]) && Number(colonParts[1]) >= 1 && Number(colonParts[1]) <= 65535;
    const isPort3 = /^\d+$/.test(colonParts[3]) && Number(colonParts[3]) >= 1 && Number(colonParts[3]) <= 65535;
    const hostLooksLikePart0 = looksLikeHost(colonParts[0]);
    const hostLooksLikePart2 = looksLikeHost(colonParts[2]);

    if (hostLooksLikePart0 && isPort1) {
      // ip:port:user:pass
      const [host, portStr, username, password] = colonParts;
      return pushShorthandEntry(entries, errors, lineNum, host, portStr, username, password, type);
    }
    if (hostLooksLikePart2 && isPort3) {
      // user:pass:ip:port
      const [username, password, host, portStr] = colonParts;
      return pushShorthandEntry(entries, errors, lineNum, host, portStr, username, password, type);
    }
    // Can't determine format
    errors.push({ line: lineNum, reason: "bulkImportErrorInvalidPort" });
    return false;
  }

  // Unknown colon format
  errors.push({ line: lineNum, reason: "bulkImportErrorMissingHost" });
  return false;

[diegosouzapw]

Nice consolidation — removing the duplicate inline parser in ProxyRegistryManager.tsx so the shared parseBulkProxyImport.ts module (which already documented HOST:PORT shorthand in the i18n string) actually runs at all is a real bug fix on its own. The 6 new shorthand formats + protocol-header mode are well covered by 30 passing tests (verified locally: node --import tsx/esm --test tests/unit/proxy-registry-manager.test.ts -> 30/30 pass), lint is clean, and nothing here touches DB/routes/security surfaces. Good to merge.