buildai-cli 0.3.62__tar.gz → 0.3.63__tar.gz

{buildai_cli-0.3.62 → buildai_cli-0.3.63}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: buildai-cli
-Version: 0.3.62
+Version: 0.3.63
 Summary: Build AI CLI (Typer)
 Requires-Python: >=3.11
 Requires-Dist: httpx>=0.27.0

{buildai_cli-0.3.62 → buildai_cli-0.3.63}/cli/auth_local.py

@@ -353,12 +353,27 @@ def _fixed_targets_for_environment(
 def _run_command(argv: list[str], *, timeout: int = 20) -> CommandResult:
     """Run one external command with bounded time and normalized output fields."""
 
-    completed = subprocess.run(
-        argv,
-        capture_output=True,
-        text=True,
-        timeout=timeout,
-    )
+    try:
+        completed = subprocess.run(
+            argv,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+        )
+    except FileNotFoundError as exc:
+        return CommandResult(
+            argv=tuple(argv),
+            returncode=127,
+            stdout="",
+            stderr=f"{argv[0]} is not installed or is not on PATH: {exc}",
+        )
+    except subprocess.TimeoutExpired as exc:
+        return CommandResult(
+            argv=tuple(argv),
+            returncode=124,
+            stdout=(exc.stdout or "").strip() if isinstance(exc.stdout, str) else "",
+            stderr=(exc.stderr or "").strip() if isinstance(exc.stderr, str) else "Command timed out.",
+        )
     return CommandResult(
         argv=tuple(argv),
         returncode=completed.returncode,

{buildai_cli-0.3.62 → buildai_cli-0.3.63}/cli/db_broker.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-import fcntl
+import ctypes
 import hashlib
 import json
 import os
@@ -20,6 +20,11 @@ from typing import Any, Iterator
 import asyncpg
 from infra.settings import Settings
 
+if os.name == "nt":
+    import msvcrt
+else:
+    import fcntl
+
 REPO_ROOT = Path(__file__).resolve().parents[3]
 LEGACY_STATE_DIR = REPO_ROOT / ".buildai" / "db-brokers"
 STATE_DIR = Path(os.getenv("BUILDAI_DB_BROKER_STATE_DIR", Path.home() / ".buildai" / "db-brokers"))
@@ -192,6 +197,9 @@ def proxy_is_listening(*, host: str, port: int) -> bool:
 def process_is_running(pid: int) -> bool:
     """Return whether the broker PID still exists."""
 
+    if os.name == "nt":
+        return _windows_process_is_running(pid)
+
     try:
         os.kill(pid, 0)
     except ProcessLookupError:
@@ -201,18 +209,59 @@ def process_is_running(pid: int) -> bool:
     return True
 
 
+def _windows_process_is_running(pid: int) -> bool:
+    """Check a Windows process handle without sending a signal to the process."""
+
+    if pid <= 0:
+        return False
+
+    synchronize = 0x00100000
+    wait_timeout = 0x00000102
+    kernel32 = ctypes.windll.kernel32
+    handle = kernel32.OpenProcess(synchronize, False, int(pid))
+    if not handle:
+        return False
+    try:
+        return kernel32.WaitForSingleObject(handle, 0) == wait_timeout
+    finally:
+        kernel32.CloseHandle(handle)
+
+
+def _lock_file(handle: Any) -> None:
+    """Acquire an exclusive machine-local lock for the opened lock file."""
+
+    if os.name == "nt":
+        handle.seek(0)
+        handle.write(b"\0")
+        handle.flush()
+        handle.seek(0)
+        msvcrt.locking(handle.fileno(), msvcrt.LK_LOCK, 1)
+        return
+    fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
+
+
+def _unlock_file(handle: Any) -> None:
+    """Release a lock previously acquired by ``_lock_file``."""
+
+    if os.name == "nt":
+        handle.seek(0)
+        msvcrt.locking(handle.fileno(), msvcrt.LK_UNLCK, 1)
+        return
+    fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+
+
 @contextmanager
 def _broker_lock(config: BrokerConfig) -> Iterator[None]:
     """Serialize local broker startup for one profile identity on this machine."""
 
     STATE_DIR.mkdir(parents=True, exist_ok=True)
     lock_path = STATE_DIR / f"{config.identity}.lock"
-    with lock_path.open("w", encoding="utf-8") as handle:
-        fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
+    with lock_path.open("a+b") as handle:
+        _lock_file(handle)
         try:
             yield
         finally:
-            fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+            _unlock_file(handle)
 
 
 def _state_paths(config: BrokerConfig) -> tuple[Path, ...]:
@@ -286,6 +335,9 @@ def _write_broker_state(config: BrokerConfig, state: BrokerState) -> None:
 def _process_command(pid: int) -> list[str]:
     """Return argv-like command text for a local PID when the OS exposes it."""
 
+    if os.name == "nt":
+        return _windows_process_command(pid)
+
     try:
         completed = subprocess.run(
             ["ps", "-p", str(pid), "-o", "command="],
@@ -307,9 +359,44 @@ def _process_command(pid: int) -> list[str]:
         return raw.split()
 
 
+def _windows_process_command(pid: int) -> list[str]:
+    """Return command-line tokens for a Windows process when PowerShell exposes it."""
+
+    try:
+        completed = subprocess.run(
+            [
+                "powershell",
+                "-NoProfile",
+                "-Command",
+                (
+                    "$p = Get-CimInstance Win32_Process -Filter "
+                    f"'ProcessId = {int(pid)}'; if ($p) {{ $p.CommandLine }}"
+                ),
+            ],
+            capture_output=True,
+            text=True,
+            timeout=2,
+            check=False,
+        )
+    except Exception:
+        return []
+    if completed.returncode != 0:
+        return []
+    raw = completed.stdout.strip()
+    if not raw:
+        return []
+    try:
+        return shlex.split(raw, posix=False)
+    except ValueError:
+        return raw.split()
+
+
 def _listening_pids(*, host: str, port: int) -> list[int]:
     """Return local PIDs listening on a TCP port when OS tools expose them."""
 
+    if os.name == "nt":
+        return _windows_listening_pids(host=host, port=port)
+
     if shutil.which("lsof") is not None:
         try:
             completed = subprocess.run(
@@ -355,6 +442,41 @@ def _listening_pids(*, host: str, port: int) -> list[int]:
     return []
 
 
+def _windows_listening_pids(*, host: str, port: int) -> list[int]:
+    """Return Windows PIDs listening on a local TCP port via netstat."""
+
+    try:
+        completed = subprocess.run(
+            ["netstat", "-ano", "-p", "tcp"],
+            capture_output=True,
+            text=True,
+            timeout=2,
+            check=False,
+        )
+    except Exception:
+        return []
+    if completed.returncode != 0:
+        return []
+
+    pids: list[int] = []
+    port_suffix = f":{port}"
+    for line in completed.stdout.splitlines():
+        parts = line.split()
+        if len(parts) < 5 or parts[0].upper() != "TCP":
+            continue
+        local_address = parts[1]
+        state = parts[3].upper()
+        if state != "LISTENING" or not local_address.endswith(port_suffix):
+            continue
+        if host not in ("0.0.0.0", "::", "localhost") and not local_address.startswith(host):
+            continue
+        try:
+            pids.append(int(parts[-1]))
+        except ValueError:
+            continue
+    return pids
+
+
 def _listener_processes(*, host: str, port: int) -> list[ListenerProcess]:
     """Return process metadata for listeners on the broker endpoint."""
 
@@ -382,7 +504,8 @@ def _is_matching_proxy_process(process: ListenerProcess, config: BrokerConfig) -
     command = process.command
     if not command:
         return False
-    if Path(command[0]).name != "alloydb-auth-proxy":
+    executable_name = Path(command[0].strip('"')).name.lower()
+    if executable_name not in {"alloydb-auth-proxy", "alloydb-auth-proxy.exe"}:
         return False
     if config.instance_uri not in command:
         return False
@@ -435,6 +558,17 @@ def _broker_command(config: BrokerConfig, *, proxy_binary: str) -> list[str]:
     return command
 
 
+def _proxy_popen_kwargs() -> dict[str, Any]:
+    """Return process-detach kwargs appropriate for the current platform."""
+
+    if os.name != "nt":
+        return {"start_new_session": True}
+    creationflags = 0
+    creationflags |= getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0)
+    creationflags |= getattr(subprocess, "DETACHED_PROCESS", 0)
+    return {"creationflags": creationflags}
+
+
 def _recent_broker_log(config: BrokerConfig, *, max_bytes: int = 12000) -> str:
     """Return the recent proxy log text that explains connection resets."""
 
@@ -565,8 +699,8 @@ def ensure_broker(config: BrokerConfig) -> BrokerState:
                 command,
                 stdout=log_file,
                 stderr=log_file,
-                start_new_session=True,
                 env=os.environ.copy(),
+                **_proxy_popen_kwargs(),
             )
 
         deadline = time.monotonic() + 15.0

{buildai_cli-0.3.62 → buildai_cli-0.3.63}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "buildai-cli"
-version = "0.3.62"
+version = "0.3.63"
 description = "Build AI CLI (Typer)"
 requires-python = ">=3.11"
 dependencies = [