devops-bot-sdk 1.6.56__tar.gz → 1.6.60__tar.gz

{devops_bot_sdk-1.6.56 → devops_bot_sdk-1.6.60}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.6.56
+Version: 1.6.60
 Summary: DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app
 Author: noumanaziz2128
 License-Expression: LicenseRef-Proprietary

{devops_bot_sdk-1.6.56 → devops_bot_sdk-1.6.60}/devops_bot_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.6.56
+Version: 1.6.60
 Summary: DevOps Bot Desktop SDK — thin client for the AgentOS Electron desktop app
 Author: noumanaziz2128
 License-Expression: LicenseRef-Proprietary

{devops_bot_sdk-1.6.56 → devops_bot_sdk-1.6.60}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -47,6 +47,7 @@ sdk/task_types.py
 sdk/test.py
 sdk/test_pipeline.py
 sdk/ticket_fields.py
+sdk/tickets.py
 sdk/updater.py
 sdk/url_access.py
 sdk/vps_health.py
@@ -207,6 +208,7 @@ tests/test_stale_panel_restart.py
 tests/test_swagger_command.py
 tests/test_task_file_and_plan_run.py
 tests/test_task_file_format_doc.py
+tests/test_ticket_cli.py
 tests/test_ticket_fields.py
 tests/test_ticket_run_resolve_by_id.py
 tests/test_ticket_speed_fixes.py

{devops_bot_sdk-1.6.56 → devops_bot_sdk-1.6.60}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.6.52
+Version: 1.6.60
 
 Public surface:
   BackendClient.from_config()        — create client from ~/.agentos/config.toml
@@ -34,7 +34,7 @@ Rules:
   - All data egress through submit_webhook only
 """
 
-__version__ = "1.6.56"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
+__version__ = "1.6.60"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
 __author__  = "AgentOS"   # sdk.client.SDK_VERSION and the UI server version all read this.
 
 from sdk.client import BackendClient

{devops_bot_sdk-1.6.56 → devops_bot_sdk-1.6.60}/sdk/cli.py

@@ -49,6 +49,21 @@ Command surface:
     agentos agent rm <name>
         De-register the agent from the backend and delete its local manifest.
 
+    agentos ticket create --project KEY --summary TEXT [--type T] [--priority P]
+            [--assignee EMAIL] [--description[-file] …] [--instructions[-file] …]
+            [--parent ID] [--status S] [--points N]
+        File one ticket (POST /tasks-ml) and print its Jira key. Type defaults to
+        Task, priority to Medium, assignee to the token owner. Validated locally
+        first; a gateway rejection prints the gateway's own messages.
+    agentos ticket update KEY_OR_ID [--summary …] [--description[-file] …]
+            [--instructions[-file] …] [--priority P] [--status S] [--points N]
+            [--assignee EMAIL] [--type T]
+        Change only the given fields (PUT /tasks-ml/{id}). Takes a Jira key or
+        the platform id. See sdk.tickets — the Tickets page uses the same code.
+    agentos ticket delete KEY_OR_ID [--yes]
+        Show the ticket and, after a y/N confirmation (skipped by --yes), delete it
+        (DELETE /tasks-ml/{id}). Cannot be undone.
+
     agentos integration add <path>
         Register an integration (MCP server, etc.) from a JSON file.
     agentos integration test <name>
@@ -104,6 +119,11 @@ Command surface:
         One submission in full — its text, its proofs and the evaluator's
         per-criterion reasoning.
 
+    agentos fallback install | login [--browser | --api-key [KEY]] | status [--verify] | logout
+        The AI Draftsman CLI a ticket re-runs on when `claude` is not working:
+        install the bundled copy, log it in (a sign-in code approved on the
+        frontend, or an API key), and check it. See sdk.local_exec.fallback_status.
+
     agentos agentd start [--foreground]
         Start the local agent daemon (background by default).
     agentos agentd status
@@ -157,6 +177,10 @@ def main() -> None:
         _integration_command(rest)
         return
 
+    if noun == "ticket":
+        _ticket_command(rest)
+        return
+
     if noun == "agentd":
         _agentd_command(rest)
         return
@@ -188,23 +212,29 @@ def main() -> None:
         _browser_command(rest)
         return
 
+    if noun == "fallback":
+        _fallback_command(rest)
+        return
+
     _print_usage()
     sys.exit(1)
 
 
 def _print_usage() -> None:
-    print("usage: agentos <configure|chat|agent|integration|default-agents|agentd|github|report|browser|firewall|activity-setup|swagger> ...")
+    print("usage: agentos <configure|chat|agent|ticket|integration|default-agents|agentd|github|report|browser|fallback|firewall|activity-setup|swagger> ...")
     print()
     print("  agentos configure [--rotate]")
     print("  agentos chat [--product-id ID] [--pv-id ID] [--no-autorun]   # requirements → ticket")
     print("  agentos agent <list|run NAME|chat NAME MSG|logs NAME|enable NAME|disable NAME|rm NAME>")
     print("  agentos agent <set-key NAME KEY[=VALUE]…|keys NAME|rm-key NAME KEY…>   # persistent API keys (custom agents)")
+    print("  agentos ticket <create|update KEY_OR_ID|delete KEY_OR_ID|help>")
     print("  agentos integration <add PATH|test NAME|list|rm NAME>")
     print("  agentos default-agents list [--department-id UUID]   # read-only; agents are created in the web app")
     print("  agentos agentd <start [--foreground]|status>")
     print("  agentos github <ingest [--days N]|status>            # PR ingestion; --days N backfills N days")
     print("  agentos report <submit|list|show ID>                 # report work Jira/GitHub never saw")
     print("  agentos browser <login URL|status|logout>            # sign in once; private links become readable")
+    print("  agentos fallback <install|login|status|logout>       # the AI Draftsman CLI used when claude is not working")
     print("  agentos firewall [--apply] [--revoke IP] [--port N]  # open the UI port to the allowlisted IPs")
     print("  agentos firewall --any [--apply]                     # open the UI port to any source (allowlist is the gate)")
     print("  agentos swagger [--open] [--json [PATH]]             # where /docs is, and can you reach it")
@@ -615,6 +645,153 @@ def _pop_department_id(args: list[str]) -> tuple[str | None, list[str]]:
     return dept_id, out
 
 
+# `agentos ticket` flag → POST/PUT /tasks-ml wire name. Text flags have a
+# `-file` twin that reads the value from a file instead.
+_TICKET_FLAGS = {
+    "--project": "projectKey", "--type": "type", "--summary": "summary",
+    "--priority": "priority", "--assignee": "assigneeEmail", "--status": "status",
+    "--points": "points", "--parent": "parentTaskId",
+    "--description": "description", "--instructions": "humanInstructions",
+}
+_TICKET_FILE_FLAGS = {"--description-file": "--description",
+                      "--instructions-file": "--instructions"}
+# Create-only: neither is editable through PUT /tasks-ml/{id}.
+_TICKET_CREATE_ONLY = {"--project", "--parent"}
+
+
+def _ticket_usage() -> None:
+    print("usage: agentos ticket <create|update KEY_OR_ID|delete KEY_OR_ID|help>")
+    print()
+    print("  agentos ticket create --project KEY --summary TEXT [--type TYPE] [--priority P]")
+    print("      [--assignee EMAIL] [--description TEXT | --description-file PATH]")
+    print("      [--instructions TEXT | --instructions-file PATH] [--parent ID] [--status S] [--points N]")
+    print("  agentos ticket update KEY_OR_ID [--summary TEXT] [--description TEXT | --description-file PATH]")
+    print("      [--instructions TEXT | --instructions-file PATH] [--priority P] [--status S]")
+    print("      [--points N] [--assignee EMAIL] [--type TYPE]")
+    print("  agentos ticket delete KEY_OR_ID [--yes]   # asks to confirm unless --yes")
+    print()
+    print("  TYPE: Epic|Story|Task|Bug|Sub-task (default Task)   P: Lowest|Low|Medium|High|Highest (default Medium)")
+    print("  --assignee defaults to the configured token's owner.")
+
+
+def _parse_ticket_flags(args: list[str], *, creating: bool) -> dict[str, str]:
+    """Flags → wire fields. Exits 1 on an unknown flag, a missing value, both a
+    text flag and its -file twin, or an unreadable file."""
+    fields: dict[str, str] = {}
+    seen: set[str] = set()
+    i = 0
+    while i < len(args):
+        flag = args[i]
+        known = flag in _TICKET_FLAGS or flag in _TICKET_FILE_FLAGS
+        if not known or (not creating and flag in _TICKET_CREATE_ONLY):
+            print(f"error: unknown option for `agentos ticket {'create' if creating else 'update'}`: {flag}")
+            sys.exit(1)
+        if i + 1 >= len(args):
+            print(f"error: expected a value after {flag}")
+            sys.exit(1)
+        value = args[i + 1]
+        text_flag = _TICKET_FILE_FLAGS.get(flag, flag)
+        if text_flag in seen:
+            print(f"error: pass {text_flag} or {text_flag}-file once, not both")
+            sys.exit(1)
+        seen.add(text_flag)
+        if flag in _TICKET_FILE_FLAGS:
+            path = Path(value).expanduser()
+            try:
+                value = path.read_text(encoding="utf-8")
+            except OSError as exc:
+                print(f"error: {flag}: cannot read {path}: {exc.strerror or exc}")
+                sys.exit(1)
+        fields[_TICKET_FLAGS[text_flag]] = value
+        i += 2
+    return fields
+
+
+def _ticket_command(args: list[str]) -> None:
+    """`agentos ticket create|update` — see sdk.tickets for the rules."""
+    verb = args[0] if args else "help"
+    if verb in {"help", "-h", "--help"}:
+        _ticket_usage()
+        sys.exit(0 if args else 1)
+    if verb not in {"create", "update", "delete"}:
+        _ticket_usage()
+        sys.exit(1)
+    if verb in {"update", "delete"} and (len(args) < 2 or args[1].startswith("--")):
+        _ticket_usage()
+        sys.exit(1)
+
+    from sdk import tickets
+    from sdk.client import BackendClient
+
+    if verb == "delete":
+        _ticket_delete(args[1], args[2:])
+        return
+
+    if verb == "create":
+        fields = _parse_ticket_flags(args[1:], creating=True)
+        if not fields.get("projectKey") or not fields.get("summary"):
+            print("error: --project and --summary are required")
+            sys.exit(1)
+    else:
+        fields = _parse_ticket_flags(args[2:], creating=False)
+        if not fields:
+            print("error: nothing to update: pass at least one field")
+            _ticket_usage()
+            sys.exit(1)
+    # Validate before building a client, so a bad flag never needs a token.
+    err = tickets.validate_fields(fields)
+    if err:
+        print(f"error: {err}")
+        sys.exit(1)
+
+    client = BackendClient.from_config()
+    if verb == "create":
+        res = asyncio.run(tickets.create_ticket(client, fields))
+    else:
+        res = asyncio.run(tickets.update_ticket(client, args[1], fields))
+    if not res["ok"]:
+        print(f"error: {res['error']}")
+        sys.exit(1)
+    label = res["key"] or res["id"]
+    if verb == "create":
+        print(f"created {label}  (id {res['id']})")
+    else:
+        print(f"updated {label}: {', '.join(sorted(fields))}")
+    sys.exit(0)
+
+
+def _ticket_delete(target: str, flags: list[str]) -> None:
+    """`agentos ticket delete KEY_OR_ID [--yes]` — shows the ticket, then asks."""
+    from sdk import tickets
+    from sdk.client import BackendClient
+
+    unknown = [f for f in flags if f not in {"--yes", "-y"}]
+    if unknown:
+        print(f"error: unknown option for `agentos ticket delete`: {unknown[0]}")
+        sys.exit(1)
+    client = BackendClient.from_config()
+    rec = asyncio.run(tickets.get_ticket(client, target))
+    if rec is None:
+        print(f"error: ticket not found: {target}")
+        sys.exit(1)
+    label = rec.get("key") or rec.get("id")
+    if not flags:
+        print(f"{label}  [{rec.get('status') or '?'}]  {rec.get('summary') or ''}")
+        try:
+            answer = input(f"Delete {label}? This cannot be undone. [y/N] ")
+        except EOFError:
+            answer = ""
+        if answer.strip().lower() not in {"y", "yes"}:
+            print("not deleted")
+            sys.exit(1)
+    res = asyncio.run(tickets.delete_ticket(client, str(rec.get("id") or target)))
+    if not res["ok"]:
+        print(f"error: {res['error']}")
+        sys.exit(1)
+    print(f"deleted {label}")
+    sys.exit(0)
+
+
 def _resolve_department_id(explicit: str | None) -> str:
     """Use the explicit --department-id, else the caller's own from bootstrap()."""
     if explicit:
@@ -892,6 +1069,89 @@ def _browser_command(args: list[str]) -> None:
     sys.exit(1)
 
 
+# ── fallback ─────────────────────────────────────────────────────────────
+
+def _fallback_usage() -> None:
+    print("usage: agentos fallback install                 # npm-install the bundled CLI now")
+    print("       agentos fallback login [--browser | --api-key [KEY]] [--base-url URL] [--no-browser]")
+    print("       agentos fallback status [--verify]       # --verify asks the server too")
+    print("       agentos fallback logout")
+    print()
+    print("  When the `claude` CLI is not working, tickets re-run on the AI Draftsman CLI")
+    print("  bundled with the SDK. It needs its own login, made as the user the SDK runs as.")
+    print()
+    print("  --browser       prints a sign-in code and a link; approve it on the AI Draftsman")
+    print("                  frontend from any machine — works on a headless VPS")
+    print("  --api-key       paste a key from Settings → API keys (hidden prompt), or pass")
+    print("                  KEY after the flag")
+    print("  (neither)       the CLI's own menu")
+
+
+def _fallback_command(args: list[str]) -> None:
+    """``agentos fallback install|login|status|logout`` — the AI Draftsman fallback CLI."""
+    from sdk import local_exec as le
+
+    verb = args[0] if args else None
+    rest = args[1:]
+
+    if verb == "install":
+        if le._fallback_disabled():
+            print("error: the fallback is disabled (AGENTOS_FALLBACK_CLI=off)")
+            sys.exit(1)
+        cli = asyncio.run(le.ensure_fallback_cli())
+        if not cli:
+            print("error: could not install the AI Draftsman CLI (Node.js 20+ and npm are needed)")
+            sys.exit(1)
+        print(f"installed: {cli}")
+        ad = Path(cli).with_name("ad.cmd" if cli.lower().endswith(".cmd") else "ad")
+        if ad.exists():
+            print(f"also as  : {ad}   (the same CLI under its short name)")
+        print("next     : agentos fallback login")
+        return
+
+    if verb == "login":
+        method = api_key = base_url = None
+        no_browser = True if "--no-browser" in rest else None
+        if "--browser" in rest:
+            method = "browser"
+        if "--api-key" in rest:
+            method = "api-key"
+            i = rest.index("--api-key") + 1
+            if i < len(rest) and not rest[i].startswith("-"):
+                api_key = rest[i]
+        if "--base-url" in rest:
+            try:
+                base_url = rest[rest.index("--base-url") + 1]
+            except IndexError:
+                print("error: --base-url needs a URL")
+                sys.exit(1)
+        rc = le.fallback_login(method=method, api_key=api_key, base_url=base_url,
+                               no_browser=no_browser)
+        if rc == 0:
+            print("check it : agentos fallback status --verify")
+        sys.exit(rc)
+
+    if verb == "status":
+        st = le.fallback_status(verify="--verify" in rest)
+        print(f"installed : {'yes' if st['installed'] else 'no'}")
+        print(f"path      : {st['path'] or '-'}")
+        print(f"logged in : {'yes' if st['logged_in'] else 'no'}")
+        if st["verified"] is not None:
+            print(f"server    : {'key accepted' if st['verified'] else 'NOT accepted'}")
+        print(f"account   : {st['account'] or '-'}")
+        print(f"server url: {st['base_url'] or '-'}")
+        if st["error"]:
+            print(f"problem   : {st['error']}")
+        ready = st["logged_in"] and st["verified"] is not False
+        sys.exit(0 if ready else 1)
+
+    if verb == "logout":
+        sys.exit(le.fallback_logout())
+
+    _fallback_usage()
+    sys.exit(1)
+
+
 def _report_check(url: str) -> None:
     """``agentos report check <URL>`` — can this machine open that link?
 

{devops_bot_sdk-1.6.56 → devops_bot_sdk-1.6.60}/sdk/client.py

@@ -249,6 +249,7 @@ class BackendClient:
         # busy backend (retry in 30 min) from a rejected request (wait for the
         # next slot). Empty dict means "no failure recorded".
         self.last_ingest_error: dict = {}
+        self.last_task_ml_error: dict = {}
         self._headers  = {
             "Authorization": token,          # co_<uuid>_<hex> — no Bearer prefix
             "X-SDK-Version": SDK_VERSION,
@@ -1274,6 +1275,48 @@ class BackendClient:
             logger.warning("client.get_task_status list failed task=%s err=%s", task_id, exc)
         return None
 
+    async def get_task_ml(self, task_id: str) -> dict | None:
+        """GET {BE}/tasks-ml/{id} → the full RAW record (jiraIssueKey, summary, …), or None.
+
+        Same read as ``get_task_status`` — direct single-record read, then a scan
+        of the list endpoint for a backend that doesn't serve it — but returns the
+        whole record. Matches `id` or the Jira key. Best-effort: never raises.
+        """
+        from sdk.config import BE_DEFAULT_URL
+
+        if not task_id:
+            return None
+        base = BE_DEFAULT_URL.rstrip("/")
+        headers = {**self._headers, "accept": "*/*", "developer-name": "null", "product": ""}
+        try:
+            async with httpx.AsyncClient(timeout=20.0) as client:
+                resp = await client.get(f"{base}/tasks-ml/{task_id}", headers=headers)
+            if resp.status_code < 400:
+                data = (resp.json() or {}).get("data") or {}
+                if isinstance(data, dict):
+                    rec = data.get("record") if isinstance(data.get("record"), dict) else data
+                    if rec.get("id"):
+                        return rec
+        except Exception as exc:  # noqa: BLE001 — fall through to the list scan
+            logger.warning("client.get_task_ml direct failed task=%s err=%s", task_id, exc)
+        try:
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                resp = await client.get(f"{base}/tasks-ml", params={"limit": 10000},
+                                        headers=headers)
+            if resp.status_code >= 400:
+                return None
+            records = ((resp.json() or {}).get("data") or {}).get("records") or []
+            want = str(task_id).strip().upper()
+            for rec in records:
+                if isinstance(rec, dict) and want in {
+                    str(rec.get(k) or "").strip().upper()
+                    for k in ("id", "jiraIssueKey", "jiraKey")
+                }:
+                    return rec
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("client.get_task_ml list failed task=%s err=%s", task_id, exc)
+        return None
+
     async def set_task_status(self, task_id: str, status: str) -> bool:
         """PUT {BE}/tasks-ml/{id} status=<status> (best-effort, arbitrary target).
 
@@ -1435,11 +1478,17 @@ class BackendClient:
             async with httpx.AsyncClient(timeout=30.0) as client:
                 resp = await client.put(url, files=files, headers=headers)
             if resp.status_code >= 400:
+                try:
+                    self.last_task_ml_error = resp.json() or {}
+                except Exception:  # noqa: BLE001
+                    self.last_task_ml_error = {"error": resp.text or "request failed"}
                 logger.warning("client.update_task_ml failed task=%s status=%s body=%s",
                                task_id, resp.status_code, resp.text[:200])
                 return False
+            self.last_task_ml_error = {}
             return True
         except Exception as exc:  # noqa: BLE001
+            self.last_task_ml_error = {"error": str(exc)}
             logger.warning("client.update_task_ml error task=%s err=%s", task_id, exc)
             return False
 
@@ -1458,6 +1507,7 @@ class BackendClient:
         from sdk.config import BE_DEFAULT_URL
         from sdk.ticket_fields import to_multipart
 
+        self.last_task_ml_error = {}
         url = f"{BE_DEFAULT_URL.rstrip('/')}/tasks-ml"
         headers = {k: v for k, v in self._headers.items() if k.lower() != "content-type"}
         headers.update({"accept": "*/*", "developer-name": "null", "product": ""})
@@ -1468,9 +1518,14 @@ class BackendClient:
             async with httpx.AsyncClient(timeout=30.0) as client:
                 resp = await client.post(url, files=files, headers=headers)
             if resp.status_code >= 400:
+                try:
+                    self.last_task_ml_error = resp.json() or {}
+                except Exception:  # noqa: BLE001
+                    self.last_task_ml_error = {"error": resp.text or "request failed"}
                 logger.warning("client.create_task_ml failed status=%s body=%s",
                                resp.status_code, resp.text[:300])
                 return None
+            self.last_task_ml_error = {}
             body = resp.json() or {}
             rec = body.get("data") or body
             # The created record's id may sit at data.id or data.record.id.
@@ -1478,9 +1533,39 @@ class BackendClient:
                 return rec.get("id") or ((rec.get("record") or {}).get("id"))
             return None
         except Exception as exc:  # noqa: BLE001
+            self.last_task_ml_error = {"error": str(exc)}
             logger.warning("client.create_task_ml error err=%s", exc)
             return None
 
+    async def delete_task_ml(self, task_id: str) -> bool:
+        """DELETE {BE}/tasks-ml/{id} — remove a ticket. True on 2xx.
+
+        On failure the gateway's JSON body (e.g. ``{"message": "Task not found"}``)
+        is kept in ``last_task_ml_error``, as for create/update. Never raises.
+        """
+        from sdk.config import BE_DEFAULT_URL
+
+        url = f"{BE_DEFAULT_URL.rstrip('/')}/tasks-ml/{task_id}"
+        headers = {k: v for k, v in self._headers.items() if k.lower() != "content-type"}
+        headers.update({"accept": "*/*", "developer-name": "null", "product": ""})
+        try:
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                resp = await client.delete(url, headers=headers)
+            if resp.status_code >= 400:
+                try:
+                    self.last_task_ml_error = resp.json() or {}
+                except Exception:  # noqa: BLE001
+                    self.last_task_ml_error = {"error": resp.text or "request failed"}
+                logger.warning("client.delete_task_ml failed task=%s status=%s body=%s",
+                               task_id, resp.status_code, resp.text[:200])
+                return False
+            self.last_task_ml_error = {}
+            return True
+        except Exception as exc:  # noqa: BLE001
+            self.last_task_ml_error = {"error": str(exc)}
+            logger.warning("client.delete_task_ml error task=%s err=%s", task_id, exc)
+            return False
+
     # ── Jira projects ──────────────────────────────────────────────────
     # A Jira project is the container a ticket's `projectKey` points at, so these
     # sit next to create_task_ml: a flow that has no projectKey yet resolves one

{devops_bot_sdk-1.6.56 → devops_bot_sdk-1.6.60}/sdk/ipc/handlers.py

@@ -1973,12 +1973,11 @@ async def _run_local_pipeline(
     thread_id = str(payload.get("thread_id", "") or "")
     project_path = str(payload.get("project_path", "") or "").strip()
 
-    if not local_exec.is_available():
+    if not local_exec.can_run_locally():
         await send(Envelope(
             type=Envelope.TYPE_ERROR, thread_id=thread_id,
             data={"code": "CLAUDE_CLI_MISSING",
-                  "message": "The Claude Code CLI is not installed on this machine. "
-                             "Install it (and run `claude login`) to use the local claude_code engine."},
+                  "message": local_exec.NO_LOCAL_CLI_MESSAGE},
         ).model_dump())
         return
     if not project_path:
@@ -4954,12 +4953,11 @@ async def handle_orchestrate_auto_local_run(
     # guaranteed on every exit — including early returns — via the finally below.
     active_flusher: ActivityFlusher | None = None
     try:
-        if not local_exec.is_available():
+        if not local_exec.can_run_locally():
             await send(Envelope(
                 type=Envelope.TYPE_ERROR, thread_id=thread_id,
                 data={"code": "CLAUDE_CLI_MISSING",
-                      "message": "The Claude Code CLI is not installed on this machine. "
-                                 "Install it and run `claude setup-token` to use local execution."},
+                      "message": local_exec.NO_LOCAL_CLI_MESSAGE},
             ).model_dump())
             return