autotouch-cli 0.2.73__tar.gz → 0.2.79__tar.gz

{autotouch_cli-0.2.73 → autotouch_cli-0.2.79}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autotouch-cli
-Version: 0.2.73
+Version: 0.2.79
 Summary: Autotouch Smart Table CLI
 Project-URL: Homepage, https://app.autotouch.ai
 Project-URL: Documentation, https://github.com/nicolonic/autotouch_main/tree/main/docs/research-table/reference
@@ -133,8 +133,8 @@ autotouch rows get --table-id "$TABLE_ID" --row-id "$ROW_ID" --output json
 - Inspect one cell: `autotouch cells get`
 - Create a workflow column: `autotouch columns recipe`, `autotouch columns create`
 - Run provider-hidden search: `autotouch search companies`, `autotouch search people`
-- Inspect LinkedIn/Sales Nav filters: `autotouch linkedin filters --api sales_navigator --category people`
-- Build a paced LinkedIn people list: `autotouch linkedin list-build create --company-query 'SaaS startups' --headcount 1-10 --people-query 'Account Executive OR SDR' --num-results 250 --wait`
+- Inspect LinkedIn filters: `autotouch linkedin filters --category people`
+- Build a durable lead list on Smart Table workers: `autotouch list-build leads --title 'Account Executive OR SDR' --geo-id 103644278 --num-results 1000 --wait`
 - Run one LinkedIn search page/debug replay: `autotouch linkedin search`
 - Run controlled slices: `autotouch columns run-next`
 - Poll authoritative state: `autotouch jobs get`
@@ -148,8 +148,9 @@ For automation or agent-driven setup, use:
 - `autotouch cli-manifest --output json` for the local machine-readable command contract
 - `autotouch cli-reference` for the shipped parser-generated reference
 - `autotouch capabilities --output json` for provider/workflow contracts
-- `autotouch linkedin filters --output json` for LinkedIn/Sales Navigator filter tokens such as headcount, industry, location, role, function, and seniority
-- `autotouch linkedin list-build create` for durable LinkedIn/Sales Navigator list building with paced provider requests, visible progress, and cooldown status
+- `autotouch --version` should be `0.2.79` or newer for provider-hidden `autotouch list-build ...`; older CLIs may still show the removed `autotouch linkedin list-build` surface
+- `autotouch capabilities --output json --select list_builds` for documented list-build inputs such as geography IDs, company size buckets, profile language, and company IDs
+- `autotouch list-build companies` and `autotouch list-build leads` for durable provider-hidden company and lead list builds with Smart Table-owned background workers, visible progress, and no user-owned network connection requirement
 - `autotouch linkedin search` for one-page LinkedIn/Sales Navigator replay/debug searches; it is not the recommended path for large lists
 - `autotouch rows list` / `autotouch rows get` / `autotouch cells get` for read-back and audit
 - `autotouch sequences ...` and `autotouch tasks ...` for sequence/task workflows

{autotouch_cli-0.2.73 → autotouch_cli-0.2.79}/README.md

@@ -108,8 +108,8 @@ autotouch rows get --table-id "$TABLE_ID" --row-id "$ROW_ID" --output json
 - Inspect one cell: `autotouch cells get`
 - Create a workflow column: `autotouch columns recipe`, `autotouch columns create`
 - Run provider-hidden search: `autotouch search companies`, `autotouch search people`
-- Inspect LinkedIn/Sales Nav filters: `autotouch linkedin filters --api sales_navigator --category people`
-- Build a paced LinkedIn people list: `autotouch linkedin list-build create --company-query 'SaaS startups' --headcount 1-10 --people-query 'Account Executive OR SDR' --num-results 250 --wait`
+- Inspect LinkedIn filters: `autotouch linkedin filters --category people`
+- Build a durable lead list on Smart Table workers: `autotouch list-build leads --title 'Account Executive OR SDR' --geo-id 103644278 --num-results 1000 --wait`
 - Run one LinkedIn search page/debug replay: `autotouch linkedin search`
 - Run controlled slices: `autotouch columns run-next`
 - Poll authoritative state: `autotouch jobs get`
@@ -123,8 +123,9 @@ For automation or agent-driven setup, use:
 - `autotouch cli-manifest --output json` for the local machine-readable command contract
 - `autotouch cli-reference` for the shipped parser-generated reference
 - `autotouch capabilities --output json` for provider/workflow contracts
-- `autotouch linkedin filters --output json` for LinkedIn/Sales Navigator filter tokens such as headcount, industry, location, role, function, and seniority
-- `autotouch linkedin list-build create` for durable LinkedIn/Sales Navigator list building with paced provider requests, visible progress, and cooldown status
+- `autotouch --version` should be `0.2.79` or newer for provider-hidden `autotouch list-build ...`; older CLIs may still show the removed `autotouch linkedin list-build` surface
+- `autotouch capabilities --output json --select list_builds` for documented list-build inputs such as geography IDs, company size buckets, profile language, and company IDs
+- `autotouch list-build companies` and `autotouch list-build leads` for durable provider-hidden company and lead list builds with Smart Table-owned background workers, visible progress, and no user-owned network connection requirement
 - `autotouch linkedin search` for one-page LinkedIn/Sales Navigator replay/debug searches; it is not the recommended path for large lists
 - `autotouch rows list` / `autotouch rows get` / `autotouch cells get` for read-back and audit
 - `autotouch sequences ...` and `autotouch tasks ...` for sequence/task workflows

{autotouch_cli-0.2.73 → autotouch_cli-0.2.79}/autotouch_cli/cli.py

@@ -95,9 +95,6 @@ from autotouch_cli.commands.linkedin import (
     cmd_linkedin_comments as cmd_linkedin_comments_impl,
     cmd_linkedin_filters as cmd_linkedin_filters_impl,
     cmd_linkedin_limits as cmd_linkedin_limits_impl,
-    cmd_linkedin_list_build_create as cmd_linkedin_list_build_create_impl,
-    cmd_linkedin_list_build_results as cmd_linkedin_list_build_results_impl,
-    cmd_linkedin_list_build_status as cmd_linkedin_list_build_status_impl,
     cmd_linkedin_post as cmd_linkedin_post_impl,
     cmd_linkedin_posts as cmd_linkedin_posts_impl,
     cmd_linkedin_reactions as cmd_linkedin_reactions_impl,
@@ -106,6 +103,13 @@ from autotouch_cli.commands.linkedin import (
     cmd_linkedin_search_params as cmd_linkedin_search_params_impl,
     cmd_linkedin_status as cmd_linkedin_status_impl,
 )
+from autotouch_cli.commands.list_build import (
+    ListBuildCommandRuntime as ListBuildCommandHandlerRuntime,
+    cmd_list_build_companies as cmd_list_build_companies_impl,
+    cmd_list_build_leads as cmd_list_build_leads_impl,
+    cmd_list_build_results as cmd_list_build_results_impl,
+    cmd_list_build_status as cmd_list_build_status_impl,
+)
 from autotouch_cli.commands.rows import (
     RowCommandRuntime as RowCommandHandlerRuntime,
     cmd_rows_add as cmd_rows_add_impl,
@@ -353,6 +357,14 @@ from autotouch_shared.provider_registry import (
     ProviderContractValidationError,
     validate_column_provider_contract,
 )
+from autotouch_shared.linkedin_contract import (
+    linkedin_capabilities_contract,
+    linkedin_endpoint_entries,
+)
+from autotouch_shared.list_build_contract import (
+    list_build_capabilities_contract,
+    list_build_endpoint_entries,
+)
 from autotouch_cli.exceptions import (
     AutotouchAPIError,
     AutotouchInputError,
@@ -1355,6 +1367,15 @@ def _linkedin_command_runtime() -> LinkedInCommandHandlerRuntime:
     )
 
 
+def _list_build_command_runtime() -> ListBuildCommandHandlerRuntime:
+    return ListBuildCommandHandlerRuntime(
+        resolve_token=_resolve_token,
+        request_api=_request_api,
+        print_json=lambda data, compact=False: _print_json(data, compact=compact),
+        load_json_input=_load_json_input,
+    )
+
+
 # ---------------------------------------------------------------------------
 # Command registry — replaces ~110 thin shim functions
 # ---------------------------------------------------------------------------
@@ -1549,14 +1570,17 @@ _register("linkedin_limits", cmd_linkedin_limits_impl, _linkedin_command_runtime
 _register("linkedin_search", cmd_linkedin_search_impl, _linkedin_command_runtime)
 _register("linkedin_search_params", cmd_linkedin_search_params_impl, _linkedin_command_runtime)
 _register("linkedin_filters", cmd_linkedin_filters_impl, _linkedin_command_runtime)
-_register("linkedin_list_build_create", cmd_linkedin_list_build_create_impl, _linkedin_command_runtime)
-_register("linkedin_list_build_status", cmd_linkedin_list_build_status_impl, _linkedin_command_runtime)
-_register("linkedin_list_build_results", cmd_linkedin_list_build_results_impl, _linkedin_command_runtime)
 _register("linkedin_posts", cmd_linkedin_posts_impl, _linkedin_command_runtime)
 _register("linkedin_post", cmd_linkedin_post_impl, _linkedin_command_runtime)
 _register("linkedin_comments", cmd_linkedin_comments_impl, _linkedin_command_runtime)
 _register("linkedin_reactions", cmd_linkedin_reactions_impl, _linkedin_command_runtime)
 
+# -- List build commands --
+_register("list_build_companies", cmd_list_build_companies_impl, _list_build_command_runtime)
+_register("list_build_leads", cmd_list_build_leads_impl, _list_build_command_runtime)
+_register("list_build_status", cmd_list_build_status_impl, _list_build_command_runtime)
+_register("list_build_results", cmd_list_build_results_impl, _list_build_command_runtime)
+
 # -- Template emitter commands (use _template_runtime) --
 _register("schema", emit_schema, _template_runtime)
 _register("auth_schema", emit_auth_schema, _template_runtime)
@@ -1900,6 +1924,17 @@ def cmd_context_resolved(args: argparse.Namespace) -> None:
     _print_json(data, compact=args.compact)
 
 
+def _with_bundled_linkedin_capabilities(data: Any) -> Any:
+    if not isinstance(data, dict):
+        return data
+    merged = dict(data)
+    endpoints = merged.get("endpoints") if isinstance(merged.get("endpoints"), dict) else {}
+    merged["endpoints"] = {**endpoints, **linkedin_endpoint_entries(), **list_build_endpoint_entries()}
+    merged["linkedin"] = linkedin_capabilities_contract()
+    merged["list_builds"] = list_build_capabilities_contract()
+    return merged
+
+
 def cmd_capabilities(args: argparse.Namespace) -> None:
     token = _resolve_token(args.token, required=False)
     data = _request_api(
@@ -1911,6 +1946,7 @@ def cmd_capabilities(args: argparse.Namespace) -> None:
         timeout=args.timeout,
         verbose=args.verbose,
     )
+    data = _with_bundled_linkedin_capabilities(data)
     if OUTPUT_MODE == "human" and isinstance(data, dict):
         execution = data.get("execution_policies") if isinstance(data.get("execution_policies"), dict) else {}
         llm = execution.get("llm") if isinstance(execution.get("llm"), dict) else {}
@@ -1953,13 +1989,21 @@ def cmd_capabilities(args: argparse.Namespace) -> None:
             print("")
             print("LinkedIn list building")
             print("---------------------")
-            modes = linkedin.get("api_modes", [])
-            print(f"API modes       : {', '.join(str(m) for m in modes)}")
+            api_mode_management = linkedin.get("api_mode_management")
+            if api_mode_management:
+                print(f"API mode        : {api_mode_management}")
             print(f"Access gate     : {linkedin.get('access_gate', 'linkedin_access flag')}")
             caps = linkedin.get("rate_limits", {}).get("search_daily_caps", {})
-            if caps:
+            if isinstance(caps, dict) and caps:
                 for mode, cap in caps.items():
                     print(f"  {mode:20s}: {cap}")
+            elif caps:
+                print(f"Daily caps      : {caps}")
+            summary = linkedin.get("recommendation_summary")
+            if isinstance(summary, list) and summary:
+                print("Recommended path:")
+                for item in summary:
+                    print(f"  - {item}")
             best_for = linkedin.get("best_for")
             if isinstance(best_for, list) and best_for:
                 print("Best for        :")

{autotouch_cli-0.2.73 → autotouch_cli-0.2.79}/autotouch_cli/cli_contracts.py

@@ -201,6 +201,8 @@ def action_descriptor(action: argparse.Action) -> Optional[Dict[str, Any]]:
         return None
     if isinstance(action, argparse._SubParsersAction):
         return None
+    if getattr(action, "help", None) == argparse.SUPPRESS:
+        return None
 
     input_kind = _option_input_kind(action)
     action_kind = _option_action_kind(action)

{autotouch_cli-0.2.73 → autotouch_cli-0.2.79}/autotouch_cli/commands/linkedin.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import argparse
 import json
-import time
 from dataclasses import dataclass
 from typing import Any, Callable, Dict, List, Optional, Sequence
 
@@ -60,7 +59,7 @@ def _normalize_linkedin_search_payload(args: argparse.Namespace, *, runtime: Lin
 
     payload: Dict[str, Any] = {
         "category": str(getattr(args, "category", "people") or "people"),
-        "limit": max(1, min(int(getattr(args, "limit", 25) or 25), 250)),
+        "limit": max(1, min(int(getattr(args, "limit", 25) or 25), 100)),
     }
     url = str(getattr(args, "url", "") or "").strip()
     if url:
@@ -141,131 +140,40 @@ def _split_repeated_values(values: Optional[List[str]]) -> List[str]:
     return output
 
 
-def _normalize_linkedin_list_build_payload(args: argparse.Namespace, *, runtime: LinkedInCommandRuntime) -> Dict[str, Any]:
-    explicit = runtime.load_json_input(
-        inline_json=getattr(args, "data_json", None),
-        file_path=getattr(args, "data_file", None),
-        context="data",
-        default=None,
-    )
-    if explicit is not None:
-        if not isinstance(explicit, dict):
-            raise AutotouchInputError("linkedin list-build payload must be a JSON object")
-        return explicit
-
-    company_query = str(getattr(args, "company_query", "") or "").strip()
-    if not company_query:
-        raise AutotouchInputError("linkedin list-build create requires --company-query or --data-file")
-
-    payload: Dict[str, Any] = {
-        "mode": str(getattr(args, "mode", "company-first-people") or "company-first-people").strip(),
-        "company_query": company_query,
-        "headcount": str(getattr(args, "headcount", "1-10") or "1-10").strip(),
-        "num_results": max(1, min(int(getattr(args, "num_results", 100) or 100), 1000)),
-    }
-    people_query = str(getattr(args, "people_query", "") or "").strip()
-    if people_query:
-        payload["people_query"] = people_query
-    linkedin_api = str(getattr(args, "linkedin_api", "auto") or "auto").strip()
-    if linkedin_api and linkedin_api != "auto":
-        payload["linkedin_api"] = linkedin_api
-    excluded_titles = _split_repeated_values(getattr(args, "excluded_title", None))
-    if excluded_titles:
-        payload["excluded_titles"] = excluded_titles
-    for arg_name, payload_key, context in (
-        ("extra_params_json", "extra_params", "extra-params"),
-        ("company_extra_params_json", "company_extra_params", "company-extra-params"),
-        ("people_extra_params_json", "people_extra_params", "people-extra-params"),
-    ):
-        parsed = _load_optional_json_object(getattr(args, arg_name, None), context=context)
-        if parsed is not None:
-            payload[payload_key] = parsed
-    return payload
-
-
-def _wait_for_linkedin_list_build(
-    job_id: str,
-    args: argparse.Namespace,
-    *,
-    runtime: LinkedInCommandRuntime,
-    token: Optional[str],
-) -> Dict[str, Any]:
-    started = time.time()
-    interval = max(1, int(getattr(args, "poll_interval", 5) or 5))
-    timeout = max(0, int(getattr(args, "wait_timeout", 0) or 0))
-    terminal = {"completed", "error", "cancelled"}
-    latest: Dict[str, Any] = {}
-
-    while True:
-        latest = runtime.request_api(
-            "GET",
-            f"/api/integrations/linkedin/list-builds/{job_id}",
-            base_url=args.base_url,
-            token=token,
-            use_x_api_key=args.use_x_api_key,
-            timeout=args.timeout,
-            verbose=args.verbose,
-        )
-        status = str(latest.get("status") or "").strip().lower() if isinstance(latest, dict) else ""
-        if status in terminal:
-            return latest
-        if timeout and (time.time() - started) >= timeout:
-            return latest
-        time.sleep(interval)
-
-
-def cmd_linkedin_list_build_create(args: argparse.Namespace, *, runtime: LinkedInCommandRuntime) -> None:
-    token = runtime.resolve_token(args.token, required=True)
-    payload = _normalize_linkedin_list_build_payload(args, runtime=runtime)
-    data = runtime.request_api(
-        "POST",
-        "/api/integrations/linkedin/list-builds",
-        base_url=args.base_url,
-        token=token,
-        use_x_api_key=args.use_x_api_key,
-        payload=payload,
-        timeout=args.timeout,
-        verbose=args.verbose,
-    )
-    if getattr(args, "wait", False) and isinstance(data, dict) and data.get("job_id"):
-        data = _wait_for_linkedin_list_build(str(data["job_id"]), args, runtime=runtime, token=token)
-    runtime.print_json(data, args.compact)
+def _coerce_filter_arg_value(raw: str) -> Any:
+    value = str(raw or "").strip()
+    if not value:
+        return ""
+    if value[0] in "[{\"" or value.lower() in {"true", "false", "null"}:
+        try:
+            return json.loads(value)
+        except Exception:
+            pass
+    if "," in value:
+        return [part.strip() for part in value.split(",") if part.strip()]
+    return value
 
 
-def cmd_linkedin_list_build_status(args: argparse.Namespace, *, runtime: LinkedInCommandRuntime) -> None:
-    token = runtime.resolve_token(args.token, required=True)
-    job_id = str(args.job_id).strip()
-    data = runtime.request_api(
-        "GET",
-        f"/api/integrations/linkedin/list-builds/{job_id}",
-        base_url=args.base_url,
-        token=token,
-        use_x_api_key=args.use_x_api_key,
-        timeout=args.timeout,
-        verbose=args.verbose,
-    )
-    runtime.print_json(data, args.compact)
+def _parse_filter_pairs(values: Optional[List[str]], *, context: str) -> Dict[str, Any]:
+    filters: Dict[str, Any] = {}
+    for raw in values or []:
+        item = str(raw or "").strip()
+        if not item:
+            continue
+        if "=" not in item:
+            raise AutotouchInputError(f"{context} filters must use FIELD=VALUE")
+        field, value = item.split("=", 1)
+        field = field.strip()
+        if not field:
+            raise AutotouchInputError(f"{context} filter field is empty")
+        filters[field] = _coerce_filter_arg_value(value)
+    return filters
 
 
-def cmd_linkedin_list_build_results(args: argparse.Namespace, *, runtime: LinkedInCommandRuntime) -> None:
-    token = runtime.resolve_token(args.token, required=True)
-    job_id = str(args.job_id).strip()
-    params: Dict[str, Any] = {
-        "type": str(getattr(args, "type", "people") or "people"),
-        "page": max(1, int(getattr(args, "page", 1) or 1)),
-        "page_size": max(1, min(int(getattr(args, "page_size", 50) or 50), 500)),
-    }
-    data = runtime.request_api(
-        "GET",
-        f"/api/integrations/linkedin/list-builds/{job_id}/results",
-        base_url=args.base_url,
-        token=token,
-        use_x_api_key=args.use_x_api_key,
-        params=params,
-        timeout=args.timeout,
-        verbose=args.verbose,
-    )
-    runtime.print_json(data, args.compact)
+def _add_repeated_filter(filters: Dict[str, Any], field: str, values: Optional[List[str]]) -> None:
+    parsed = _split_repeated_values(values)
+    if parsed:
+        filters[field] = parsed
 
 
 def cmd_linkedin_filters(args: argparse.Namespace, *, runtime: LinkedInCommandRuntime) -> None:
@@ -397,7 +305,7 @@ def register_linkedin_subcommands(
     handlers: Dict[str, Callable[[argparse.Namespace], None]],
     recipe_types: Sequence[str],
 ) -> None:
-    parser = subparsers.add_parser("linkedin", help="LinkedIn list-building operations")
+    parser = subparsers.add_parser("linkedin", help="Connected LinkedIn search and engagement operations")
     linkedin_sub = parser.add_subparsers(dest="linkedin_cmd", required=True)
 
     recipe_parser = linkedin_sub.add_parser("recipe", help="Print LinkedIn payload recipes for search and list-building")
@@ -420,9 +328,9 @@ def register_linkedin_subcommands(
     search_parser.add_argument("--url", help="Full LinkedIn/Sales Navigator search URL (overrides keyword filters)")
     search_parser.add_argument("--category", choices=["people", "companies", "jobs", "posts"], default="people", help="Search category (default: people)")
     search_parser.add_argument("--keywords", help="Free-text keyword search")
-    search_parser.add_argument("--linkedin-api", choices=["auto", "classic", "sales_navigator"], default="auto", help="API mode (default: auto; uses connected account mode)")
+    search_parser.add_argument("--linkedin-api", choices=["auto", "classic", "sales_navigator"], default="auto", help=argparse.SUPPRESS)
     search_parser.add_argument("--cursor", help="Pagination cursor from previous response")
-    search_parser.add_argument("--limit", type=int, default=25, help="Results per page, 1-250 (default: 25)")
+    search_parser.add_argument("--limit", type=int, default=25, help="Results per page, 1-100 (default: 25)")
     search_parser.add_argument("--extra-params-json", help="JSON object with additional search filters (location IDs, industry, etc.)")
     add_api_common_arguments(search_parser)
     search_parser.set_defaults(func=handlers["search"])
@@ -430,7 +338,7 @@ def register_linkedin_subcommands(
     params_parser = linkedin_sub.add_parser("search-params", help="Resolve names to LinkedIn parameter IDs for search filters")
     params_parser.add_argument("--type", required=True, help="Parameter type: location, industry, company, school, title, language, etc.")
     params_parser.add_argument("--keywords", default="", help="Search text to match")
-    params_parser.add_argument("--linkedin-api", choices=["auto", "classic", "sales_navigator"], default="auto", help="Resolver service (default: auto; uses connected account mode)")
+    params_parser.add_argument("--linkedin-api", choices=["auto", "classic", "sales_navigator"], default="auto", help=argparse.SUPPRESS)
     params_parser.add_argument("--limit", type=int, default=25, help="Max results, 1-250 (default: 25)")
     add_api_common_arguments(params_parser)
     params_parser.set_defaults(func=handlers["search_params"])
@@ -443,41 +351,6 @@ def register_linkedin_subcommands(
     add_api_common_arguments(filters_parser)
     filters_parser.set_defaults(func=handlers["filters"])
 
-    list_build_parser = linkedin_sub.add_parser("list-build", help="Create and inspect paced LinkedIn list-build jobs")
-    list_build_sub = list_build_parser.add_subparsers(dest="linkedin_list_build_cmd", required=True)
-
-    list_build_create = list_build_sub.add_parser("create", help="Create a paced background LinkedIn list-build job")
-    list_build_create.add_argument("--data-json", help="Explicit list-build payload JSON (overrides individual flags)")
-    list_build_create.add_argument("--data-file", help="Path to list-build payload JSON file")
-    list_build_create.add_argument("--mode", choices=["company-first-people"], default="company-first-people", help="List build mode")
-    list_build_create.add_argument("--linkedin-api", choices=["auto", "classic", "sales_navigator"], default="auto", help="API mode (default: auto; uses connected account mode)")
-    list_build_create.add_argument("--company-query", help="Company-search query used to build the seed account set")
-    list_build_create.add_argument("--people-query", help="People-search query/title terms")
-    list_build_create.add_argument("--headcount", default="1-10", help="Company headcount range, e.g. 1-10 or 11-50")
-    list_build_create.add_argument("--num-results", type=int, default=100, help="Target number of people results, 1-1000")
-    list_build_create.add_argument("--excluded-title", action="append", help="Title to exclude after results return; repeat or comma-separate")
-    list_build_create.add_argument("--extra-params-json", help="JSON object applied to both company and people searches")
-    list_build_create.add_argument("--company-extra-params-json", help="JSON object applied only to company search")
-    list_build_create.add_argument("--people-extra-params-json", help="JSON object applied only to people search")
-    list_build_create.add_argument("--wait", action="store_true", help="Poll until the job reaches completed, error, or cancelled")
-    list_build_create.add_argument("--poll-interval", type=int, default=5, help="Polling interval seconds for --wait")
-    list_build_create.add_argument("--wait-timeout", type=int, default=0, help="Max seconds to wait (0 = no timeout)")
-    add_api_common_arguments(list_build_create)
-    list_build_create.set_defaults(func=handlers["list_build_create"])
-
-    list_build_status = list_build_sub.add_parser("status", help="Get LinkedIn list-build job status")
-    list_build_status.add_argument("--job-id", required=True, help="LinkedIn list-build job id")
-    add_api_common_arguments(list_build_status)
-    list_build_status.set_defaults(func=handlers["list_build_status"])
-
-    list_build_results = list_build_sub.add_parser("results", help="Get LinkedIn list-build results")
-    list_build_results.add_argument("--job-id", required=True, help="LinkedIn list-build job id")
-    list_build_results.add_argument("--type", choices=["people", "companies", "all"], default="people", help="Result type")
-    list_build_results.add_argument("--page", type=int, default=1, help="Results page")
-    list_build_results.add_argument("--page-size", type=int, default=50, help="Results per page, 1-500")
-    add_api_common_arguments(list_build_results)
-    list_build_results.set_defaults(func=handlers["list_build_results"])
-
     posts_parser = linkedin_sub.add_parser("posts", help="List LinkedIn posts for a user")
     posts_parser.add_argument("--identifier", required=True, help="LinkedIn profile URL, public ID, or URN")
     posts_parser.add_argument("--cursor", help="Pagination cursor from previous response")

autotouch_cli-0.2.79/autotouch_cli/commands/list_build.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import argparse
+import json
+import time
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, Optional
+
+from autotouch_cli.exceptions import AutotouchInputError, AutotouchTimeoutError
+
+
+@dataclass(frozen=True)
+class ListBuildCommandRuntime:
+    resolve_token: Callable[[Optional[str], bool], Optional[str]]
+    request_api: Callable[..., Any]
+    print_json: Callable[[Any, bool], None]
+    load_json_input: Callable[..., Any]
+
+
+def _payload(args: argparse.Namespace, *, runtime: ListBuildCommandRuntime, kind: str) -> Dict[str, Any]:
+    explicit = runtime.load_json_input(
+        inline_json=getattr(args, "data_json", None),
+        file_path=getattr(args, "data_file", None),
+        context="data",
+        default=None,
+    )
+    if explicit is not None:
+        if not isinstance(explicit, dict):
+            raise AutotouchInputError("list-build payload must be a JSON object")
+        explicit.setdefault("kind", kind)
+        return explicit
+    filters: Dict[str, Any] = {}
+    for attr, key in (
+        ("geo_id", "geo_ids"),
+        ("industry_id", "industry_ids"),
+        ("company_size", "company_sizes"),
+        ("current_company_id", "current_company_ids"),
+        ("past_company_id", "past_company_ids"),
+        ("school_id", "school_ids"),
+    ):
+        values = getattr(args, attr, None) or []
+        if values:
+            filters[key] = values
+    if getattr(args, "has_jobs", False):
+        filters["has_jobs"] = True
+    profile_language = str(getattr(args, "profile_language", "") or "").strip()
+    if profile_language:
+        filters["profile_language"] = profile_language
+    payload: Dict[str, Any] = {
+        "kind": kind,
+        "num_results": max(1, min(int(getattr(args, "num_results", 100) or 100), 10000)),
+        "page_size": max(1, min(int(getattr(args, "page_size", 25) or 25), 100)),
+        "filters": filters,
+    }
+    for attr in ("list_name", "keywords", "title"):
+        value = str(getattr(args, attr, "") or "").strip()
+        if value:
+            payload[attr] = value
+    return payload
+
+
+def _wait(job_id: str, args: argparse.Namespace, *, runtime: ListBuildCommandRuntime, token: Optional[str]) -> Any:
+    started = time.time()
+    while True:
+        data = runtime.request_api(
+            "GET",
+            f"/api/list-builds/{job_id}",
+            base_url=args.base_url,
+            token=token,
+            use_x_api_key=args.use_x_api_key,
+            timeout=args.timeout,
+            verbose=args.verbose,
+        )
+        if str(data.get("status") or "").lower() in {"completed", "error", "cancelled"}:
+            return data
+        timeout = int(getattr(args, "wait_timeout", 0) or 0)
+        if timeout and time.time() - started >= timeout:
+            raise AutotouchTimeoutError(f"Timed out waiting for list build {job_id}")
+        time.sleep(max(1, int(getattr(args, "poll_interval", 5) or 5)))
+
+
+def _create(args: argparse.Namespace, *, runtime: ListBuildCommandRuntime, kind: str) -> None:
+    token = runtime.resolve_token(args.token, required=True)
+    data = runtime.request_api(
+        "POST",
+        "/api/list-builds",
+        base_url=args.base_url,
+        token=token,
+        use_x_api_key=args.use_x_api_key,
+        payload=_payload(args, runtime=runtime, kind=kind),
+        timeout=args.timeout,
+        verbose=args.verbose,
+    )
+    if getattr(args, "wait", False) and data.get("job_id"):
+        data = _wait(str(data["job_id"]), args, runtime=runtime, token=token)
+    runtime.print_json(data, args.compact)
+
+
+def cmd_list_build_companies(args: argparse.Namespace, *, runtime: ListBuildCommandRuntime) -> None:
+    _create(args, runtime=runtime, kind="companies")
+
+
+def cmd_list_build_leads(args: argparse.Namespace, *, runtime: ListBuildCommandRuntime) -> None:
+    _create(args, runtime=runtime, kind="leads")
+
+
+def cmd_list_build_status(args: argparse.Namespace, *, runtime: ListBuildCommandRuntime) -> None:
+    token = runtime.resolve_token(args.token, required=True)
+    data = runtime.request_api(
+        "GET",
+        f"/api/list-builds/{args.job_id}",
+        base_url=args.base_url,
+        token=token,
+        use_x_api_key=args.use_x_api_key,
+        timeout=args.timeout,
+        verbose=args.verbose,
+    )
+    runtime.print_json(data, args.compact)
+
+
+def cmd_list_build_results(args: argparse.Namespace, *, runtime: ListBuildCommandRuntime) -> None:
+    token = runtime.resolve_token(args.token, required=True)
+    data = runtime.request_api(
+        "GET",
+        f"/api/list-builds/{args.job_id}/results?type={args.type}&page={args.page}&page_size={args.page_size}",
+        base_url=args.base_url,
+        token=token,
+        use_x_api_key=args.use_x_api_key,
+        timeout=args.timeout,
+        verbose=args.verbose,
+    )
+    runtime.print_json(data, args.compact)
+
+
+def register_list_build_subcommands(
+    subparsers: argparse._SubParsersAction[argparse.ArgumentParser],
+    *,
+    add_api_common_arguments: Callable[[argparse.ArgumentParser], None],
+    handlers: Dict[str, Callable[[argparse.Namespace], None]],
+) -> None:
+    parser = subparsers.add_parser("list-build", help="Build durable company and lead lists")
+    sub = parser.add_subparsers(dest="list_build_cmd", required=True)
+
+    def add_create_args(p: argparse.ArgumentParser) -> None:
+        p.add_argument("--data-json", help="Explicit list-build payload JSON")
+        p.add_argument("--data-file", help="Path to list-build payload JSON file")
+        p.add_argument("--list-name", help="Optional display name")
+        p.add_argument("--keywords", help="Search keywords")
+        p.add_argument("--title", help="Lead title/persona query")
+        p.add_argument("--geo-id", action="append", help="Geography ID; repeat or comma-separate in JSON")
+        p.add_argument("--industry-id", action="append", help="Industry ID; repeat or comma-separate in JSON")
+        p.add_argument("--company-size", action="append", help="Company size bucket, e.g. 1-10 or 11-50")
+        p.add_argument("--current-company-id", action="append", help="Company ID for lead search")
+        p.add_argument("--past-company-id", action="append", help="Past company ID for lead search")
+        p.add_argument("--school-id", action="append", help="School ID for lead search")
+        p.add_argument("--profile-language", help="Profile language code, e.g. en")
+        p.add_argument("--has-jobs", action="store_true", help="Only include companies with active job listings")
+        p.add_argument("--num-results", type=int, default=100, help="Target result count, 1-10000")
+        p.add_argument("--page-size", type=int, default=25, help="Provider page size")
+        p.add_argument("--wait", action="store_true", help="Poll until terminal status")
+        p.add_argument("--poll-interval", type=int, default=5, help="Polling interval seconds for --wait")
+        p.add_argument("--wait-timeout", type=int, default=0, help="Max seconds to wait (0 = no timeout)")
+        add_api_common_arguments(p)
+
+    companies = sub.add_parser("companies", help="Build a company/account list")
+    add_create_args(companies)
+    companies.set_defaults(func=handlers["companies"])
+
+    leads = sub.add_parser("leads", help="Build a lead/contact list")
+    add_create_args(leads)
+    leads.set_defaults(func=handlers["leads"])
+
+    status = sub.add_parser("status", help="Get list-build job status")
+    status.add_argument("--job-id", required=True)
+    add_api_common_arguments(status)
+    status.set_defaults(func=handlers["status"])
+
+    results = sub.add_parser("results", help="Get list-build results")
+    results.add_argument("--job-id", required=True)
+    results.add_argument("--type", choices=["items", "companies", "leads", "all"], default="items")
+    results.add_argument("--page", type=int, default=1)
+    results.add_argument("--page-size", type=int, default=50)
+    add_api_common_arguments(results)
+    results.set_defaults(func=handlers["results"])
+