devlinker 1.2.1__tar.gz → 1.2.3__tar.gz

{devlinker-1.2.1 → devlinker-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devlinker
-Version: 1.2.1
+Version: 1.2.3
 Summary: AI-powered linking and automation tool
 Author-email: Mani <mani1028@users.noreply.github.com>
 Requires-Python: >=3.7
@@ -20,6 +20,7 @@ Dev Linker runs frontend and backend dev servers, proxies both through a single
 - Auto-detects backend runtime (Docker Compose, Dockerfile, Node, or Python)
 - Auto-starts Python/Node backends; Docker is manual by default for reliability
 - Detects common frontend/backend ports
+- Detects Vite frontend across dynamic fallback ports (5173-5190, plus common alternatives)
 - Supports Docker backend port auto-detection
 - Works with dynamic container host ports
 - No config needed for standard Flask/Docker flows
@@ -67,7 +68,7 @@ devlinker
 Typical startup output:
 
 ```text
-Dev Linker v0.2.0
+Dev Linker v1.2.2
 
 [INFO] Mode: Auto (Flask + Docker detection)
 [INFO] Booting local services...
@@ -122,6 +123,18 @@ Run local-only mode without tunnel:
 devlinker --no-tunnel
 ```
 
+Interactive backend selection (when local and Docker are both detected):
+
+```bash
+devlinker --interactive-backend
+```
+
+Disable interactive backend selection (keeps local-first behavior):
+
+```bash
+devlinker --no-interactive-backend
+```
+
 If port 8000 is already in use:
 
 ```bash
@@ -139,6 +152,12 @@ Default behavior also tries fallback ports automatically when 8000 is busy:
 - 8002
 - 18000
 
+Frontend detection behavior:
+
+- Scans Vite defaults and fallback ports (`5173` through `5190`)
+- Also checks common alternatives (`3000`, `4173`, `8080`)
+- Retries during startup to catch slow boot cases
+
 ## Important Frontend Rule
 
 Frontend requests must use relative API paths:
@@ -154,9 +173,14 @@ Do not hardcode backend host URLs in frontend code.
 Backend port detection runs in this order:
 
 1. Check localhost port 5000
-2. If not found, check Docker port mappings for `->5000/tcp`
-3. Use the mapped host port automatically
-4. If nothing is found, print next-step guidance and exit
+2. If not found, parse all Docker host-to-container port mappings
+3. Rank containers by likely backend identity (name hints like backend/api plus project-name hints)
+4. Use the best mapped host port automatically, even when internal port is not 5000
+5. If nothing is found, print next-step guidance and exit
+
+When both Local and Docker backends are available, Dev Linker prompts you to choose one (TTY mode) unless `--no-interactive-backend` is used.
+
+If backend detection fails, Dev Linker prints a clear checklist showing what it checked and how to recover.
 
 Detection messages include source labels, for example:
 

{devlinker-1.2.1 → devlinker-1.2.3}/README.md

@@ -8,6 +8,7 @@ Dev Linker runs frontend and backend dev servers, proxies both through a single
 - Auto-detects backend runtime (Docker Compose, Dockerfile, Node, or Python)
 - Auto-starts Python/Node backends; Docker is manual by default for reliability
 - Detects common frontend/backend ports
+- Detects Vite frontend across dynamic fallback ports (5173-5190, plus common alternatives)
 - Supports Docker backend port auto-detection
 - Works with dynamic container host ports
 - No config needed for standard Flask/Docker flows
@@ -55,7 +56,7 @@ devlinker
 Typical startup output:
 
 ```text
-Dev Linker v0.2.0
+Dev Linker v1.2.2
 
 [INFO] Mode: Auto (Flask + Docker detection)
 [INFO] Booting local services...
@@ -110,6 +111,18 @@ Run local-only mode without tunnel:
 devlinker --no-tunnel
 ```
 
+Interactive backend selection (when local and Docker are both detected):
+
+```bash
+devlinker --interactive-backend
+```
+
+Disable interactive backend selection (keeps local-first behavior):
+
+```bash
+devlinker --no-interactive-backend
+```
+
 If port 8000 is already in use:
 
 ```bash
@@ -127,6 +140,12 @@ Default behavior also tries fallback ports automatically when 8000 is busy:
 - 8002
 - 18000
 
+Frontend detection behavior:
+
+- Scans Vite defaults and fallback ports (`5173` through `5190`)
+- Also checks common alternatives (`3000`, `4173`, `8080`)
+- Retries during startup to catch slow boot cases
+
 ## Important Frontend Rule
 
 Frontend requests must use relative API paths:
@@ -142,9 +161,14 @@ Do not hardcode backend host URLs in frontend code.
 Backend port detection runs in this order:
 
 1. Check localhost port 5000
-2. If not found, check Docker port mappings for `->5000/tcp`
-3. Use the mapped host port automatically
-4. If nothing is found, print next-step guidance and exit
+2. If not found, parse all Docker host-to-container port mappings
+3. Rank containers by likely backend identity (name hints like backend/api plus project-name hints)
+4. Use the best mapped host port automatically, even when internal port is not 5000
+5. If nothing is found, print next-step guidance and exit
+
+When both Local and Docker backends are available, Dev Linker prompts you to choose one (TTY mode) unless `--no-interactive-backend` is used.
+
+If backend detection fails, Dev Linker prints a clear checklist showing what it checked and how to recover.
 
 Detection messages include source labels, for example:
 

{devlinker-1.2.1 → devlinker-1.2.3}/devlinker/detector.py

@@ -41,6 +41,18 @@ def _pick_open_port(
     return None
 
 
+def _ordered_unique_ports(*port_groups: Iterable[int]) -> list[int]:
+    ordered: list[int] = []
+    seen: set[int] = set()
+    for group in port_groups:
+        for port in group:
+            if port in seen:
+                continue
+            seen.add(port)
+            ordered.append(port)
+    return ordered
+
+
 def detect_ports(
     frontend: Optional[int] = None,
     backend: Optional[int] = None,
@@ -48,8 +60,13 @@ def detect_ports(
     delay_seconds: float = 1.0,
 ) -> Tuple[Optional[int], Optional[int]]:
     """Detect frontend and backend ports with retry support for slow startups."""
-    frontend_ports = [5173, 5174, 5175, 5176, 5177, 3000, 8080]
-    backend_ports = [5000, 8081]
+    frontend_ports = _ordered_unique_ports(
+        range(5173, 5191),
+        (3000, 4173, 8080),
+    )
+    backend_ports = _ordered_unique_ports(
+        (5000, 8000, 8001, 8080, 8081, 3001),
+    )
 
     selected_frontend = frontend
     selected_backend = backend

{devlinker-1.2.1 → devlinker-1.2.3}/devlinker/main.py

@@ -87,6 +87,12 @@ def _print_summary(
     help="Auto-start Docker backends (manual Docker is the default).",
 )
 @click.option("--no-tunnel", is_flag=True, help="Skip public tunnel and run local proxy only.")
+@click.option(
+    "--interactive-backend/--no-interactive-backend",
+    default=True,
+    show_default=True,
+    help="Prompt to choose backend when local and Docker candidates are both available.",
+)
 @click.option("--debug", is_flag=True, hidden=True, help="Enable debug logging.")
 def cli(
     frontend: int | None,
@@ -94,6 +100,7 @@ def cli(
     proxy_port: int,
     auto_start_docker: bool,
     no_tunnel: bool,
+    interactive_backend: bool,
     debug: bool,
 ) -> None:
     started = time.perf_counter()
@@ -106,6 +113,7 @@ def cli(
     backend_port = detect_backend_port(
         default_port=5000,
         override_port=backend_port_override,
+        interactive=interactive_backend,
         debug=debug,
     )
     if backend_port is None:

{devlinker-1.2.1 → devlinker-1.2.3}/devlinker/runner.py

@@ -36,34 +36,71 @@ def is_port_open(port: int) -> bool:
         return sock.connect_ex(("localhost", port)) == 0
 
 
-def _extract_host_port(ports_text: str, container_port: int) -> int | None:
-    # Covers typical Docker mappings: 0.0.0.0:32768->5000/tcp, [::]:32768->5000/tcp
-    pattern = rf"(?:0\.0\.0\.0|127\.0\.0\.1|\[::\]|::):(\d+)->{container_port}/tcp"
-    match = re.search(pattern, ports_text)
-    if match:
-        return int(match.group(1))
-    return None
+def _extract_port_mappings(ports_text: str) -> list[tuple[int, int]]:
+    """
+    Extracts host and container ports from docker ps output.
+    Handles:
+      - 0.0.0.0:8000->8000/tcp
+      - [::]:8000->8000/tcp
+      - :::8000->8000/tcp
+      - 8000->8000/tcp
+    
+    Skips unmapped ports (e.g., "8000/tcp" without a host binding).
+    """
+    # Skip if no host mappings present (unmapped ports are not useful externally).
+    if "->" not in ports_text:
+        return []
+    
+    # This regex specifically captures the host port (Group 1) and container port (Group 2)
+    # while optionally ignoring any IP binding prefix.
+    pattern = re.compile(
+        r"(?:(?:\d{1,3}(?:\.\d{1,3}){3}|\[[a-fA-F0-9:]+\]|:::):)?(\d+)->(\d+)/(?:tcp|udp)"
+    )
+    
+    mappings: list[tuple[int, int]] = []
+    for match in pattern.finditer(ports_text):
+        host_port = int(match.group(1))
+        container_port = int(match.group(2))
+        mappings.append((host_port, container_port))
+    return mappings
+
+
+def _container_priority(name: str, container_port: int, default_container_port: int) -> int:
+    score = 0
+    lowered_name = name.lower()
+    if "backend" in lowered_name:
+        score += 6
+    if any(token in lowered_name for token in ("api", "server", "svc", "service")):
+        score += 3
+    if container_port == default_container_port:
+        score += 2
+
+    project_hint = Path.cwd().name.lower()
+    if len(project_hint) >= 3 and project_hint in lowered_name:
+        score += 5
 
+    return score
 
-def get_docker_backend_port(
+
+def get_docker_backend_candidates(
     default_container_port: int = 5000,
     debug: bool = False,
-) -> tuple[int, str, int] | None:
+) -> list[tuple[str, int, int]]:
     try:
         output = subprocess.check_output(  # noqa: S603
             ["docker", "ps", "--format", "{{.Names}}\t{{.Ports}}"],
             stderr=subprocess.DEVNULL,
         ).decode("utf-8", errors="ignore")
     except Exception:
-        return None
+        return []
 
     _debug_log(debug, "docker ps port map output:")
     if debug:
         for raw_line in output.splitlines():
             _debug_log(True, raw_line)
 
-    candidates: list[tuple[str, int]] = []
-    for line in output.splitlines():
+    candidates: list[tuple[str, int, int, int]] = []
+    for line_index, line in enumerate(output.splitlines()):
         stripped = line.strip()
         if not stripped:
             continue
@@ -76,23 +113,86 @@ def get_docker_backend_port(
                 continue
             name, ports = parts[0], parts[1]
 
-        host_port = _extract_host_port(ports, default_container_port)
-        if host_port is not None:
-            candidates.append((name, host_port))
+        mappings = _extract_port_mappings(ports)
+        if not mappings:
+            continue
+
+        for host_port, container_port in mappings:
+            candidates.append((name, host_port, container_port, line_index))
+            _debug_log(
+                debug,
+                (
+                    f"Candidate Docker port mapping: container='{name}', "
+                    f"host={host_port}, container={container_port}"
+                ),
+            )
 
     if not candidates:
-        return None
+        return []
+
+    # Score candidates by likely backend identity and prefer newest on ties.
+    ranked = sorted(
+        candidates,
+        key=lambda item: (-_container_priority(item[0], item[2], default_container_port), item[3]),
+    )
+    ordered: list[tuple[str, int, int]] = []
+    seen: set[tuple[str, int, int]] = set()
+    for name, host_port, container_port, _line_index in ranked:
+        key = (name, host_port, container_port)
+        if key in seen:
+            continue
+        seen.add(key)
+        ordered.append(key)
+
+    if ordered:
+        name, host_port, container_port = ordered[0]
+        _debug_log(
+            debug,
+            (
+                f"Selected Docker container '{name}' with host port {host_port} "
+                f"(container port {container_port})"
+            ),
+        )
+
+    return ordered
 
-    # Prefer container names that look like backend services.
-    for name, port in candidates:
-        if "backend" in name.lower():
-            _debug_log(debug, f"Selected Docker backend container '{name}' on host port {port}")
-            return port, name, len(candidates)
 
-    # docker ps is already newest-first; fallback to first match.
-    name, port = candidates[0]
-    _debug_log(debug, f"Selected first Docker match '{name}' on host port {port}")
-    return port, name, len(candidates)
+def _choose_backend_candidate(
+    local_port: int,
+    docker_candidates: list[tuple[str, int, int]],
+    debug: bool = False,
+) -> tuple[str, int, str | None, int | None]:
+    print("[INFO] Multiple backends detected:")
+    print(f"1. Local (localhost:{local_port})")
+    for index, (container_name, host_port, container_port) in enumerate(docker_candidates, start=2):
+        print(f"{index}. Docker: {container_name} (localhost:{host_port} -> {container_port})")
+    print("[INFO] Select backend [default: 1]: ", end="", flush=True)
+
+    try:
+        raw = input().strip()
+    except EOFError:
+        _debug_log(debug, "Interactive prompt unavailable (EOF); using local backend fallback")
+        return "local", local_port, None, None
+
+    if raw == "":
+        return "local", local_port, None, None
+
+    try:
+        selection = int(raw)
+    except ValueError:
+        _log("warn", "Invalid selection; using local backend")
+        return "local", local_port, None, None
+
+    if selection == 1:
+        return "local", local_port, None, None
+
+    docker_index = selection - 2
+    if 0 <= docker_index < len(docker_candidates):
+        container_name, host_port, container_port = docker_candidates[docker_index]
+        return "docker", host_port, container_name, container_port
+
+    _log("warn", "Selection out of range; using local backend")
+    return "local", local_port, None, None
 
 
 def _wait_for_port(port: int, retries: int = 5, delay_seconds: float = 1.0, debug: bool = False) -> bool:
@@ -107,6 +207,7 @@ def _wait_for_port(port: int, retries: int = 5, delay_seconds: float = 1.0, debu
 def detect_backend_port(
     default_port: int = 5000,
     override_port: int | None = None,
+    interactive: bool = False,
     debug: bool = False,
 ) -> int | None:
     started = time.perf_counter()
@@ -118,32 +219,63 @@ def detect_backend_port(
 
     _log("info", "Checking backend...")
     _debug_log(debug, f"Scanned local port: {default_port}")
-    if is_port_open(default_port):
-        _log("ok", f"Backend detected (Local) -> port {default_port}")
-        _log("info", f"Backend detected in {time.perf_counter() - started:.1f}s")
-        return default_port
 
-    _log("warn", f"Backend not found on port {default_port}")
+    local_open = is_port_open(default_port)
+    if not local_open:
+        _log("warn", f"Backend not found on port {default_port}")
+
     _log("info", "Checking Docker containers...")
     _debug_log(debug, f"Scanned Docker container target port: {default_port}")
 
-    docker_match = get_docker_backend_port(default_container_port=default_port, debug=debug)
-    if docker_match is not None:
-        docker_port, container_name, match_count = docker_match
-        if match_count > 1:
-            _log("warn", "Multiple backend containers found")
+    docker_candidates = get_docker_backend_candidates(default_container_port=default_port, debug=debug)
+
+    if local_open and docker_candidates:
+        if interactive and sys.stdin.isatty():
+            source, selected_port, container_name, container_port = _choose_backend_candidate(
+                local_port=default_port,
+                docker_candidates=docker_candidates,
+                debug=debug,
+            )
+            if source == "local":
+                _log("ok", f"Backend detected (Local) -> port {selected_port}")
+                _log("info", f"Backend detected in {time.perf_counter() - started:.1f}s")
+                return selected_port
+
+            if _wait_for_port(selected_port, retries=5, delay_seconds=1.0, debug=debug):
+                _log("ok", f"Backend detected (Docker: {container_name}) -> port {selected_port}")
+                _debug_log(debug, f"Selected Docker container port: {container_port}")
+                _log("info", f"Backend detected in {time.perf_counter() - started:.1f}s")
+                return selected_port
+            _log("warn", f"Docker mapped port {selected_port} found but backend is not ready yet")
+        else:
+            _log("info", f"Docker candidate also detected: {docker_candidates[0][0]} -> {docker_candidates[0][1]}")
+            _debug_log(debug, "Interactive backend picker disabled or no TTY; using local-first priority")
+            _log("ok", f"Backend detected (Local) -> port {default_port}")
+            _log("info", f"Backend detected in {time.perf_counter() - started:.1f}s")
+            return default_port
+
+    if local_open:
+        _log("ok", f"Backend detected (Local) -> port {default_port}")
+        _log("info", f"Backend detected in {time.perf_counter() - started:.1f}s")
+        return default_port
+
+    if docker_candidates:
+        container_name, docker_port, container_port = docker_candidates[0]
+        if len(docker_candidates) > 1:
+            _log("warn", f"Multiple Docker containers published ports ({len(docker_candidates)} candidates)")
             _log("info", f"Using: {container_name}")
         if _wait_for_port(docker_port, retries=5, delay_seconds=1.0, debug=debug):
-            _log("ok", f"Backend detected (Docker) -> port {docker_port}")
+            _log("ok", f"Backend detected (Docker: {container_name}) -> port {docker_port}")
+            _debug_log(debug, f"Selected Docker container port: {container_port}")
             _log("info", f"Backend detected in {time.perf_counter() - started:.1f}s")
             return docker_port
         _log("warn", f"Docker mapped port {docker_port} found but backend is not ready yet")
 
-    _log("error", "Backend not detected")
+    _log("error", "No backend found")
     print("Checked:")
     print(f"- localhost:{default_port}")
     print("- Docker containers")
-    print("Next step:")
+    print("Tip:")
     print("  - Start Flask: python app.py")
     print("  - OR expose Docker port: -p 5000:5000")
     return None

{devlinker-1.2.1 → devlinker-1.2.3}/devlinker.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devlinker
-Version: 1.2.1
+Version: 1.2.3
 Summary: AI-powered linking and automation tool
 Author-email: Mani <mani1028@users.noreply.github.com>
 Requires-Python: >=3.7
@@ -20,6 +20,7 @@ Dev Linker runs frontend and backend dev servers, proxies both through a single
 - Auto-detects backend runtime (Docker Compose, Dockerfile, Node, or Python)
 - Auto-starts Python/Node backends; Docker is manual by default for reliability
 - Detects common frontend/backend ports
+- Detects Vite frontend across dynamic fallback ports (5173-5190, plus common alternatives)
 - Supports Docker backend port auto-detection
 - Works with dynamic container host ports
 - No config needed for standard Flask/Docker flows
@@ -67,7 +68,7 @@ devlinker
 Typical startup output:
 
 ```text
-Dev Linker v0.2.0
+Dev Linker v1.2.2
 
 [INFO] Mode: Auto (Flask + Docker detection)
 [INFO] Booting local services...
@@ -122,6 +123,18 @@ Run local-only mode without tunnel:
 devlinker --no-tunnel
 ```
 
+Interactive backend selection (when local and Docker are both detected):
+
+```bash
+devlinker --interactive-backend
+```
+
+Disable interactive backend selection (keeps local-first behavior):
+
+```bash
+devlinker --no-interactive-backend
+```
+
 If port 8000 is already in use:
 
 ```bash
@@ -139,6 +152,12 @@ Default behavior also tries fallback ports automatically when 8000 is busy:
 - 8002
 - 18000
 
+Frontend detection behavior:
+
+- Scans Vite defaults and fallback ports (`5173` through `5190`)
+- Also checks common alternatives (`3000`, `4173`, `8080`)
+- Retries during startup to catch slow boot cases
+
 ## Important Frontend Rule
 
 Frontend requests must use relative API paths:
@@ -154,9 +173,14 @@ Do not hardcode backend host URLs in frontend code.
 Backend port detection runs in this order:
 
 1. Check localhost port 5000
-2. If not found, check Docker port mappings for `->5000/tcp`
-3. Use the mapped host port automatically
-4. If nothing is found, print next-step guidance and exit
+2. If not found, parse all Docker host-to-container port mappings
+3. Rank containers by likely backend identity (name hints like backend/api plus project-name hints)
+4. Use the best mapped host port automatically, even when internal port is not 5000
+5. If nothing is found, print next-step guidance and exit
+
+When both Local and Docker backends are available, Dev Linker prompts you to choose one (TTY mode) unless `--no-interactive-backend` is used.
+
+If backend detection fails, Dev Linker prints a clear checklist showing what it checked and how to recover.
 
 Detection messages include source labels, for example:
 

{devlinker-1.2.1 → devlinker-1.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devlinker"
-version = "1.2.1"
+version = "1.2.3"
 description = "AI-powered linking and automation tool"
 authors = [
     { name = "Mani", email = "mani1028@users.noreply.github.com" }