arga-cli 0.1.6__tar.gz → 0.1.7__tar.gz

{arga_cli-0.1.6 → arga_cli-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arga-cli
-Version: 0.1.6
+Version: 0.1.7
 Summary: Command-line interface for Arga authentication, MCP installation, and browser validation
 Author: Arga Labs
 Project-URL: Homepage, https://github.com/ArgaLabs/arga-cli
@@ -33,7 +33,6 @@ Requires-Dist: rich>=13.0.0
 - Starts URL validation runs from the terminal.
 - Starts pull request validation runs from the terminal.
 - Wraps `git commit` and `git push` with Arga skip-validation helpers.
-- Starts and inspects Arga app scans.
 
 ## Installation 
 
@@ -112,14 +111,6 @@ arga validate config arga-labs/validation-server
 arga validate config set arga-labs/validation-server --trigger branch --branch main --comments on
 ```
 
-Start an app scan and inspect it later:
-
-```bash
-arga scan https://demo-app.com --budget 200
-arga scan status <run_id>
-arga scan report <run_id>
-```
-
 List and inspect recent validation runs:
 
 ```bash
@@ -173,19 +164,6 @@ arga test url \
 
 Both `--email` and `--password` must be supplied together.
 
-### App Scans
-
-```bash
-arga scan https://demo-app.com --budget 200
-arga scan status <run_id>
-arga scan report <run_id>
-```
-
-- `arga scan <url>` starts an app scan, waits for the generated scan plan to be ready, and auto-approves it so execution can begin.
-- `--budget` controls the red-team action budget and defaults to `200`.
-- `arga scan status <run_id>` prints the current run status and anomaly count.
-- `arga scan report <run_id>` prints the final JSON report once the scan has completed.
-
 ### Validation Runs
 
 ```bash

{arga_cli-0.1.6 → arga_cli-0.1.7}/README.md

@@ -11,7 +11,6 @@
 - Starts URL validation runs from the terminal.
 - Starts pull request validation runs from the terminal.
 - Wraps `git commit` and `git push` with Arga skip-validation helpers.
-- Starts and inspects Arga app scans.
 
 ## Installation 
 
@@ -90,14 +89,6 @@ arga validate config arga-labs/validation-server
 arga validate config set arga-labs/validation-server --trigger branch --branch main --comments on
 ```
 
-Start an app scan and inspect it later:
-
-```bash
-arga scan https://demo-app.com --budget 200
-arga scan status <run_id>
-arga scan report <run_id>
-```
-
 List and inspect recent validation runs:
 
 ```bash
@@ -151,19 +142,6 @@ arga test url \
 
 Both `--email` and `--password` must be supplied together.
 
-### App Scans
-
-```bash
-arga scan https://demo-app.com --budget 200
-arga scan status <run_id>
-arga scan report <run_id>
-```
-
-- `arga scan <url>` starts an app scan, waits for the generated scan plan to be ready, and auto-approves it so execution can begin.
-- `--budget` controls the red-team action budget and defaults to `200`.
-- `arga scan status <run_id>` prints the current run status and anomaly count.
-- `arga scan report <run_id>` prints the final JSON report once the scan has completed.
-
 ### Validation Runs
 
 ```bash

{arga_cli-0.1.6 → arga_cli-0.1.7}/arga_cli/main.py

@@ -25,6 +25,7 @@ WIZARD_SESSION_FILE = ".arga-session.json"
 WIZARD_SESSION_PATH = Path(WIZARD_SESSION_FILE)
 POLL_INTERVAL_SECONDS = 2.0
 POLL_TIMEOUT_SECONDS = 600.0
+URL_VALIDATION_START_TIMEOUT_SECONDS = 60.0
 SKIP_TRAILER = "[skip arga]"
 
 
@@ -82,15 +83,17 @@ class ApiClient:
         self,
         *,
         url: str,
-        prompt: str,
+        prompt: str | None = None,
         email: str | None = None,
         password: str | None = None,
         ttl_minutes: int | None = None,
+        scenario_id: str | None = None,
+        provision_id: str | None = None,
+        twins: list[str] | None = None,
     ) -> dict[str, str]:
-        payload: dict[str, object] = {
-            "url": url,
-            "prompt": prompt,
-        }
+        payload: dict[str, object] = {"url": url}
+        if prompt is not None:
+            payload["prompt"] = prompt
         if email or password:
             payload["credentials"] = {
                 "email": email or "",
@@ -98,13 +101,67 @@ class ApiClient:
             }
         if ttl_minutes is not None:
             payload["ttl_minutes"] = ttl_minutes
+        if scenario_id:
+            payload["scenario_id"] = scenario_id
+        if provision_id:
+            payload["provision_id"] = provision_id
+        if twins:
+            payload["twins"] = twins
         response = self._client.post(
             f"{self._api_url}/validate/url-run",
             json=payload,
             headers=self._auth_headers(),
+            timeout=URL_VALIDATION_START_TIMEOUT_SECONDS,
         )
         return self._parse_json(response, "Failed to start URL validation")
 
+    def list_scenarios(self, *, include_presets: bool = False) -> list[dict[str, Any]]:
+        params: dict[str, str] = {}
+        if include_presets:
+            params["include_presets"] = "true"
+        response = self._client.get(
+            f"{self._api_url}/scenarios",
+            params=params,
+            headers=self._auth_headers(),
+        )
+        data = self._parse_json(response, "Failed to list scenarios")
+        if not isinstance(data, list):
+            raise CliError("Unexpected response from /scenarios")
+        return data
+
+    def create_scenario(
+        self,
+        *,
+        name: str,
+        prompt: str | None = None,
+        description: str | None = None,
+        twins: list[str] | None = None,
+        tags: list[str] | None = None,
+    ) -> dict[str, Any]:
+        payload: dict[str, Any] = {"name": name}
+        if prompt is not None:
+            payload["prompt"] = prompt
+        if description is not None:
+            payload["description"] = description
+        if twins:
+            payload["twins"] = twins
+        if tags:
+            payload["tags"] = tags
+        response = self._client.post(
+            f"{self._api_url}/scenarios",
+            json=payload,
+            headers=self._auth_headers(),
+            timeout=URL_VALIDATION_START_TIMEOUT_SECONDS,
+        )
+        return self._parse_json(response, "Failed to create scenario")
+
+    def delete_scenario(self, scenario_id: str) -> dict[str, str]:
+        response = self._client.delete(
+            f"{self._api_url}/scenarios/{scenario_id}",
+            headers=self._auth_headers(),
+        )
+        return self._parse_json(response, "Failed to delete scenario")
+
     def start_pr_validation(
         self,
         *,
@@ -122,22 +179,6 @@ class ApiClient:
         )
         return self._parse_json(response, "Failed to start PR validation")
 
-    def start_redteam_scan(self, *, url: str, action_budget: int, focus: str | None = None) -> dict[str, Any]:
-        response = self._client.post(
-            f"{self._api_url}/validate/agent-run",
-            json={"url": url, "action_budget": action_budget, "focus": focus},
-            headers=self._auth_headers(),
-        )
-        return self._parse_json(response, "Failed to start agent run")
-
-    def approve_redteam_scan(self, run_id: str) -> dict[str, Any]:
-        response = self._client.post(
-            f"{self._api_url}/redteam/{run_id}/approve",
-            json={},
-            headers=self._auth_headers(),
-        )
-        return self._parse_json(response, "Failed to approve agent run")
-
     def get_run(self, run_id: str) -> dict[str, Any]:
         response = self._client.get(
             f"{self._api_url}/runs/{run_id}",
@@ -152,13 +193,6 @@ class ApiClient:
         )
         return self._parse_json(response, "Failed to load run logs")
 
-    def get_redteam_report(self, run_id: str) -> dict[str, Any]:
-        response = self._client.get(
-            f"{self._api_url}/redteam/{run_id}/report",
-            headers=self._auth_headers(),
-        )
-        return self._parse_json(response, "Failed to load agent run report")
-
     def list_pr_validation_runs(
         self,
         *,
@@ -443,20 +477,87 @@ def _resolve_ttl(client: ApiClient, requested_ttl: int | None) -> int | None:
     return FREE_TTL
 
 
+def _print_twin_env_vars(status: dict) -> None:
+    """Print twin URLs and env vars so the user can configure their app."""
+    from arga_cli.wizard.provision import with_proxy_token
+
+    proxy_token = status.get("proxy_token")
+    print("\nTwin environment variables — update your app's config to point at these:\n")
+    for name, info in status.get("twins", {}).items():
+        label = info.get("label", name)
+        base_url = info.get("base_url", "")
+        if proxy_token and base_url:
+            base_url = with_proxy_token(base_url, proxy_token)
+        print(f"  {label}:")
+        print(f"    Base URL: {base_url}")
+        env_vars = info.get("env_vars", {})
+        for key, val in env_vars.items():
+            print(f"    {key}={val}")
+        print()
+
+
 def run_test_url(args: argparse.Namespace) -> int:
     if bool(args.email) != bool(args.password):
         raise CliError("Both --email and --password must be provided together.")
 
+    scenario_id = getattr(args, "scenario", None)
+    if not args.prompt and not scenario_id:
+        raise CliError("Either --prompt or --scenario must be provided.")
+
+    twins_arg: list[str] | None = None
+    raw_twins = getattr(args, "twins", None)
+    if raw_twins:
+        twins_arg = [t.strip() for t in raw_twins.split(",") if t.strip()]
+
+    if not args.url and not twins_arg:
+        raise CliError("--url is required (or use --twins to provision twins first).")
+
+    url: str = args.url or ""
+
     api_key = load_api_key()
     client = ApiClient(args.api_url, api_key=api_key)
     try:
         ttl_minutes = _resolve_ttl(client, getattr(args, "ttl", None))
+
+        provision_id: str | None = None
+        if twins_arg:
+            from arga_cli.wizard.provision import provision_twins
+
+            status = provision_twins(client, twins_arg, ttl_minutes=ttl_minutes or 30)
+            provision_id = status.get("run_id")
+            _print_twin_env_vars(status)
+
+            if not url:
+                print("Deploy your app with the environment variables above.")
+                print("Press Ctrl+C to cancel.\n")
+                try:
+                    url = input("Enter your staging URL: ").strip()
+                except KeyboardInterrupt:
+                    print("\nCancelled.")
+                    return 1
+                if not url:
+                    raise CliError("A URL is required to start the validation run.")
+                print()
+            else:
+                print(
+                    "Deploy your app with the environment variables above, then press Enter to start the validation run."
+                )
+                print("Press Ctrl+C to cancel.\n")
+                try:
+                    input()
+                except KeyboardInterrupt:
+                    print("\nCancelled.")
+                    return 1
+
         payload = client.start_url_validation(
-            url=args.url,
+            url=url,
             prompt=args.prompt,
             email=args.email,
             password=args.password,
             ttl_minutes=ttl_minutes,
+            scenario_id=scenario_id,
+            provision_id=provision_id,
+            twins=twins_arg if not provision_id else None,
         )
     finally:
         client.close()
@@ -466,8 +567,11 @@ def run_test_url(args: argparse.Namespace) -> int:
         return 0
 
     print("Starting validation...\n")
-    print(f"URL: {args.url}")
-    print(f"Prompt: {args.prompt}")
+    print(f"URL: {url}")
+    if args.prompt:
+        print(f"Prompt: {args.prompt}")
+    if scenario_id:
+        print(f"Scenario: {scenario_id}")
     print(f"TTL: {ttl_minutes} minutes\n")
     print(f"Run ID: {payload.get('run_id', 'unknown')}")
     print(f"Status: {payload.get('status', 'unknown')}")
@@ -497,6 +601,77 @@ def run_validate_pr(args: argparse.Namespace) -> int:
     return 0
 
 
+def run_scenarios_list(args: argparse.Namespace) -> int:
+    api_key = load_api_key()
+    client = ApiClient(args.api_url, api_key=api_key)
+    try:
+        scenarios = client.list_scenarios(include_presets=getattr(args, "include_presets", False))
+    finally:
+        client.close()
+
+    if getattr(args, "json", False):
+        print(json.dumps(scenarios, indent=2))
+        return 0
+
+    if not scenarios:
+        print("No scenarios found. Create one with `arga scenarios create`.")
+        return 0
+
+    for s in scenarios:
+        marker = " (preset)" if s.get("is_preset") else ""
+        twins = ", ".join(s.get("twins") or []) or "-"
+        tags = ", ".join(s.get("tags") or []) or "-"
+        print(f"{s.get('id')}  {s.get('name')}{marker}")
+        if s.get("description"):
+            print(f"  description: {s['description']}")
+        print(f"  twins: {twins}")
+        print(f"  tags: {tags}")
+        print()
+    return 0
+
+
+def run_scenarios_create(args: argparse.Namespace) -> int:
+    api_key = load_api_key()
+    client = ApiClient(args.api_url, api_key=api_key)
+    try:
+        scenario = client.create_scenario(
+            name=args.name,
+            prompt=args.prompt,
+            description=getattr(args, "description", None),
+            twins=getattr(args, "twin", None),
+            tags=getattr(args, "tag", None),
+        )
+    finally:
+        client.close()
+
+    if getattr(args, "json", False):
+        print(json.dumps(scenario, indent=2))
+        return 0
+
+    print("Scenario created.")
+    print(f"  id: {scenario.get('id')}")
+    print(f"  name: {scenario.get('name')}")
+    if scenario.get("twins"):
+        print(f"  twins: {', '.join(scenario['twins'])}")
+    return 0
+
+
+def run_scenarios_delete(args: argparse.Namespace) -> int:
+    api_key = load_api_key()
+    client = ApiClient(args.api_url, api_key=api_key)
+    try:
+        result = client.delete_scenario(args.scenario_id)
+    finally:
+        client.close()
+
+    if getattr(args, "json", False):
+        print(json.dumps(result))
+        return 0
+
+    print(f"Deleted scenario {args.scenario_id}.")
+    return 0
+
+
 def _validate_help_text() -> str:
     return (
         "usage: arga validate pr --repo <owner/repo> --pr <number>\n"
@@ -642,150 +817,6 @@ def run_mcp_install(args: argparse.Namespace) -> int:
     return 1 if failures else 0
 
 
-def _scan_help_text() -> str:
-    return (
-        "usage: arga scan <url> [--budget 200]\n"
-        "       arga scan status <run_id>\n"
-        "       arga scan report <run_id>\n\n"
-        "Start or inspect Arga agent runs.\n\n"
-        "Note: scan requires a Team or Paid plan. Check your plan with `arga whoami`."
-    )
-
-
-def _build_scan_start_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(
-        prog="arga scan",
-        description="Start an Arga agent run. Requires a Team or Paid plan.",
-        allow_abbrev=False,
-    )
-    parser.add_argument("--api-url", default=DEFAULT_API_URL, help="Arga API base URL")
-    parser.add_argument("url", help="Public application URL to explore")
-    parser.add_argument("--budget", type=int, default=200, help="Total action budget for the scan")
-    return parser
-
-
-def _build_scan_status_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(
-        prog="arga scan status",
-        description="Check the status of an Arga agent run.",
-        allow_abbrev=False,
-    )
-    parser.add_argument("--api-url", default=DEFAULT_API_URL, help="Arga API base URL")
-    parser.add_argument("run_id", help="App scan run ID")
-    return parser
-
-
-def _build_scan_report_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(
-        prog="arga scan report",
-        description="View the final report for an Arga agent run.",
-        allow_abbrev=False,
-    )
-    parser.add_argument("--api-url", default=DEFAULT_API_URL, help="Arga API base URL")
-    parser.add_argument("run_id", help="App scan run ID")
-    return parser
-
-
-def _status_from_run(run: dict[str, Any]) -> str:
-    return str(run.get("status") or "unknown")
-
-
-def _wait_for_scan_approval(client: ApiClient, run_id: str) -> dict[str, Any]:
-    deadline = time.monotonic() + POLL_TIMEOUT_SECONDS
-    last_run: dict[str, Any] = {"id": run_id, "status": "planning"}
-    while time.monotonic() < deadline:
-        run = client.get_run(run_id)
-        last_run = run
-        status = _status_from_run(run)
-        if status in {"queued", "running", "completed", "failed", "cancelled"}:
-            return run
-
-        if status in {"planning", "awaiting_approval"}:
-            try:
-                approval = client.approve_redteam_scan(run_id)
-                run["status"] = approval.get("status", run.get("status"))
-                return run
-            except CliError as exc:
-                if str(exc) != "Scan plan is not ready yet":
-                    raise
-
-        time.sleep(POLL_INTERVAL_SECONDS)
-
-    raise CliError(f"Timed out waiting for the scan plan to be ready for run {last_run.get('id', run_id)}.")
-
-
-def _print_scan_summary(run_id: str, run: dict[str, Any]) -> None:
-    report = run.get("redteam_report_json")
-    anomaly_count = len(report.get("anomalies") or []) if isinstance(report, dict) else 0
-    print(f"Run ID: {run_id}")
-    print(f"Status: {_status_from_run(run)}")
-    print(f"URL: {run.get('frontend_url') or run.get('pr_url') or 'unknown'}")
-    print(f"Mode: {run.get('mode') or 'unknown'}")
-    print(f"Anomalies: {anomaly_count}")
-
-
-def run_scan_start(args: argparse.Namespace) -> int:
-    if args.budget <= 0:
-        raise CliError("Budget must be a positive integer.")
-
-    api_key = load_api_key()
-    client = ApiClient(args.api_url, api_key=api_key)
-    try:
-        payload = client.start_redteam_scan(url=args.url, action_budget=args.budget)
-        run_id = str(payload.get("run_id") or "")
-        if not run_id:
-            raise CliError("Agent run started but no run ID was returned.")
-        run = _wait_for_scan_approval(client, run_id)
-    finally:
-        client.close()
-
-    print("Starting agent run...\n")
-    print(f"URL: {args.url}")
-    print(f"Budget: {args.budget}")
-    print(f"Run ID: {run_id}")
-    print(f"Status: {_status_from_run(run)}")
-    return 0
-
-
-def run_scan_status(args: argparse.Namespace) -> int:
-    api_key = load_api_key()
-    client = ApiClient(args.api_url, api_key=api_key)
-    try:
-        run = client.get_run(args.run_id)
-    finally:
-        client.close()
-
-    _print_scan_summary(args.run_id, run)
-    return 0
-
-
-def run_scan_report(args: argparse.Namespace) -> int:
-    api_key = load_api_key()
-    client = ApiClient(args.api_url, api_key=api_key)
-    try:
-        report = client.get_redteam_report(args.run_id)
-    finally:
-        client.close()
-
-    if not report:
-        raise CliError("Scan report is not ready yet.")
-
-    print(json.dumps(report, indent=2))
-    return 0
-
-
-def run_scan_cli(argv: list[str]) -> int:
-    if not argv or argv[0] in {"-h", "--help"}:
-        print(_scan_help_text())
-        return 0
-
-    if argv[0] == "status":
-        return run_scan_status(_build_scan_status_parser().parse_args(argv[1:]))
-    if argv[0] == "report":
-        return run_scan_report(_build_scan_report_parser().parse_args(argv[1:]))
-    return run_scan_start(_build_scan_start_parser().parse_args(argv))
-
-
 def _format_timestamp(value: str | None) -> str:
     if not value:
         return "-"
@@ -904,6 +935,40 @@ def _print_worker_logs(worker_logs: list[dict[str, Any]]) -> None:
             print()
 
 
+def _print_timeline_events(timeline_events: list[dict[str, Any]], *, limit: int = 50) -> None:
+    print("Timeline:")
+    if not timeline_events:
+        print("None")
+        return
+
+    total = len(timeline_events)
+    events = timeline_events[-limit:] if total > limit else timeline_events
+    if total > limit:
+        print(f"(showing last {len(events)} of {total} events)")
+
+    for index, event in enumerate(events):
+        if not isinstance(event, dict):
+            continue
+        timestamp = _format_timestamp(event.get("timestamp") or event.get("created_at"))
+        event_type = str(event.get("type") or event.get("event_type") or "").strip()
+        header_parts = [part for part in (timestamp, event_type) if part and part != "-"]
+        header = " | ".join(header_parts) if header_parts else "event"
+        print(header)
+
+        message = str(event.get("message") or "").strip()
+        if message:
+            print(message)
+
+        details = event.get("details")
+        if isinstance(details, dict) and details:
+            error_message = str(details.get("error_message") or details.get("error") or "").strip()
+            if error_message and error_message != message:
+                print(f"Error: {error_message}")
+
+        if index < len(events) - 1:
+            print()
+
+
 def _print_runtime_logs(runtime_logs: list[dict[str, Any]]) -> None:
     print("Runtime Logs:")
     if not runtime_logs:
@@ -996,10 +1061,18 @@ def _print_run_logs(payload: dict[str, Any], fallback_run_id: str) -> None:
     if isinstance(timeline_events, list):
         print(f"Timeline Events: {len(timeline_events)}")
 
+    worker_logs_list = worker_logs if isinstance(worker_logs, list) else []
+    runtime_logs_list = runtime_logs if isinstance(runtime_logs, list) else []
+    timeline_events_list = timeline_events if isinstance(timeline_events, list) else []
+
     print()
-    _print_worker_logs(worker_logs if isinstance(worker_logs, list) else [])
+    _print_worker_logs(worker_logs_list)
     print()
-    _print_runtime_logs(runtime_logs if isinstance(runtime_logs, list) else [])
+    _print_runtime_logs(runtime_logs_list)
+
+    if not worker_logs_list and not runtime_logs_list and timeline_events_list:
+        print()
+        _print_timeline_events(timeline_events_list)
 
     if isinstance(warnings, list) and warnings:
         print()
@@ -1493,8 +1566,25 @@ def build_parser() -> argparse.ArgumentParser:
 
     test_url_parser = test_subparsers.add_parser("url", help="Run a browser validation against a deployed URL")
     test_url_parser.add_argument("--api-url", default=DEFAULT_API_URL, help="Arga API base URL")
-    test_url_parser.add_argument("--url", required=True, help="Deployed application URL")
-    test_url_parser.add_argument("--prompt", required=True, help="Natural language instructions for the agent")
+    test_url_parser.add_argument(
+        "--url", default=None, help="Deployed application URL (prompted after twin provisioning when --twins is used)"
+    )
+    test_url_parser.add_argument(
+        "--prompt",
+        default=None,
+        help="Natural language instructions for the agent (optional when --scenario is provided)",
+    )
+    test_url_parser.add_argument(
+        "--scenario",
+        default=None,
+        help="Scenario ID to seed twins from (obtain via `arga scenarios list` or the web app)",
+    )
+    test_url_parser.add_argument(
+        "--twins",
+        default=None,
+        help="Comma-separated list of digital twins to provision before the run (e.g. slack,stripe). "
+        "Twins are provisioned first, then you deploy your app against them before the validation starts.",
+    )
     test_url_parser.add_argument("--email", help="Optional login email")
     test_url_parser.add_argument("--password", help="Optional login password")
     test_url_parser.add_argument(
@@ -1506,6 +1596,47 @@ def build_parser() -> argparse.ArgumentParser:
     test_url_parser.add_argument("--json", action="store_true", default=False, help="Output result as JSON")
     test_url_parser.set_defaults(func=run_test_url)
 
+    scenarios_parser = subparsers.add_parser("scenarios", help="Manage twin seed scenarios")
+    scenarios_subparsers = scenarios_parser.add_subparsers(dest="scenarios_command", required=True)
+
+    scenarios_list_parser = scenarios_subparsers.add_parser("list", help="List your scenarios")
+    scenarios_list_parser.add_argument("--api-url", default=DEFAULT_API_URL, help="Arga API base URL")
+    scenarios_list_parser.add_argument(
+        "--include-presets",
+        action="store_true",
+        default=False,
+        help="Also include built-in preset scenarios",
+    )
+    scenarios_list_parser.add_argument("--json", action="store_true", default=False, help="Output as JSON")
+    scenarios_list_parser.set_defaults(func=run_scenarios_list)
+
+    scenarios_create_parser = scenarios_subparsers.add_parser(
+        "create", help="Create a scenario from a natural-language prompt"
+    )
+    scenarios_create_parser.add_argument("--api-url", default=DEFAULT_API_URL, help="Arga API base URL")
+    scenarios_create_parser.add_argument("--name", required=True, help="Scenario name")
+    scenarios_create_parser.add_argument(
+        "--prompt",
+        required=True,
+        help="Natural-language description of the desired twin state (LLM generates seed_config)",
+    )
+    scenarios_create_parser.add_argument("--description", default=None, help="Optional description")
+    scenarios_create_parser.add_argument(
+        "--twin",
+        action="append",
+        default=None,
+        help="Restrict to specific twin(s) (repeatable). Inferred from prompt if omitted.",
+    )
+    scenarios_create_parser.add_argument("--tag", action="append", default=None, help="Tag the scenario (repeatable)")
+    scenarios_create_parser.add_argument("--json", action="store_true", default=False, help="Output as JSON")
+    scenarios_create_parser.set_defaults(func=run_scenarios_create)
+
+    scenarios_delete_parser = scenarios_subparsers.add_parser("delete", help="Delete a scenario")
+    scenarios_delete_parser.add_argument("--api-url", default=DEFAULT_API_URL, help="Arga API base URL")
+    scenarios_delete_parser.add_argument("scenario_id", help="Scenario ID to delete")
+    scenarios_delete_parser.add_argument("--json", action="store_true", default=False, help="Output as JSON")
+    scenarios_delete_parser.set_defaults(func=run_scenarios_delete)
+
     validate_parser = subparsers.add_parser("validate", help="Start PR or URL validation runs")
     validate_subparsers = validate_parser.add_subparsers(dest="validate_command", required=True)
 
@@ -1574,7 +1705,6 @@ def build_parser() -> argparse.ArgumentParser:
 
     subparsers.add_parser("commit", help="Wrap git commit and optionally mark it to skip Arga validation")
     subparsers.add_parser("push", help="Wrap git push and verify skip state when requested")
-    subparsers.add_parser("scan", help="Start an agent run or inspect a scan run")
     return parser
 
 
@@ -1586,8 +1716,6 @@ def main() -> None:
             exit_code = run_push_cli(sys.argv[2:])
         elif len(sys.argv) > 1 and sys.argv[1] == "validate":
             exit_code = run_validate_cli(sys.argv[2:])
-        elif len(sys.argv) > 1 and sys.argv[1] == "scan":
-            exit_code = run_scan_cli(sys.argv[2:])
         elif len(sys.argv) > 1 and sys.argv[1] == "wizard":
             exit_code = run_wizard_cli(sys.argv[2:])
         else:

{arga_cli-0.1.6 → arga_cli-0.1.7}/arga_cli/wizard/provision.py

@@ -47,6 +47,7 @@ def provision_twins(
     )
     data = client._parse_json(response, "Failed to provision twins")
     run_id = data["run_id"]
+    dim(f"  Run ID: {run_id}")
 
     # Poll until ready
     ready_set: set[str] = set()
@@ -106,6 +107,23 @@ def provision_twins(
     raise RuntimeError(f"Timed out waiting for twins to provision for run {run_id}.")
 
 
+def _format_seed_summary(seed_info: dict) -> list[str]:
+    """Render a server-reported seed result as a list of display lines."""
+    status_value = seed_info.get("status")
+    if status_value == "seeded":
+        counts = [
+            f"{key.replace('_', ' ')}: {value}"
+            for key, value in seed_info.items()
+            if key not in {"status", "twin"} and isinstance(value, (int, str))
+        ]
+        return [f"Seeded — {', '.join(counts)}"] if counts else ["Seeded."]
+    if status_value == "skipped":
+        return [f"Skipped ({seed_info.get('reason', 'unknown')})"]
+    if status_value == "error":
+        return [f"Seed error: {seed_info.get('error', 'unknown')}"]
+    return ["Default configuration loaded."]
+
+
 def seed_and_report(client: Any, status: dict) -> None:
     """Seed quickstart data for UI twins, print default config for backend-only twins."""
     header("Quickstart setup...")
@@ -120,23 +138,29 @@ def seed_and_report(client: Any, status: dict) -> None:
             backend_twins.append(name)
 
     proxy_token = status.get("proxy_token")
+    seed_results = status.get("seed_results") or {}
 
     # Seed and report UI twins
     for name in ui_twins:
         info = status["twins"][name]
         label = TWIN_CATALOG.get(name, {}).get("label", name)
 
-        # Reset to seed state
-        try:
-            admin_url = info.get("admin_url", "")
-            reset_url = with_proxy_token(f"{admin_url}/admin/reset", proxy_token)
-            client._client.post(reset_url, json={}, headers={"Content-Type": "application/json"})
-        except Exception:
-            pass  # Twin may already be in clean state
+        seed_info = seed_results.get(name)
+        if seed_info is None:
+            # No server-side seeding happened — fall back to the legacy client-side reset.
+            try:
+                admin_url = info.get("admin_url", "")
+                reset_url = with_proxy_token(f"{admin_url}/admin/reset", proxy_token)
+                client._client.post(reset_url, json={}, headers={"Content-Type": "application/json"})
+            except Exception:
+                pass
 
         console.print(f"  [bold cyan]{label}[/bold cyan]:")
-        summary = QUICKSTART_SUMMARIES.get(name, ["Default configuration loaded."])
-        for line in summary:
+        if seed_info is not None:
+            summary_lines = _format_seed_summary(seed_info)
+        else:
+            summary_lines = QUICKSTART_SUMMARIES.get(name, ["Default configuration loaded."])
+        for line in summary_lines:
             console.print(f"    {line}")
 
         # Print env vars
@@ -151,12 +175,16 @@ def seed_and_report(client: Any, status: dict) -> None:
         label = TWIN_CATALOG.get(name, {}).get("label", name)
 
         console.print(f"  [bold cyan]{label}[/bold cyan] [dim](backend-only)[/dim]:")
-        base_url = with_proxy_token(info.get("base_url", ""), proxy_token)
-        console.print(f"    Base URL: [underline]{base_url}[/underline]")
+        base_url = info.get("base_url", "")
+        console.print(f"    Base URL: [underline]{base_url}[/underline]", soft_wrap=True, overflow="ignore")
+        seed_info = seed_results.get(name)
+        if seed_info is not None:
+            for line in _format_seed_summary(seed_info):
+                console.print(f"    {line}")
         env_vars = info.get("env_vars", {})
         if env_vars:
             for key, val in env_vars.items():
                 console.print(f"    [dim]{key}[/dim]: {val}")
-        else:
+        elif seed_info is None:
             dim("    No UI dashboard. Use API calls directly.")
         console.print()

{arga_cli-0.1.6 → arga_cli-0.1.7}/arga_cli/wizard/summary.py

@@ -5,8 +5,7 @@ from __future__ import annotations
 from datetime import datetime
 
 from arga_cli.wizard.constants import DASHBOARD_BASE_URL, SESSION_FILE, TWIN_CATALOG
-from arga_cli.wizard.output import dim, print_summary_box
-from arga_cli.wizard.provision import with_proxy_token
+from arga_cli.wizard.output import console, dim, print_summary_box
 from arga_cli.wizard.session import save_session
 
 
@@ -18,31 +17,31 @@ def print_summary(cwd: str, status: dict, api_url: str, api_key: str) -> None:
     lines = [
         "[bold green]Arga Twins \u2014 Ready![/bold green]",
         "",
-        f"Dashboard: [underline]{dashboard_url}[/underline]",
-        "",
+        "Commands:",
+        "  [cyan]arga wizard status[/cyan]      Check health",
+        "  [cyan]arga wizard reset[/cyan]       Reset twin state",
+        "  [cyan]arga wizard extend[/cyan]      Extend by 10 min",
+        "  [cyan]arga wizard teardown[/cyan]    Destroy session",
     ]
 
-    # Twin URLs
-    for name, info in status.get("twins", {}).items():
-        label = TWIN_CATALOG.get(name, {}).get("label", name).ljust(16)
-        url = with_proxy_token(info.get("base_url", ""), proxy_token)
-        lines.append(f"{label} [underline]{url}[/underline]")
+    print_summary_box(lines)
 
-    lines.append("")
+    console.print(f"Dashboard: [underline]{dashboard_url}[/underline]", soft_wrap=True, overflow="ignore")
+    console.print()
 
-    if status.get("expires_at"):
-        lines.append(f"Session expires: {status['expires_at']}")
-        lines.append("")
+    for name, info in status.get("twins", {}).items():
+        label = TWIN_CATALOG.get(name, {}).get("label", name)
+        url = info.get("base_url", "")
+        console.print(
+            f"  [bold cyan]{label}[/bold cyan]: [underline]{url}[/underline]", soft_wrap=True, overflow="ignore"
+        )
 
-    lines.append("Commands:")
-    lines.append("  [cyan]arga wizard status[/cyan]      Check health")
-    lines.append("  [cyan]arga wizard reset[/cyan]       Reset twin state")
-    lines.append("  [cyan]arga wizard extend[/cyan]      Extend by 10 min")
-    lines.append("  [cyan]arga wizard teardown[/cyan]    Destroy session")
+    if status.get("expires_at"):
+        console.print()
+        dim(f"Session expires: {status['expires_at']}")
 
-    print_summary_box(lines)
+    console.print()
 
-    # Write session state
     session = {
         "run_id": status["run_id"],
         "created_at": datetime.now().isoformat(),

{arga_cli-0.1.6 → arga_cli-0.1.7}/arga_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arga-cli
-Version: 0.1.6
+Version: 0.1.7
 Summary: Command-line interface for Arga authentication, MCP installation, and browser validation
 Author: Arga Labs
 Project-URL: Homepage, https://github.com/ArgaLabs/arga-cli
@@ -33,7 +33,6 @@ Requires-Dist: rich>=13.0.0
 - Starts URL validation runs from the terminal.
 - Starts pull request validation runs from the terminal.
 - Wraps `git commit` and `git push` with Arga skip-validation helpers.
-- Starts and inspects Arga app scans.
 
 ## Installation 
 
@@ -112,14 +111,6 @@ arga validate config arga-labs/validation-server
 arga validate config set arga-labs/validation-server --trigger branch --branch main --comments on
 ```
 
-Start an app scan and inspect it later:
-
-```bash
-arga scan https://demo-app.com --budget 200
-arga scan status <run_id>
-arga scan report <run_id>
-```
-
 List and inspect recent validation runs:
 
 ```bash
@@ -173,19 +164,6 @@ arga test url \
 
 Both `--email` and `--password` must be supplied together.
 
-### App Scans
-
-```bash
-arga scan https://demo-app.com --budget 200
-arga scan status <run_id>
-arga scan report <run_id>
-```
-
-- `arga scan <url>` starts an app scan, waits for the generated scan plan to be ready, and auto-approves it so execution can begin.
-- `--budget` controls the red-team action budget and defaults to `200`.
-- `arga scan status <run_id>` prints the current run status and anomaly count.
-- `arga scan report <run_id>` prints the final JSON report once the scan has completed.
-
 ### Validation Runs
 
 ```bash

{arga_cli-0.1.6 → arga_cli-0.1.7}/arga_cli.egg-info/SOURCES.txt

@@ -20,7 +20,6 @@ arga_cli/wizard/summary.py
 tests/test_cli_git.py
 tests/test_cli_mcp.py
 tests/test_cli_runs.py
-tests/test_cli_scan.py
 tests/test_cli_test_url.py
 tests/test_cli_validate_config.py
 tests/test_cli_validate_pr.py

{arga_cli-0.1.6 → arga_cli-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "arga-cli"
-version = "0.1.6"
+version = "0.1.7"
 description = "Command-line interface for Arga authentication, MCP installation, and browser validation"
 readme = "README.md"
 requires-python = ">=3.12"

arga_cli-0.1.7/tests/test_cli_test_url.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import json
+
+from arga_cli import main
+
+
+def test_start_url_validation_uses_longer_timeout(monkeypatch) -> None:
+    client = main.ApiClient("https://api.argalabs.com", api_key="arga_api_key")
+    captured: dict[str, object] = {}
+
+    def fake_post(url: str, *, json: dict[str, object], headers: dict[str, str], timeout: float):
+        captured["url"] = url
+        captured["json"] = json
+        captured["headers"] = headers
+        captured["timeout"] = timeout
+
+        class FakeResponse:
+            is_success = True
+            status_code = 200
+
+            def json(self) -> dict[str, str]:
+                return {"run_id": "run_3421", "status": "queued", "session_id": "session_1"}
+
+        return FakeResponse()
+
+    monkeypatch.setattr(client._client, "post", fake_post)
+    try:
+        payload = client.start_url_validation(url="https://demo-app.com", prompt="test login flow")
+    finally:
+        client.close()
+
+    assert captured["url"] == "https://api.argalabs.com/validate/url-run"
+    assert captured["json"] == {"url": "https://demo-app.com", "prompt": "test login flow"}
+    assert captured["timeout"] == main.URL_VALIDATION_START_TIMEOUT_SECONDS
+    assert payload == {"run_id": "run_3421", "status": "queued", "session_id": "session_1"}
+
+
+def test_test_url_command_prints_run_id(monkeypatch, capsys) -> None:
+    monkeypatch.setattr(main, "load_api_key", lambda: "arga_api_key")
+    monkeypatch.setattr(main.ApiClient, "get_me", lambda self: {"billing_plan": "free"})
+
+    def fake_start(
+        self,
+        *,
+        url: str,
+        prompt: str | None = None,
+        email: str | None = None,
+        password: str | None = None,
+        ttl_minutes: int | None = None,
+        scenario_id: str | None = None,
+        provision_id: str | None = None,
+        twins: list[str] | None = None,
+    ):
+        assert url == "https://demo-app.com"
+        assert prompt == "test login flow"
+        assert email is None
+        assert password is None
+        assert ttl_minutes == 10
+        return {"run_id": "run_3421", "status": "queued", "session_id": "session_1"}
+
+    monkeypatch.setattr(main.ApiClient, "start_url_validation", fake_start)
+    monkeypatch.setattr(main.ApiClient, "close", lambda self: None)
+
+    args = main.build_parser().parse_args(
+        ["test", "url", "--url", "https://demo-app.com", "--prompt", "test login flow"]
+    )
+    exit_code = args.func(args)
+    output = capsys.readouterr().out
+
+    assert exit_code == 0
+    assert "Starting validation..." in output
+    assert "Run ID: run_3421" in output
+    assert "Status: queued" in output
+
+
+def test_test_url_json_flag(monkeypatch, capsys) -> None:
+    monkeypatch.setattr(main, "load_api_key", lambda: "arga_api_key")
+    monkeypatch.setattr(main.ApiClient, "get_me", lambda self: {"billing_plan": "free"})
+
+    def fake_start(
+        self,
+        *,
+        url: str,
+        prompt: str | None = None,
+        email: str | None = None,
+        password: str | None = None,
+        ttl_minutes: int | None = None,
+        scenario_id: str | None = None,
+        provision_id: str | None = None,
+        twins: list[str] | None = None,
+    ):
+        assert ttl_minutes == 10
+        return {"run_id": "run_3421", "status": "queued", "session_id": "session_1"}
+
+    monkeypatch.setattr(main.ApiClient, "start_url_validation", fake_start)
+    monkeypatch.setattr(main.ApiClient, "close", lambda self: None)
+
+    args = main.build_parser().parse_args(
+        ["test", "url", "--url", "https://demo-app.com", "--prompt", "test login flow", "--json"]
+    )
+    exit_code = args.func(args)
+    output = capsys.readouterr().out
+
+    assert exit_code == 0
+    parsed = json.loads(output)
+    assert parsed == {"run_id": "run_3421", "status": "queued"}

arga_cli-0.1.6/tests/test_cli_scan.py

@@ -1,113 +0,0 @@
-from __future__ import annotations
-
-import json
-import sys
-
-import pytest
-
-from arga_cli import main
-
-
-def test_scan_start_polls_until_plan_ready_and_auto_approves(monkeypatch: pytest.MonkeyPatch, capsys) -> None:
-    monkeypatch.setattr(main, "load_api_key", lambda: "arga_api_key")
-    monkeypatch.setattr(main.ApiClient, "close", lambda self: None)
-    monkeypatch.setattr(main.time, "sleep", lambda _: None)
-
-    statuses = iter(
-        [
-            {"status": "planning"},
-            {"status": "awaiting_approval"},
-        ]
-    )
-
-    def fake_start(self, *, url: str, action_budget: int):
-        assert url == "https://demo-app.com"
-        assert action_budget == 200
-        return {"run_id": "run_scan_123", "status": "planning"}
-
-    def fake_get_run(self, run_id: str):
-        assert run_id == "run_scan_123"
-        status = next(statuses)
-        return {
-            "id": run_id,
-            "status": status["status"],
-            "frontend_url": "https://demo-app.com",
-            "mode": "redteam",
-        }
-
-    def fake_approve(self, run_id: str):
-        assert run_id == "run_scan_123"
-        return {"run_id": run_id, "status": "queued"}
-
-    monkeypatch.setattr(main.ApiClient, "start_redteam_scan", fake_start)
-    monkeypatch.setattr(main.ApiClient, "get_run", fake_get_run)
-    monkeypatch.setattr(main.ApiClient, "approve_redteam_scan", fake_approve)
-
-    exit_code = main.run_scan_cli(["https://demo-app.com"])
-    output = capsys.readouterr().out
-
-    assert exit_code == 0
-    assert "Starting agent run..." in output
-    assert "URL: https://demo-app.com" in output
-    assert "Budget: 200" in output
-    assert "Run ID: run_scan_123" in output
-    assert "Status: queued" in output
-
-
-def test_scan_status_prints_summary(monkeypatch: pytest.MonkeyPatch, capsys) -> None:
-    monkeypatch.setattr(main, "load_api_key", lambda: "arga_api_key")
-    monkeypatch.setattr(main.ApiClient, "close", lambda self: None)
-
-    def fake_get_run(self, run_id: str):
-        assert run_id == "run_scan_123"
-        return {
-            "id": run_id,
-            "status": "running",
-            "frontend_url": "https://demo-app.com",
-            "mode": "redteam",
-            "redteam_report_json": {"anomalies": [{"title": "Issue 1"}, {"title": "Issue 2"}]},
-        }
-
-    monkeypatch.setattr(main.ApiClient, "get_run", fake_get_run)
-
-    exit_code = main.run_scan_cli(["status", "run_scan_123"])
-    output = capsys.readouterr().out
-
-    assert exit_code == 0
-    assert "Run ID: run_scan_123" in output
-    assert "Status: running" in output
-    assert "Anomalies: 2" in output
-
-
-def test_scan_report_prints_json(monkeypatch: pytest.MonkeyPatch, capsys) -> None:
-    monkeypatch.setattr(main, "load_api_key", lambda: "arga_api_key")
-    monkeypatch.setattr(main.ApiClient, "close", lambda self: None)
-
-    def fake_report(self, run_id: str):
-        assert run_id == "run_scan_123"
-        return {"summary": "done", "anomalies": [{"title": "Issue 1"}]}
-
-    monkeypatch.setattr(main.ApiClient, "get_redteam_report", fake_report)
-
-    exit_code = main.run_scan_cli(["report", "run_scan_123"])
-    output = capsys.readouterr().out
-
-    assert exit_code == 0
-    assert json.loads(output) == {"summary": "done", "anomalies": [{"title": "Issue 1"}]}
-
-
-def test_main_dispatches_scan_wrapper_before_argparse(monkeypatch: pytest.MonkeyPatch) -> None:
-    captured: dict[str, object] = {}
-
-    def fake_scan(argv: list[str]) -> int:
-        captured["argv"] = argv
-        return 0
-
-    monkeypatch.setattr(main, "run_scan_cli", fake_scan)
-    monkeypatch.setattr(sys, "argv", ["arga", "scan", "status", "run_scan_123"])
-
-    with pytest.raises(SystemExit) as exc_info:
-        main.main()
-
-    assert exc_info.value.code == 0
-    assert captured["argv"] == ["status", "run_scan_123"]

arga_cli-0.1.6/tests/test_cli_test_url.py

@@ -1,50 +0,0 @@
-from __future__ import annotations
-
-import json
-
-from arga_cli import main
-
-
-def test_test_url_command_prints_run_id(monkeypatch, capsys) -> None:
-    monkeypatch.setattr(main, "load_api_key", lambda: "arga_api_key")
-
-    def fake_start(self, *, url: str, prompt: str, email: str | None = None, password: str | None = None):
-        assert url == "https://demo-app.com"
-        assert prompt == "test login flow"
-        assert email is None
-        assert password is None
-        return {"run_id": "run_3421", "status": "queued", "session_id": "session_1"}
-
-    monkeypatch.setattr(main.ApiClient, "start_url_validation", fake_start)
-    monkeypatch.setattr(main.ApiClient, "close", lambda self: None)
-
-    args = main.build_parser().parse_args(
-        ["test", "url", "--url", "https://demo-app.com", "--prompt", "test login flow"]
-    )
-    exit_code = args.func(args)
-    output = capsys.readouterr().out
-
-    assert exit_code == 0
-    assert "Starting validation..." in output
-    assert "Run ID: run_3421" in output
-    assert "Status: queued" in output
-
-
-def test_test_url_json_flag(monkeypatch, capsys) -> None:
-    monkeypatch.setattr(main, "load_api_key", lambda: "arga_api_key")
-
-    def fake_start(self, *, url: str, prompt: str, email: str | None = None, password: str | None = None):
-        return {"run_id": "run_3421", "status": "queued", "session_id": "session_1"}
-
-    monkeypatch.setattr(main.ApiClient, "start_url_validation", fake_start)
-    monkeypatch.setattr(main.ApiClient, "close", lambda self: None)
-
-    args = main.build_parser().parse_args(
-        ["test", "url", "--url", "https://demo-app.com", "--prompt", "test login flow", "--json"]
-    )
-    exit_code = args.func(args)
-    output = capsys.readouterr().out
-
-    assert exit_code == 0
-    parsed = json.loads(output)
-    assert parsed == {"run_id": "run_3421", "status": "queued"}