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

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

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

{buildai_cli-0.3.61 → 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.61 → buildai_cli-0.3.63}/cli/commands/gigcamera.py

@@ -5,12 +5,15 @@ from __future__ import annotations
 import asyncio
 import hashlib
 from datetime import date
+from decimal import Decimal
 from typing import Literal
 from uuid import UUID
 
 import typer
 
+from cli.console import error
 from cli.context import get_cli_context, get_inspection_connection
+from cli.db_broker import BrokerConnectionError
 from cli.ops_init import init_ops_context
 from cli.output import Format, format_option, render
 
@@ -106,6 +109,150 @@ def _idempotency_key(base: str, *, run_suffix: str | None) -> str:
     return f"{base}:{suffix}" if suffix else base
 
 
+async def _stale_consolidated_source_rows(
+    db: object,
+    *,
+    day_ist: date,
+    source_ids: list[UUID] | None,
+) -> list[dict[str, object]]:
+    """List approved source rows not actually covered by same-day consolidation."""
+
+    rows = await db.fetch(
+        """
+        WITH source_rows AS (
+            SELECT source.*
+            FROM finance.payouts source
+            WHERE COALESCE(source.metadata->>'gigcamera_surface', 'false') = 'true'
+              AND source.metadata->>'payout_day_ist' = $1::text
+              AND COALESCE(source.metadata->>'payout_kind', 'participant_earnings') IN (
+                    'participant_earnings',
+                    'participant_referral_bonus'
+              )
+              AND source.status = 'approved'
+              AND ($2::uuid[] IS NULL OR source.id = ANY($2::uuid[]))
+              AND NOT EXISTS (
+                    SELECT 1
+                    FROM finance.disbursements source_disbursement
+                    WHERE source_disbursement.payout_id = source.id
+                      AND source_disbursement.status IN ('settled', 'pending', 'sent', 'processing')
+              )
+        ),
+        stale_sources AS (
+            SELECT DISTINCT ON (source.id)
+                   source.id AS source_id,
+                   source.metadata->>'person_display_name' AS person_display_name,
+                   source.metadata->>'person_id' AS person_id,
+                   COALESCE(
+                       source.metadata->>'payout_kind',
+                       'participant_earnings'
+                   ) AS source_kind,
+                   source.net_amount AS source_amount,
+                   source.metadata->>'gigcamera_provider_state' AS source_provider_state,
+                   source.metadata->>'gigcamera_reason' AS source_provider_reason,
+                   consolidated.id AS consolidated_id,
+                   consolidated.status AS consolidated_status,
+                   consolidated.net_amount AS consolidated_amount,
+                   consolidated.metadata->>'worker_amount_inr' AS consolidated_worker_amount,
+                   consolidated.metadata->>'referral_amount_inr' AS consolidated_referral_amount,
+                   consolidated.metadata->'source_payout_ids' AS consolidated_source_ids,
+                   latest.status AS consolidated_disbursement_status,
+                   latest.reconciled_at AS consolidated_reconciled_at
+            FROM source_rows source
+            JOIN finance.payouts consolidated
+              ON consolidated.org_id = source.org_id
+             AND COALESCE(consolidated.metadata->>'gigcamera_surface', 'false') = 'true'
+             AND consolidated.metadata->>'payout_kind' = 'participant_consolidated'
+             AND consolidated.metadata->>'person_id' = source.metadata->>'person_id'
+             AND consolidated.metadata->>'payout_day_ist' = source.metadata->>'payout_day_ist'
+             AND consolidated.status NOT IN ('voided', 'skipped')
+            LEFT JOIN LATERAL (
+                SELECT status, reconciled_at
+                FROM finance.disbursements disbursement
+                WHERE disbursement.payout_id = consolidated.id
+                ORDER BY attempt_index DESC, created_at DESC
+                LIMIT 1
+            ) latest ON true
+            WHERE NOT (
+                    COALESCE(consolidated.metadata->'source_payout_ids', '[]'::jsonb)
+                    ? source.id::text
+            )
+              AND NOT EXISTS (
+                    SELECT 1
+                    FROM finance.payouts explicit_consolidated
+                    WHERE explicit_consolidated.org_id = source.org_id
+                      AND COALESCE(
+                            explicit_consolidated.metadata->>'gigcamera_surface',
+                            'false'
+                          ) = 'true'
+                      AND explicit_consolidated.metadata->>'payout_kind'
+                            = 'participant_consolidated'
+                      AND explicit_consolidated.metadata->>'person_id'
+                            = source.metadata->>'person_id'
+                      AND explicit_consolidated.metadata->>'payout_day_ist'
+                            = source.metadata->>'payout_day_ist'
+                      AND explicit_consolidated.status NOT IN ('voided', 'skipped')
+                      AND COALESCE(
+                            explicit_consolidated.metadata->'source_payout_ids',
+                            '[]'::jsonb
+                          ) ? source.id::text
+              )
+            ORDER BY source.id, consolidated.created_at DESC, consolidated.id DESC
+        )
+        SELECT *
+        FROM stale_sources
+        ORDER BY person_display_name, source_id
+        """,
+        day_ist.isoformat(),
+        source_ids,
+    )
+    return [dict(row) for row in rows]
+
+
+async def _clear_false_consolidated_submit_blocks(
+    db: object,
+    *,
+    source_ids: list[UUID],
+) -> list[UUID]:
+    """Clear only metadata written by the old false consolidation submit guard."""
+
+    if not source_ids:
+        return []
+    rows = await db.fetch(
+        """
+        UPDATE finance.payouts payout
+        SET metadata = jsonb_strip_nulls(
+                (
+                    COALESCE(payout.metadata, '{}'::jsonb)
+                    - 'gigcamera_provider_state'
+                    - 'gigcamera_provider_review_needed'
+                    - 'gigcamera_reason'
+                    - 'gigcamera_provider_status'
+                    - 'gigcamera_provider_status_code'
+                    - 'gigcamera_retry_policy'
+                    - 'gigcamera_retry_available'
+                    - 'gigcamera_retry_guidance'
+                )
+                || jsonb_build_object(
+                    'gigcamera_consolidation_repair',
+                    jsonb_build_object(
+                        'kind', 'cleared_false_consolidated_submit_block',
+                        'cleared_at', now()::text
+                    )
+                )
+            ),
+            updated_at = now()
+        WHERE payout.id = ANY($1::uuid[])
+          AND payout.status = 'approved'
+          AND payout.metadata->>'gigcamera_provider_state' = 'blocked_destination'
+          AND COALESCE(payout.metadata->>'gigcamera_reason', '')
+                LIKE 'this row has been consolidated into payout %; submit the consolidated row instead'
+        RETURNING payout.id
+        """,
+        source_ids,
+    )
+    return [UUID(str(row["id"])) for row in rows]
+
+
 async def _resolve_program_version_id(
     conn: object,
     *,
@@ -213,6 +360,83 @@ async def _delete_stale_recaps(conn: object, *, program_version_id: UUID) -> Non
         )
 
 
+@app.command("stale-consolidation-sources")
+def stale_consolidation_sources(
+    ctx: typer.Context,
+    day: str = typer.Option(..., "--day", help="IST payout day to inspect (YYYY-MM-DD)."),
+    source_id: list[str] | None = typer.Option(
+        None,
+        "--source-id",
+        help="Optional source payout id to constrain the repair; repeatable.",
+    ),
+    write: bool = typer.Option(
+        False,
+        "--write",
+        help=(
+            "Clear bogus blocked-destination metadata on affected source rows. "
+            "Does not submit payments."
+        ),
+    ),
+    format: Format = format_option(),
+) -> None:
+    """Audit stale source rows left outside settled participant-day consolidation."""
+
+    parsed_day = _parse_ist_day(day, field_name="--day")
+    parsed_source_ids = [UUID(value) for value in source_id or []] or None
+    settings = _settings_for_command(ctx, write=write)
+    _require_internal_admin_for_write(ctx, write=write)
+
+    async def run() -> None:
+        async with get_inspection_connection(settings) as conn:
+            rows = await _stale_consolidated_source_rows(
+                conn,
+                day_ist=parsed_day,
+                source_ids=parsed_source_ids,
+            )
+            cleared_ids: list[UUID] = []
+            if write:
+                async with conn.transaction():
+                    cleared_ids = await _clear_false_consolidated_submit_blocks(
+                        conn,
+                        source_ids=[UUID(str(row["source_id"])) for row in rows],
+                    )
+
+        delta_ids = [str(row["source_id"]) for row in rows]
+        block_repair_candidate_ids = [
+            str(row["source_id"])
+            for row in rows
+            if row.get("source_provider_state") == "blocked_destination"
+            and str(row.get("source_provider_reason") or "").startswith(
+                "this row has been consolidated into payout "
+            )
+        ]
+        delta_total = sum(
+            (row["source_amount"] for row in rows),
+            Decimal("0"),
+        ).quantize(Decimal("0.01"))
+        render(
+            {
+                "dry_run": not write,
+                "day": parsed_day.isoformat(),
+                "delta_payout_count": len(delta_ids),
+                "delta_payout_total_inr": delta_total,
+                "delta_payout_ids": delta_ids,
+                "blocked_destination_repair_candidate_count": len(block_repair_candidate_ids),
+                "blocked_destination_repair_candidate_ids": block_repair_candidate_ids,
+                "cleared_blocked_destination_count": len(cleared_ids),
+                "cleared_blocked_destination_ids": [str(value) for value in cleared_ids],
+                "rows": rows,
+            },
+            format=format,
+        )
+
+    try:
+        asyncio.run(run())
+    except BrokerConnectionError as exc:
+        error(str(exc))
+        raise typer.Exit(1) from None
+
+
 @app.command("vlm-purge-stale-recaps")
 def vlm_purge_stale_recaps(
     ctx: typer.Context,

{buildai_cli-0.3.61 → buildai_cli-0.3.63}/cli/context.py

@@ -220,10 +220,13 @@ def resolve_broker_config(
 
     resolved_profile = resolve_cli_profile(profile)
     db_identity_profile = db_identity_profile_for_cli_profile(resolved_profile)
-    config = _fixed_profile_connection_config(settings, profile=db_identity_profile)
-
-    if config is None and resolved_profile in _ADMIN_DB_IDENTITY_PROFILES:
-        config = resolve_admin_connection_config(settings)
+    if resolved_profile in _ADMIN_DB_IDENTITY_PROFILES:
+        config = resolve_admin_connection_config(settings) or _fixed_profile_connection_config(
+            settings,
+            profile=db_identity_profile,
+        )
+    else:
+        config = _fixed_profile_connection_config(settings, profile=db_identity_profile)
 
     if config is None:
         if resolved_profile in _ADMIN_DB_IDENTITY_PROFILES:

{buildai_cli-0.3.61 → 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.61 → buildai_cli-0.3.63}/pyproject.toml

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