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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autotouch-cli
-Version: 0.2.70
+Version: 0.2.73
 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,6 +133,9 @@ 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`
+- Run one LinkedIn search page/debug replay: `autotouch linkedin search`
 - Run controlled slices: `autotouch columns run-next`
 - Poll authoritative state: `autotouch jobs get`
 - Create/activate sequences: `autotouch sequences recipe`, `autotouch sequences create`, `autotouch sequences activate`
@@ -145,10 +148,19 @@ 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 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
 - `pip install 'autotouch-cli[mongo]'` if you need the Mongo-backed `status` / `watch` commands
 
+## Realtime Table Updates
+
+Research-table cell updates are persistence-first. Writers update Mongo `cells`; the API-side Mongo change-stream listener emits table-scoped `cells_update_batch` events. Workers should not emit per-cell socket events directly, and `/api/events/emit` is not a cell-update transport.
+
+CSV import/export and long-running worker flows still emit low-rate lifecycle/progress events such as `table_update`, but saved cell state is the source of truth for table rendering. For the full contract, see `docs/platform/realtime-events.md` and `docs/workers/bulk-jobs.md`.
+
 ## LLM Columns
 
 For `llm_enrichment` in `agent` mode, the recommended path is:
@@ -175,3 +187,4 @@ Prompt variables in authored prompts support nested JSON access:
 - Agent playbook: https://github.com/nicolonic/autotouch_main/blob/main/docs/research-table/guides/autotouch-cli-agent-playbook.md
 - Tables/API reference: https://github.com/nicolonic/autotouch_main/blob/main/docs/research-table/reference/tables-api.md
 - Authentication/scopes: https://github.com/nicolonic/autotouch_main/blob/main/docs/platform/authentication.md
+- Instantly/Smartlead external sending accounts: https://github.com/nicolonic/autotouch_main/blob/main/docs/integrations/email-automation-platforms.md

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

@@ -108,6 +108,9 @@ 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`
+- Run one LinkedIn search page/debug replay: `autotouch linkedin search`
 - Run controlled slices: `autotouch columns run-next`
 - Poll authoritative state: `autotouch jobs get`
 - Create/activate sequences: `autotouch sequences recipe`, `autotouch sequences create`, `autotouch sequences activate`
@@ -120,10 +123,19 @@ 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 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
 - `pip install 'autotouch-cli[mongo]'` if you need the Mongo-backed `status` / `watch` commands
 
+## Realtime Table Updates
+
+Research-table cell updates are persistence-first. Writers update Mongo `cells`; the API-side Mongo change-stream listener emits table-scoped `cells_update_batch` events. Workers should not emit per-cell socket events directly, and `/api/events/emit` is not a cell-update transport.
+
+CSV import/export and long-running worker flows still emit low-rate lifecycle/progress events such as `table_update`, but saved cell state is the source of truth for table rendering. For the full contract, see `docs/platform/realtime-events.md` and `docs/workers/bulk-jobs.md`.
+
 ## LLM Columns
 
 For `llm_enrichment` in `agent` mode, the recommended path is:
@@ -150,3 +162,4 @@ Prompt variables in authored prompts support nested JSON access:
 - Agent playbook: https://github.com/nicolonic/autotouch_main/blob/main/docs/research-table/guides/autotouch-cli-agent-playbook.md
 - Tables/API reference: https://github.com/nicolonic/autotouch_main/blob/main/docs/research-table/reference/tables-api.md
 - Authentication/scopes: https://github.com/nicolonic/autotouch_main/blob/main/docs/platform/authentication.md
+- Instantly/Smartlead external sending accounts: https://github.com/nicolonic/autotouch_main/blob/main/docs/integrations/email-automation-platforms.md

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

@@ -93,7 +93,11 @@ from autotouch_cli.commands.leads import (
 from autotouch_cli.commands.linkedin import (
     LinkedInCommandRuntime as LinkedInCommandHandlerRuntime,
     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,
@@ -1544,6 +1548,10 @@ _register("linkedin_status", cmd_linkedin_status_impl, _linkedin_command_runtime
 _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)
@@ -1962,6 +1970,9 @@ def cmd_capabilities(args: argparse.Namespace) -> None:
                 print("Not for         :")
                 for item in not_for:
                     print(f"  - {item}")
+            filter_count = len((linkedin.get("filter_catalog") or {}).get("filters") or [])
+            if filter_count:
+                print(f"Structured filters: {filter_count} exposed via `autotouch linkedin filters`")
             print("Tip: run `autotouch linkedin recipe` for example payloads.")
         if isinstance(search, dict):
             print("")

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

@@ -25,6 +25,7 @@ _AUTH_MODE_EXACT: Dict[str, str] = {
     "webhooks.ingest": "webhook_token",
     "cli-manifest": "none",
     "cli-reference": "none",
+    "linkedin.filters": "none",
     "schema": "none",
     "status": "none",
     "watch": "none",

{autotouch_cli-0.2.70 → autotouch_cli-0.2.73}/autotouch_cli/commands/agents.py

@@ -59,15 +59,47 @@ def cmd_agents_create(args: argparse.Namespace, *, runtime: AgentCommandRuntime)
             payload["targetType"] = args.target
         if args.assigned_user:
             payload["assignedUserId"] = args.assigned_user
+        # Build the schedule object from any provided schedule flags. We only
+        # send a `schedule` key when the user actually set at least one field.
+        schedule_payload: Dict[str, Any] = {}
         if args.schedule_time:
-            tz = getattr(args, "schedule_tz", None) or "UTC"
-            payload["schedule"] = {"timezone": tz, "timeOfDay": args.schedule_time}
+            schedule_payload["timeOfDay"] = args.schedule_time
+        schedule_tz = getattr(args, "schedule_tz", None)
+        if schedule_tz:
+            schedule_payload["timezone"] = schedule_tz
+        schedule_frequency = getattr(args, "schedule_frequency", None)
+        if schedule_frequency:
+            schedule_payload["frequency"] = schedule_frequency
+        schedule_days = getattr(args, "schedule_days", None)
+        if schedule_days:
+            schedule_payload["days"] = schedule_days
+        schedule_day_of_week = getattr(args, "schedule_day_of_week", None)
+        if schedule_day_of_week is not None:
+            schedule_payload["dayOfWeek"] = schedule_day_of_week
+        schedule_window_start = getattr(args, "schedule_window_start", None)
+        if schedule_window_start:
+            schedule_payload["windowStart"] = schedule_window_start
+        schedule_window_end = getattr(args, "schedule_window_end", None)
+        if schedule_window_end:
+            schedule_payload["windowEnd"] = schedule_window_end
+        if schedule_payload:
+            # Backfill required fields the API expects (timezone defaults to UTC,
+            # timeOfDay defaults to 09:00 — required even for sub-daily frequencies).
+            schedule_payload.setdefault("timezone", "UTC")
+            schedule_payload.setdefault("timeOfDay", "09:00")
+            payload["schedule"] = schedule_payload
         if getattr(args, "auto_find_email", False):
             payload["autoFindEmail"] = True
         if getattr(args, "auto_find_phone", False):
             payload["autoFindPhone"] = True
         if getattr(args, "auto_broaden", False):
             payload["autoBroadenSearch"] = True
+        auto_create_lead_mode = getattr(args, "auto_create_lead_mode", None)
+        if auto_create_lead_mode:
+            payload["autoCreateLeadMode"] = auto_create_lead_mode
+        auto_sequence_id = getattr(args, "auto_sequence_id", None)
+        if auto_sequence_id:
+            payload["autoSequenceId"] = auto_sequence_id
         status = getattr(args, "status", None)
         if status:
             payload["status"] = status
@@ -165,6 +197,47 @@ def cmd_agents_update(args: argparse.Namespace, *, runtime: AgentCommandRuntime)
             payload["autoFindPhone"] = args.auto_find_phone
         if getattr(args, "auto_broaden", None) is not None:
             payload["autoBroadenSearch"] = args.auto_broaden
+        if getattr(args, "auto_create_lead_mode", None):
+            payload["autoCreateLeadMode"] = args.auto_create_lead_mode
+        # Pass an empty string to clear the auto-sequence link.
+        auto_sequence_id_arg = getattr(args, "auto_sequence_id", None)
+        if auto_sequence_id_arg is not None:
+            payload["autoSequenceId"] = auto_sequence_id_arg or None
+
+        # Schedule changes need a full schedule object, so we merge any
+        # provided flags onto the agent's existing schedule.
+        schedule_flag_values = {
+            "timeOfDay": getattr(args, "schedule_time", None),
+            "timezone": getattr(args, "schedule_tz", None),
+            "frequency": getattr(args, "schedule_frequency", None),
+            "days": getattr(args, "schedule_days", None),
+            "dayOfWeek": getattr(args, "schedule_day_of_week", None),
+            "windowStart": getattr(args, "schedule_window_start", None),
+            "windowEnd": getattr(args, "schedule_window_end", None),
+        }
+        if any(v is not None for v in schedule_flag_values.values()):
+            existing = runtime.request_api(
+                "GET", f"/api/agents/{args.agent_id}",
+                base_url=args.base_url, token=token,
+                use_x_api_key=args.use_x_api_key,
+                timeout=args.timeout, verbose=args.verbose,
+            )
+            existing_schedule = (existing or {}).get("schedule") or {}
+            merged_schedule: Dict[str, Any] = {
+                "timezone": existing_schedule.get("timezone") or "UTC",
+                "timeOfDay": existing_schedule.get("timeOfDay") or "09:00",
+                "frequency": existing_schedule.get("frequency") or "daily",
+                "days": existing_schedule.get("days") or "all",
+                "dayOfWeek": existing_schedule.get("dayOfWeek") or 0,
+            }
+            if existing_schedule.get("windowStart"):
+                merged_schedule["windowStart"] = existing_schedule["windowStart"]
+            if existing_schedule.get("windowEnd"):
+                merged_schedule["windowEnd"] = existing_schedule["windowEnd"]
+            for key, value in schedule_flag_values.items():
+                if value is not None:
+                    merged_schedule[key] = value
+            payload["schedule"] = merged_schedule
 
     data = runtime.request_api(
         "PATCH", f"/api/agents/{args.agent_id}",
@@ -376,11 +449,52 @@ def register_agents_subcommands(
     pac.add_argument("--name", help="Agent name")
     pac.add_argument("--target", choices=["LEADS"], help="Target type")
     pac.add_argument("--assigned-user", dest="assigned_user", help="Assigned user ID")
-    pac.add_argument("--schedule-time", dest="schedule_time", help="Time of day (HH:MM)")
+    pac.add_argument("--schedule-time", dest="schedule_time", help="Time of day (HH:MM) — used by daily/weekly")
     pac.add_argument("--schedule-tz", dest="schedule_tz", help="Timezone (default: UTC)")
+    pac.add_argument(
+        "--schedule-frequency",
+        dest="schedule_frequency",
+        choices=["hourly", "every_6h", "every_12h", "daily", "weekly"],
+        help="Run cadence (default: daily)",
+    )
+    pac.add_argument(
+        "--schedule-days",
+        dest="schedule_days",
+        choices=["all", "weekdays"],
+        help="Which days to run on for sub-weekly cadences (default: all)",
+    )
+    pac.add_argument(
+        "--schedule-day-of-week",
+        dest="schedule_day_of_week",
+        type=int,
+        choices=range(0, 7),
+        metavar="0-6",
+        help="Day of week for weekly cadence (0=Mon, 6=Sun)",
+    )
+    pac.add_argument(
+        "--schedule-window-start",
+        dest="schedule_window_start",
+        help="Active-hours window start (HH:MM) — used by hourly/every_6h/every_12h",
+    )
+    pac.add_argument(
+        "--schedule-window-end",
+        dest="schedule_window_end",
+        help="Active-hours window end (HH:MM) — used by hourly/every_6h/every_12h",
+    )
     pac.add_argument("--auto-find-email", dest="auto_find_email", action="store_true", default=False, help="Enable auto email finder")
     pac.add_argument("--auto-find-phone", dest="auto_find_phone", action="store_true", default=False, help="Enable auto phone finder")
     pac.add_argument("--auto-broaden", dest="auto_broaden", action="store_true", default=False, help="Enable auto broaden search")
+    pac.add_argument(
+        "--auto-create-lead-mode",
+        dest="auto_create_lead_mode",
+        choices=["qualified_only", "everyone", "manual_only"],
+        help="Which discovered prospects become leads (default: qualified_only)",
+    )
+    pac.add_argument(
+        "--auto-sequence-id",
+        dest="auto_sequence_id",
+        help="Sequence ID — discovered leads get auto-enrolled. Triggers outreach automatically.",
+    )
     pac.add_argument("--status", choices=["DRAFT", "ACTIVE", "PAUSED"], help="Initial status")
     pac.add_argument("--from-file", dest="from_file", help="Path to JSON payload file")
     pac.add_argument("--generate", action="store_true", help="Auto-generate persona, topics, and job signal config")
@@ -395,6 +509,49 @@ def register_agents_subcommands(
     pau.add_argument("--auto-find-email", dest="auto_find_email", type=_bool_arg, default=None, help="Enable/disable auto email finder")
     pau.add_argument("--auto-find-phone", dest="auto_find_phone", type=_bool_arg, default=None, help="Enable/disable auto phone finder")
     pau.add_argument("--auto-broaden", dest="auto_broaden", type=_bool_arg, default=None, help="Enable/disable auto broaden search")
+    pau.add_argument(
+        "--auto-create-lead-mode",
+        dest="auto_create_lead_mode",
+        choices=["qualified_only", "everyone", "manual_only"],
+        help="Which discovered prospects become leads",
+    )
+    pau.add_argument(
+        "--auto-sequence-id",
+        dest="auto_sequence_id",
+        help="Sequence ID for auto-enrollment. Pass empty string to clear.",
+    )
+    pau.add_argument("--schedule-time", dest="schedule_time", help="Time of day (HH:MM) — used by daily/weekly")
+    pau.add_argument("--schedule-tz", dest="schedule_tz", help="Timezone")
+    pau.add_argument(
+        "--schedule-frequency",
+        dest="schedule_frequency",
+        choices=["hourly", "every_6h", "every_12h", "daily", "weekly"],
+        help="Run cadence",
+    )
+    pau.add_argument(
+        "--schedule-days",
+        dest="schedule_days",
+        choices=["all", "weekdays"],
+        help="Which days to run on for sub-weekly cadences",
+    )
+    pau.add_argument(
+        "--schedule-day-of-week",
+        dest="schedule_day_of_week",
+        type=int,
+        choices=range(0, 7),
+        metavar="0-6",
+        help="Day of week for weekly cadence (0=Mon, 6=Sun)",
+    )
+    pau.add_argument(
+        "--schedule-window-start",
+        dest="schedule_window_start",
+        help="Active-hours window start (HH:MM) — used by hourly/every_6h/every_12h",
+    )
+    pau.add_argument(
+        "--schedule-window-end",
+        dest="schedule_window_end",
+        help="Active-hours window end (HH:MM) — used by hourly/every_6h/every_12h",
+    )
     pau.add_argument("--from-file", dest="from_file", help="Path to JSON patch payload file")
     add_api_common_arguments(pau)
     pau.set_defaults(func=handlers["update"])

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

@@ -2,9 +2,11 @@ from __future__ import annotations
 
 import argparse
 import json
+import time
 from dataclasses import dataclass
-from typing import Any, Callable, Dict, Optional, Sequence
+from typing import Any, Callable, Dict, List, Optional, Sequence
 
+from autotouch_shared.linkedin_filters import linkedin_filter_catalog
 from autotouch_cli.exceptions import AutotouchInputError
 
 
@@ -66,8 +68,8 @@ def _normalize_linkedin_search_payload(args: argparse.Namespace, *, runtime: Lin
     keywords = str(getattr(args, "keywords", "") or "").strip()
     if keywords:
         payload["keywords"] = keywords
-    linkedin_api = str(getattr(args, "linkedin_api", "classic") or "classic").strip()
-    if linkedin_api:
+    linkedin_api = str(getattr(args, "linkedin_api", "auto") or "auto").strip()
+    if linkedin_api and linkedin_api != "auto":
         payload["linkedin_api"] = linkedin_api
     cursor = str(getattr(args, "cursor", "") or "").strip()
     if cursor:
@@ -101,6 +103,9 @@ def cmd_linkedin_search_params(args: argparse.Namespace, *, runtime: LinkedInCom
         "keywords": str(getattr(args, "keywords", "") or "").strip(),
         "limit": max(1, min(int(getattr(args, "limit", 25) or 25), 250)),
     }
+    linkedin_api = str(getattr(args, "linkedin_api", "auto") or "auto").strip()
+    if linkedin_api and linkedin_api != "auto":
+        payload["linkedin_api"] = linkedin_api
     data = runtime.request_api(
         "POST",
         "/api/integrations/linkedin/search/parameters",
@@ -114,6 +119,168 @@ def cmd_linkedin_search_params(args: argparse.Namespace, *, runtime: LinkedInCom
     runtime.print_json(data, args.compact)
 
 
+def _load_optional_json_object(raw: Optional[str], *, context: str) -> Optional[Dict[str, Any]]:
+    if not raw:
+        return None
+    try:
+        parsed = json.loads(raw)
+    except Exception as exc:
+        raise AutotouchInputError(f"invalid JSON for {context}: {exc}") from exc
+    if not isinstance(parsed, dict):
+        raise AutotouchInputError(f"{context} must be a JSON object")
+    return parsed
+
+
+def _split_repeated_values(values: Optional[List[str]]) -> List[str]:
+    output: List[str] = []
+    for raw in values or []:
+        for part in str(raw).replace("\n", ",").split(","):
+            value = part.strip()
+            if value:
+                output.append(value)
+    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 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 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 cmd_linkedin_filters(args: argparse.Namespace, *, runtime: LinkedInCommandRuntime) -> None:
+    output = linkedin_filter_catalog(
+        api_mode=getattr(args, "api", None),
+        category=getattr(args, "category", None),
+        field=getattr(args, "field", None),
+    )
+    out_file = str(getattr(args, "out_file", "") or "").strip()
+    if out_file:
+        with open(out_file, "w", encoding="utf-8") as f:
+            json.dump(output, f, indent=2)
+    runtime.print_json(output, args.compact)
+
+
 def cmd_linkedin_recipe(
     args: argparse.Namespace,
     *,
@@ -253,7 +420,7 @@ 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=["classic", "sales_navigator"], default="classic", help="API mode (default: classic)")
+    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("--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("--extra-params-json", help="JSON object with additional search filters (location IDs, industry, etc.)")
@@ -263,10 +430,54 @@ 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("--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"])
 
+    filters_parser = linkedin_sub.add_parser("filters", help="Print the LinkedIn/Sales Navigator structured filter catalog")
+    filters_parser.add_argument("--api", choices=["all", "classic", "sales_navigator"], default="all", help="Filter by API mode")
+    filters_parser.add_argument("--category", choices=["all", "people", "companies", "jobs", "posts"], default="all", help="Filter by search category")
+    filters_parser.add_argument("--field", help="Show one filter field or alias, e.g. headcount, company_headcount, role")
+    filters_parser.add_argument("--out-file", help="Optional path to save the selected catalog JSON")
+    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.70 → autotouch_cli-0.2.73}/autotouch_cli/core/http.py

@@ -47,7 +47,19 @@ def _decode_response_body(response: Any) -> Any:
     return response.text
 
 
+def _print_special_error_hint(body: Any) -> None:
+    detail = body.get("detail") if isinstance(body, dict) else None
+    if isinstance(detail, dict) and detail.get("error_code") == "sales_nav_reconnect_required":
+        message = detail.get("message") or "Sales Navigator search credentials expired."
+        print(f"ERROR: {message}", file=sys.stderr)
+        print(
+            "Open Autotouch > Settings > Inbox > LinkedIn > Reconnect Sales Navigator.",
+            file=sys.stderr,
+        )
+
+
 def _print_error_body(body: Any) -> None:
+    _print_special_error_hint(body)
     if isinstance(body, (dict, list)):
         print(json.dumps(body, indent=2, default=str), file=sys.stderr)
     else:
@@ -129,6 +141,7 @@ def request_api(
             )
         print(f"ERROR: API {response.status_code}", file=sys.stderr)
         if error_body_writer is not None:
+            _print_special_error_hint(body)
             error_body_writer(body)
         else:
             _print_error_body(body)
@@ -212,6 +225,7 @@ def request_multipart_api(
             )
         print(f"ERROR: API {response.status_code}", file=sys.stderr)
         if error_body_writer is not None:
+            _print_special_error_hint(body)
             error_body_writer(body)
         else:
             _print_error_body(body)