autotouch-cli 0.2.58__tar.gz → 0.2.60__tar.gz

{autotouch_cli-0.2.58 → autotouch_cli-0.2.60}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autotouch-cli
-Version: 0.2.58
+Version: 0.2.60
 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

{autotouch_cli-0.2.58 → autotouch_cli-0.2.60}/autotouch_cli/cli.py

@@ -158,9 +158,14 @@ from autotouch_cli.commands.tasks import (
     cmd_tasks_delete as cmd_tasks_delete_impl,
     cmd_tasks_draft as cmd_tasks_draft_impl,
     cmd_tasks_get as cmd_tasks_get_impl,
+    cmd_tasks_prioritize_email as cmd_tasks_prioritize_email_impl,
+    cmd_tasks_prioritize_linkedin as cmd_tasks_prioritize_linkedin_impl,
     cmd_tasks_query as cmd_tasks_query_impl,
     cmd_tasks_recipe as cmd_tasks_recipe_impl,
+    cmd_tasks_reschedule_email as cmd_tasks_reschedule_email_impl,
+    cmd_tasks_reschedule_linkedin as cmd_tasks_reschedule_linkedin_impl,
     cmd_tasks_schedule_email as cmd_tasks_schedule_email_impl,
+    cmd_tasks_schedule_linkedin as cmd_tasks_schedule_linkedin_impl,
     cmd_tasks_stats as cmd_tasks_stats_impl,
     cmd_tasks_update as cmd_tasks_update_impl,
 )
@@ -1460,6 +1465,11 @@ _register("tasks_bulk_update", cmd_tasks_bulk_update_impl, _task_command_runtime
 _register("tasks_bulk_delete", cmd_tasks_bulk_delete_impl, _task_command_runtime)
 _register("tasks_draft", cmd_tasks_draft_impl, _task_command_runtime)
 _register("tasks_schedule_email", cmd_tasks_schedule_email_impl, _task_command_runtime)
+_register("tasks_prioritize_email", cmd_tasks_prioritize_email_impl, _task_command_runtime)
+_register("tasks_reschedule_email", cmd_tasks_reschedule_email_impl, _task_command_runtime)
+_register("tasks_schedule_linkedin", cmd_tasks_schedule_linkedin_impl, _task_command_runtime)
+_register("tasks_prioritize_linkedin", cmd_tasks_prioritize_linkedin_impl, _task_command_runtime)
+_register("tasks_reschedule_linkedin", cmd_tasks_reschedule_linkedin_impl, _task_command_runtime)
 _register("tasks_recipe", cmd_tasks_recipe_impl, _task_command_runtime)
 
 # -- Webhook commands --

{autotouch_cli-0.2.58 → autotouch_cli-0.2.60}/autotouch_cli/commands/sequences.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
 import argparse
+import json
+import sys
 from dataclasses import dataclass
 from typing import Any, Callable, Dict, Optional, Sequence
 
@@ -30,6 +32,51 @@ class SequenceCommandRuntime:
     sequence_runtime_factory: Callable[[], SequenceRuntime]
 
 
+def _sequence_enroll_research_context(payload: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    research_context = payload.get("researchContext")
+    return research_context if isinstance(research_context, dict) else None
+
+
+def _sequence_enroll_output_hints(payload: Dict[str, Any]) -> Dict[str, Any]:
+    research_context = _sequence_enroll_research_context(payload) or {}
+    source_table_id = str(
+        research_context.get("sourceTableId")
+        or research_context.get("source_table_id")
+        or ""
+    ).strip() or None
+    attached = bool(research_context)
+
+    if attached:
+        context_hint = (
+            "Attached research context will follow later tasks, sidecar views, and AI drafts"
+            + (f" using table {source_table_id}." if source_table_id else ".")
+        )
+    else:
+        context_hint = (
+            "No research context is attached; later tasks and AI drafts will use lead/company context only."
+        )
+
+    return {
+        "research_context_attached": attached,
+        "research_context_table_id": source_table_id,
+        "context_hint": context_hint,
+        "workflow_hint": (
+            "Direct enroll is best for one-off/manual adds. Use add_to_sequence when rows should "
+            "auto-enroll from a research table over time."
+        ),
+        "personalization_hint": (
+            "Attached research context does not personalize copy by itself; static copy stays the same "
+            "unless the sequence uses variables or AI draft steps."
+        ),
+    }
+
+
+def _attach_sequence_enroll_hints(output: Dict[str, Any], payload: Dict[str, Any]) -> Dict[str, Any]:
+    enriched = dict(output)
+    enriched.update(_sequence_enroll_output_hints(payload))
+    return enriched
+
+
 def _sequence_mutation_params(args: argparse.Namespace) -> Optional[Dict[str, Any]]:
     return sequence_mutation_params_impl(args)
 
@@ -148,17 +195,41 @@ def cmd_sequences_update(args: argparse.Namespace, *, runtime: SequenceCommandRu
     if not isinstance(payload, dict):
         raise AutotouchInputError("sequence update requires --data-json/--data-file with a JSON object")
 
-    data = runtime.request_api(
-        "PUT",
-        f"/api/sequences/{args.sequence_id}",
-        base_url=args.base_url,
-        token=token,
-        use_x_api_key=args.use_x_api_key,
-        params=_sequence_mutation_params(args),
-        payload=payload,
-        timeout=args.timeout,
-        verbose=args.verbose,
-    )
+    try:
+        data = runtime.request_api(
+            "PUT",
+            f"/api/sequences/{args.sequence_id}",
+            base_url=args.base_url,
+            token=token,
+            use_x_api_key=args.use_x_api_key,
+            params=_sequence_mutation_params(args),
+            payload=payload,
+            timeout=args.timeout,
+            verbose=args.verbose,
+        )
+    except AutotouchAPIError as exc:
+        if exc.status_code == 409 and exc.response_body:
+            try:
+                body = json.loads(exc.response_body)
+            except Exception:
+                body = None
+            if isinstance(body, dict) and str(body.get("error") or "").strip() == "delivery_edit_locked":
+                message = str(body.get("message") or "Cannot change delivery backend because this sequence has in-flight email work.").strip()
+                policy = body.get("deliveryEditPolicy") if isinstance(body.get("deliveryEditPolicy"), dict) else {}
+                enrollment_count = int(policy.get("inFlightEnrollmentCount") or 0)
+                task_count = int(policy.get("activeEmailTaskCount") or 0)
+                outbox_count = int(policy.get("activeEmailOutboxCount") or 0)
+                print(f"ERROR: {message}", file=sys.stderr)
+                print(
+                    f"Counts: active enrollments={enrollment_count}, email tasks={task_count}, queued email jobs={outbox_count}",
+                    file=sys.stderr,
+                )
+                print(
+                    f"Hint: clone the sequence with `autotouch sequences clone --sequence-id {args.sequence_id}` and apply the delivery change there.",
+                    file=sys.stderr,
+                )
+                raise AutotouchAPIError(message, status_code=exc.status_code, response_body=exc.response_body) from exc
+        raise
     runtime.print_json(data, args.compact)
 
 
@@ -258,6 +329,7 @@ def cmd_sequences_enroll(args: argparse.Namespace, *, runtime: SequenceCommandRu
             output.setdefault("job_id", job_id)
             output["job_status_url"] = status_url
             output["watch_command"] = watch_command
+        output = _attach_sequence_enroll_hints(output, payload)
         runtime.print_json(output, args.compact)
         return
 
@@ -306,6 +378,7 @@ def cmd_sequences_enroll(args: argparse.Namespace, *, runtime: SequenceCommandRu
         "timed_out": timed_out,
         "polls": int(poll_result.get("polls") or 0),
     }
+    output = _attach_sequence_enroll_hints(output, payload)
     runtime.print_json(output, args.compact)
 
     if timed_out:
@@ -386,7 +459,10 @@ def register_sequences_subcommands(
     add_api_common_arguments(psqc)
     psqc.set_defaults(func=handlers["create"])
 
-    psqu = sequences_sub.add_parser("update", help="Update a sequence from a JSON payload")
+    psqu = sequences_sub.add_parser(
+        "update",
+        help="Update a sequence from a JSON payload (schedule changes may rewindow unsent scheduled work)",
+    )
     psqu.add_argument("--sequence-id", required=True)
     psqu.add_argument("--data-json", help="Sequence update payload JSON")
     psqu.add_argument("--data-file", help="Sequence update payload file path")
@@ -432,10 +508,17 @@ def register_sequences_subcommands(
     add_api_common_arguments(psqar)
     psqar.set_defaults(func=handlers["status"], target_status="ARCHIVED")
 
-    psqe = sequences_sub.add_parser("enroll", help="Enroll leads into a sequence")
+    psqe = sequences_sub.add_parser(
+        "enroll",
+        help="Enroll leads into a sequence (best for one-off/manual adds)",
+        description=(
+            "Direct enroll is best for one-off/manual adds. Use add_to_sequence when rows should "
+            "auto-enroll from a research table over time."
+        ),
+    )
     psqe.add_argument("--sequence-id", required=True)
-    psqe.add_argument("--data-json", help="Full enroll payload JSON")
-    psqe.add_argument("--data-file", help="Full enroll payload JSON file")
+    psqe.add_argument("--data-json", help="Full enroll payload JSON (advanced; overrides simpler flags)")
+    psqe.add_argument("--data-file", help="Full enroll payload JSON file (advanced; overrides simpler flags)")
     psqe.add_argument(
         "--lead-id",
         action="append",
@@ -445,8 +528,31 @@ def register_sequences_subcommands(
     psqe.add_argument("--lead-ids-file", help="Path to JSON/TXT/CSV file with lead ids")
     psqe.add_argument("--lead-ids-column", default="lead_id", help="CSV column for lead ids (default: lead_id)")
     psqe.add_argument("--start-date", help="Optional startDate ISO timestamp")
-    psqe.add_argument("--research-context-json", help="researchContext JSON")
-    psqe.add_argument("--research-context-file", help="researchContext JSON file")
+    psqe.add_argument(
+        "--research-context-json",
+        "--attach-research-context-json",
+        dest="research_context_json",
+        help="Advanced raw researchContext JSON for workflow-scoped table context",
+    )
+    psqe.add_argument(
+        "--research-context-file",
+        "--attach-research-context-file",
+        dest="research_context_file",
+        help="Advanced raw researchContext JSON file for workflow-scoped table context",
+    )
+    psqe.add_argument(
+        "--attach-research-table-id",
+        help="Attach research context from this table for later tasks, sidecar views, and AI drafts",
+    )
+    psqe.add_argument(
+        "--attach-research-table-name",
+        help="Optional source table name to store alongside attached research context",
+    )
+    psqe.add_argument(
+        "--attach-research-field-id",
+        action="append",
+        help="Optional research field id to keep in attached context (repeatable; comma-separated also supported)",
+    )
     psqe.add_argument("--variable-map-json", help="variableMap JSON")
     psqe.add_argument("--variable-map-file", help="variableMap JSON file")
     psqe.add_argument("--variable-overrides-json", help="variableOverrides JSON")

{autotouch_cli-0.2.58 → autotouch_cli-0.2.60}/autotouch_cli/commands/tasks.py

@@ -231,3 +231,101 @@ def cmd_tasks_schedule_email(args: argparse.Namespace, *, runtime: TaskCommandRu
         verbose=args.verbose,
     )
     runtime.print_json(data, args.compact)
+
+
+def cmd_tasks_prioritize_email(args: argparse.Namespace, *, runtime: TaskCommandRuntime) -> None:
+    token = runtime.resolve_token(args.token, required=True)
+    data = runtime.request_api(
+        "POST",
+        f"/api/task-queue/{args.task_id}/email/prioritize",
+        base_url=args.base_url,
+        token=token,
+        use_x_api_key=args.use_x_api_key,
+        params=_task_mutation_params(args),
+        timeout=args.timeout,
+        verbose=args.verbose,
+    )
+    runtime.print_json(data, args.compact)
+
+
+def cmd_tasks_reschedule_email(args: argparse.Namespace, *, runtime: TaskCommandRuntime) -> None:
+    token = runtime.resolve_token(args.token, required=True)
+    payload = runtime.load_required_object_payload(args, noun="task email reschedule")
+    data = runtime.request_api(
+        "POST",
+        f"/api/task-queue/{args.task_id}/email/reschedule",
+        base_url=args.base_url,
+        token=token,
+        use_x_api_key=args.use_x_api_key,
+        params=_task_mutation_params(args),
+        payload=payload,
+        timeout=args.timeout,
+        verbose=args.verbose,
+    )
+    runtime.print_json(data, args.compact)
+
+
+def _load_optional_task_payload(
+    args: argparse.Namespace,
+    *,
+    runtime: TaskCommandRuntime,
+    noun: str,
+) -> Dict[str, Any]:
+    payload = runtime.load_json_input(
+        inline_json=getattr(args, "data_json", None),
+        file_path=getattr(args, "data_file", None),
+        context="data",
+        default={},
+    )
+    if not isinstance(payload, dict):
+        raise AutotouchInputError(f"{noun} payload must be a JSON object")
+    return payload
+
+
+def cmd_tasks_schedule_linkedin(args: argparse.Namespace, *, runtime: TaskCommandRuntime) -> None:
+    token = runtime.resolve_token(args.token, required=True)
+    payload = _load_optional_task_payload(args, runtime=runtime, noun="task linkedin schedule")
+    data = runtime.request_api(
+        "POST",
+        f"/api/task-queue/{args.task_id}/linkedin/schedule",
+        base_url=args.base_url,
+        token=token,
+        use_x_api_key=args.use_x_api_key,
+        params=_task_mutation_params(args),
+        payload=payload,
+        timeout=args.timeout,
+        verbose=args.verbose,
+    )
+    runtime.print_json(data, args.compact)
+
+
+def cmd_tasks_prioritize_linkedin(args: argparse.Namespace, *, runtime: TaskCommandRuntime) -> None:
+    token = runtime.resolve_token(args.token, required=True)
+    data = runtime.request_api(
+        "POST",
+        f"/api/task-queue/{args.task_id}/linkedin/prioritize",
+        base_url=args.base_url,
+        token=token,
+        use_x_api_key=args.use_x_api_key,
+        params=_task_mutation_params(args),
+        timeout=args.timeout,
+        verbose=args.verbose,
+    )
+    runtime.print_json(data, args.compact)
+
+
+def cmd_tasks_reschedule_linkedin(args: argparse.Namespace, *, runtime: TaskCommandRuntime) -> None:
+    token = runtime.resolve_token(args.token, required=True)
+    payload = runtime.load_required_object_payload(args, noun="task linkedin reschedule")
+    data = runtime.request_api(
+        "POST",
+        f"/api/task-queue/{args.task_id}/linkedin/reschedule",
+        base_url=args.base_url,
+        token=token,
+        use_x_api_key=args.use_x_api_key,
+        params=_task_mutation_params(args),
+        payload=payload,
+        timeout=args.timeout,
+        verbose=args.verbose,
+    )
+    runtime.print_json(data, args.compact)

{autotouch_cli-0.2.58 → autotouch_cli-0.2.60}/autotouch_cli/core/http.py

@@ -54,6 +54,12 @@ def _print_error_body(body: Any) -> None:
         print(str(body), file=sys.stderr)
 
 
+def _serialize_error_body(body: Any) -> str:
+    if isinstance(body, (dict, list)):
+        return json.dumps(body, default=str)
+    return str(body)
+
+
 def request_api(
     method: str,
     path: str,
@@ -129,7 +135,7 @@ def request_api(
         raise AutotouchAPIError(
             f"API {response.status_code}",
             status_code=response.status_code,
-            response_body=str(body),
+            response_body=_serialize_error_body(body),
         )
     return body
 
@@ -212,6 +218,6 @@ def request_multipart_api(
         raise AutotouchAPIError(
             f"API {response.status_code}",
             status_code=response.status_code,
-            response_body=str(body),
+            response_body=_serialize_error_body(body),
         )
     return body

{autotouch_cli-0.2.58 → autotouch_cli-0.2.60}/autotouch_cli/core/validation.py

@@ -55,8 +55,18 @@ def extract_add_to_crm_field_mappings(payload: Any) -> Optional[Dict[str, Any]]:
     return {}
 
 
-def inspect_add_to_crm_field_mappings(field_mappings: Dict[str, Any]) -> Dict[str, Any]:
-    mode = "multi" if str(field_mappings.get("mode") or "").strip().lower() == "multi" else "single"
+def inspect_add_to_crm_field_mappings(
+    field_mappings: Dict[str, Any],
+    *,
+    require_company_domain: bool = True,
+) -> Dict[str, Any]:
+    raw_mode = str(field_mappings.get("mode") or "").strip().lower()
+    if raw_mode == "array":
+        mode = "array"
+    elif raw_mode == "multi":
+        mode = "multi"
+    else:
+        mode = "single"
     required_missing: List[str] = []
     optional_missing: List[str] = []
 
@@ -75,12 +85,20 @@ def inspect_add_to_crm_field_mappings(field_mappings: Dict[str, Any]) -> Dict[st
             return True
         return False
 
+    if not require_company_domain and mode != "single":
+        required_missing.append("singleModeOnlyWhenCompanyDomainOptional")
+        return {
+            "mode": mode,
+            "required_missing": required_missing,
+            "optional_missing": optional_missing,
+        }
+
     if mode == "multi":
         common = field_mappings.get("common") if isinstance(field_mappings.get("common"), dict) else {}
         leads = field_mappings.get("leads") if isinstance(field_mappings.get("leads"), list) else []
 
         common_domain = str((common or {}).get("companyDomain") or field_mappings.get("companyDomain") or "").strip()
-        if not common_domain:
+        if require_company_domain and not common_domain:
             required_missing.append("common.companyDomain")
 
         has_lead_identity = False
@@ -95,10 +113,24 @@ def inspect_add_to_crm_field_mappings(field_mappings: Dict[str, Any]) -> Dict[st
                     optional_missing.append(f"leads[{idx}].{slot}")
         if not has_lead_identity:
             required_missing.append("leads[].identityFields")
+    elif mode == "array":
+        common = field_mappings.get("common") if isinstance(field_mappings.get("common"), dict) else {}
+        template = field_mappings.get("template") if isinstance(field_mappings.get("template"), dict) else {}
+        if require_company_domain and not str((common or {}).get("companyDomain") or "").strip():
+            required_missing.append("common.companyDomain")
+        if not str(field_mappings.get("sourceColumn") or "").strip():
+            required_missing.append("sourceColumn")
+        if not _has_identity_mapping(template):
+            required_missing.append("template.identityFields")
     else:
         company_domain_key = str(field_mappings.get("companyDomain") or "").strip()
-        if not company_domain_key:
+        if require_company_domain and not company_domain_key:
             required_missing.append("companyDomain")
+        if require_company_domain:
+            if not _has_identity_mapping(field_mappings):
+                required_missing.append("identityFields")
+        elif not str(field_mappings.get("linkedinUrl") or "").strip():
+            required_missing.append("linkedinUrl")
         if not _has_identity_mapping(field_mappings):
             required_missing.append("identityFields")
         for slot in ["firstName", "lastName", "title", "companyName"]:
@@ -116,6 +148,7 @@ def validate_add_to_crm_create_payload(payload: Dict[str, Any]) -> None:
     field_mappings = extract_add_to_crm_field_mappings(payload)
     if field_mappings is None:
         return
+    config = payload.get("config") if isinstance(payload.get("config"), dict) else {}
 
     kind_value = str(payload.get("kind") or "").strip().lower()
     if kind_value != "enrichment":
@@ -130,10 +163,24 @@ def validate_add_to_crm_create_payload(payload: Dict[str, Any]) -> None:
             "Tip: run `autotouch columns recipe --type add_to_crm`."
         )
 
-    issues = inspect_add_to_crm_field_mappings(field_mappings)
+    require_company_domain = config.get("requireCompanyDomain", True)
+    if not isinstance(require_company_domain, bool):
+        raise AutotouchInputError(
+            "add_to_crm config.requireCompanyDomain must be a boolean when provided."
+        )
+
+    issues = inspect_add_to_crm_field_mappings(
+        field_mappings,
+        require_company_domain=require_company_domain,
+    )
     required_missing = issues.get("required_missing") or []
     optional_missing = issues.get("optional_missing") or []
     if required_missing:
+        if "singleModeOnlyWhenCompanyDomainOptional" in required_missing:
+            raise AutotouchInputError(
+                "add_to_crm with config.requireCompanyDomain=false only supports single-mode fieldMappings. "
+                "Tip: map config.fieldMappings.linkedinUrl and keep mode='single' for LinkedIn-First Sync to Leads."
+            )
         missing = ", ".join(str(v) for v in required_missing)
         raise AutotouchInputError(
             f"add_to_crm fieldMappings missing required keys: {missing}. "
@@ -301,11 +348,20 @@ def run_precheck_for_add_to_crm(
     if field_mappings is None:
         return
 
-    issues = inspect_add_to_crm_field_mappings(field_mappings)
+    config = column.get("config") if isinstance(column.get("config"), dict) else {}
+    require_company_domain = config.get("requireCompanyDomain", True)
+    issues = inspect_add_to_crm_field_mappings(
+        field_mappings,
+        require_company_domain=bool(require_company_domain) if isinstance(require_company_domain, bool) else True,
+    )
     required_missing = issues.get("required_missing") or []
     optional_missing = issues.get("optional_missing") or []
 
     if required_missing:
+        if "singleModeOnlyWhenCompanyDomainOptional" in required_missing:
+            raise AutotouchInputError(
+                "add_to_crm column is misconfigured: config.requireCompanyDomain=false only supports single-mode fieldMappings for LinkedIn-First Sync to Leads."
+            )
         missing = ", ".join(str(v) for v in required_missing)
         raise AutotouchInputError(
             f"add_to_crm column is misconfigured (missing required mappings: {missing}). "