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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devops-bot-sdk
-Version: 1.6.56
+Version: 1.6.57
 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.57}/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.57
 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.57}/sdk/__init__.py

@@ -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.57"   # 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.57}/sdk/cli.py

@@ -104,6 +104,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
@@ -188,12 +193,16 @@ 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|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")
@@ -205,6 +214,7 @@ def _print_usage() -> None:
     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")
@@ -892,6 +902,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.57}/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
 

{devops_bot_sdk-1.6.56 → devops_bot_sdk-1.6.57}/sdk/local_exec.py

@@ -1052,7 +1052,9 @@ async def _run_claude_cli(
 # prompt goes in on stdin, `-p --output-format json` prints one JSON object.
 # The CLI is bundled in sdk/vendor/ and npm-installed into ~/.agentos/aidraftsman
 # the first time it is needed; one already on PATH is used instead. It needs
-# its own login on the box (`ad auth login`, or AD_API_KEY in the env).
+# its own login on the box, as the user the SDK runs as: `agentos fallback
+# login` (browser sign-in code or an API key), or AD_API_KEY in the env.
+# `agentos fallback status --verify` checks it against the server.
 #
 # What it does NOT do: honour the PreToolUse approval guard, resume a Claude
 # session, or stream progress events. So a resumed run never falls back (the
@@ -1108,8 +1110,8 @@ def _bundled_bin(tarball: Path) -> Path:
 def fallback_cli_path() -> str | None:
     """Absolute path to an installed `aidraftsman` CLI, or None if absent or disabled.
 
-    Resolution order: ``AGENTOS_FALLBACK_CLI``, then ``PATH``, then the copy
-    installed from the bundled tarball. Never installs anything — see
+    Resolution order: ``AGENTOS_FALLBACK_CLI``, then ``aidraftsman`` or ``ad``
+    on ``PATH``, then the copy installed from the bundled tarball. Never installs anything — see
     :func:`ensure_fallback_cli` for that.
     """
     if _fallback_disabled():
@@ -1117,9 +1119,12 @@ def fallback_cli_path() -> str | None:
     override = _setting("AGENTOS_FALLBACK_CLI")
     if override and Path(override).exists():
         return override
-    found = shutil.which("aidraftsman")
-    if found:
-        return found
+    # The package installs the same entry point under two names; a box may
+    # only have `ad` on PATH.
+    for name in ("aidraftsman", "ad"):
+        found = shutil.which(name)
+        if found:
+            return found
     tarball = _bundled_tarball()
     if tarball and _bundled_bin(tarball).exists():
         return str(_bundled_bin(tarball))
@@ -1164,6 +1169,145 @@ async def ensure_fallback_cli() -> str | None:
     return await asyncio.to_thread(_install_bundled, tarball)
 
 
+def _fallback_argv(cli: str, *args: str) -> list[str]:
+    # npm installs a .cmd shim on Windows — same reason as the claude spawn.
+    cmd = [cli, *args]
+    if sys.platform == "win32" and cli.lower().endswith((".cmd", ".bat")):
+        cmd = [os.environ.get("COMSPEC", "cmd.exe"), "/c", *cmd]
+    return cmd
+
+
+def fallback_status(*, verify: bool = False, timeout: float = 20.0) -> dict:
+    """Readiness of the AI Draftsman fallback CLI: installed AND logged in.
+
+    The fallback counterpart of :func:`claude_status`. ``aidraftsman auth status``
+    only says whether a key is STORED (in ~/.config/ai-draftsman/config.json for
+    the user running this); ``verify=True`` also asks the server, by listing
+    agents, so an expired or revoked key shows as not logged in. AD_API_KEY in
+    the env counts as a login, as it does for the CLI itself. Never raises.
+
+    Returns::
+
+        {"installed": bool, "logged_in": bool, "verified": bool|None,
+         "path": str|None, "account": str|None, "base_url": str|None,
+         "disabled": bool, "error": str|None}
+    """
+    out: dict[str, Any] = {"installed": False, "logged_in": False, "verified": None,
+                           "path": None, "account": None, "base_url": None,
+                           "disabled": _fallback_disabled(), "error": None}
+    if out["disabled"]:
+        out["error"] = "disabled (AGENTOS_FALLBACK_CLI=off)"
+        return out
+    cli = fallback_cli_path()
+    if not cli:
+        out["error"] = "not installed — run `agentos fallback install`"
+        return out
+    out.update(installed=True, path=cli)
+    try:
+        proc = subprocess.run(_fallback_argv(cli, "auth", "status", "--json"),
+                              capture_output=True, text=True, errors="replace",
+                              timeout=timeout, check=False)
+        data = json.loads(proc.stdout or "{}")
+    except Exception as exc:  # noqa: BLE001 — timeout / OSError / bad JSON
+        out["error"] = f"`aidraftsman auth status` failed: {exc}"
+        return out
+    out["account"] = data.get("account")
+    out["base_url"] = data.get("baseUrl")
+    out["logged_in"] = bool(data.get("authenticated") or os.environ.get("AD_API_KEY"))
+    if not out["logged_in"]:
+        out["error"] = "not logged in — run `agentos fallback login`"
+        return out
+    if verify:
+        try:
+            proc = subprocess.run(_fallback_argv(cli, "agents", "list", "--json"),
+                                  capture_output=True, text=True, errors="replace",
+                                  timeout=timeout, check=False)
+        except Exception as exc:  # noqa: BLE001
+            out["error"] = f"could not reach the AI Draftsman server: {exc}"
+            return out
+        out["verified"] = proc.returncode == 0
+        if proc.returncode != 0:
+            out["logged_in"] = proc.returncode != 2
+            out["error"] = ((proc.stderr or proc.stdout).strip()[-300:]
+                            or f"aidraftsman exited with code {proc.returncode}")
+            if proc.returncode == 2:
+                out["error"] += " — run `agentos fallback login`"
+    return out
+
+
+#: Shown when neither CLI can take a ticket; the entry points' "CLI missing" error.
+NO_LOCAL_CLI_MESSAGE = (
+    "Neither the Claude Code CLI nor the AI Draftsman fallback is ready on this "
+    "machine. Install claude and run `claude setup-token`, or run "
+    "`agentos fallback install` then `agentos fallback login`."
+)
+
+
+def can_run_locally() -> bool:
+    """True when a ticket can run here: claude is installed, or the fallback is
+    installed AND logged in.
+
+    The entry points (plan, the auto loop, local execution) gate on this rather
+    than :func:`is_available`, so a box with no claude at all still runs tickets
+    on the fallback. A missing claude fails on spawn with no session id, which
+    is exactly what ``run_claude_local`` falls back on.
+    """
+    if is_available():
+        return True
+    st = fallback_status()
+    return bool(st["installed"] and st["logged_in"])
+
+
+def _headless() -> bool:
+    """No browser can open here: an SSH session, or Linux with no display."""
+    if os.environ.get("SSH_CONNECTION") or os.environ.get("SSH_TTY"):
+        return True
+    return sys.platform.startswith("linux") and not (
+        os.environ.get("DISPLAY") or os.environ.get("WAYLAND_DISPLAY"))
+
+
+def fallback_login(*, method: str | None = None, api_key: str | None = None,
+                   base_url: str | None = None, no_browser: bool | None = None) -> int:
+    """Log the fallback CLI in, interactively, on this terminal. Returns its exit code.
+
+    Same two ways the CLI offers: ``method="browser"`` prints a sign-in code and
+    a link to approve on the AI Draftsman frontend (works on a headless VPS: open
+    the link on any machine), ``method="api-key"`` validates and stores a key
+    from Settings → API keys (prompted with hidden input when ``api_key`` is not
+    given). ``None`` shows the CLI's own menu. Installs the bundled CLI first.
+    """
+    cli = asyncio.run(ensure_fallback_cli())
+    if not cli:
+        print("error: the AI Draftsman CLI is not available "
+              "(Node.js 20+ and npm are needed to install the bundled copy, "
+              "or it is disabled with AGENTOS_FALLBACK_CLI=off)")
+        return 1
+    args = ["auth", "login"]
+    if api_key:
+        method = "api-key"
+        args += ["--api-key", api_key]
+    if method:
+        args += ["--method", method]
+    if base_url:
+        args += ["--base-url", base_url]
+    if no_browser is None:
+        no_browser = _headless()
+    if no_browser:
+        args.append("--no-browser")
+    try:
+        return subprocess.run(_fallback_argv(cli, *args), check=False).returncode
+    except KeyboardInterrupt:  # the CLI already printed "Sign-in cancelled."
+        return 130
+
+
+def fallback_logout() -> int:
+    cli = fallback_cli_path()
+    if not cli:
+        print("nothing to do: the AI Draftsman CLI is not installed")
+        return 0
+    return subprocess.run(_fallback_argv(cli, "auth", "logout"), check=False).returncode
+
+
 def _claude_not_working(result: dict[str, Any]) -> bool:
     """True when the run failed because of the `claude` CLI, not the task.
 
@@ -1213,7 +1357,8 @@ async def run_fallback_cli(
     cli = await ensure_fallback_cli()
     if not cli:
         return _result(ok=False, error="AI Draftsman CLI not available (needs Node.js 20+ "
-                                       "and npm to install the bundled copy).",
+                                       "and npm to install the bundled copy; "
+                                       "`agentos fallback install`).",
                        tier=tier, provider=provider)
 
     path = Path(project_path).expanduser()
@@ -1222,13 +1367,11 @@ async def run_fallback_cli(
     mode = _setting("AGENTOS_FALLBACK_PERMISSION_MODE") or "acceptEdits"
     if mode not in _FALLBACK_MODES:
         mode = "acceptEdits"
-    cmd = [cli, "-p", "--output-format", "json", "--permission-mode", mode]
+    args = ["-p", "--output-format", "json", "--permission-mode", mode]
     agent = _setting("AGENTOS_FALLBACK_AGENT")
     if agent:
-        cmd += ["--agent", agent]
-    # npm installs a .cmd shim on Windows — same reason as the claude spawn.
-    if sys.platform == "win32" and cli.lower().endswith((".cmd", ".bat")):
-        cmd = [os.environ.get("COMSPEC", "cmd.exe"), "/c", *cmd]
+        args += ["--agent", agent]
+    cmd = _fallback_argv(cli, *args)
 
     env = dict(os.environ)
     if extra_env:
@@ -1277,8 +1420,11 @@ async def run_fallback_cli(
             continue
     if proc.returncode != 0 or not isinstance(data, dict) or "result" not in data:
         err = err_text[-500:] or f"aidraftsman exited with code {proc.returncode}"
+        auth_expired = proc.returncode == 2 or _is_auth_error(err)
+        if auth_expired:
+            err += " — log the fallback in with `agentos fallback login`"
         return _result(ok=False, error=err, files_changed=files_changed,
-                       auth_expired=proc.returncode == 2 or _is_auth_error(err),
+                       auth_expired=auth_expired,
                        tier=tier, provider=provider, model="aidraftsman")
 
     usage = data.get("usage") or {}

{devops_bot_sdk-1.6.56 → devops_bot_sdk-1.6.57}/sdk/plan_run.py

@@ -224,12 +224,11 @@ async def run_task(task: dict[str, Any], *, send: Send, thread_id: str = "plan-l
     from sdk import local_exec
     from sdk.ipc.handlers import _code_one_repo
 
-    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`."},
+                  "message": local_exec.NO_LOCAL_CLI_MESSAGE},
         ).model_dump())
         return {"status": "failed", "reason": "claude_cli_missing", "repos": []}
 

{devops_bot_sdk-1.6.56 → devops_bot_sdk-1.6.57}/sdk/run_auto.py

@@ -1201,9 +1201,8 @@ def _run_loop(workspace_root: str | None, only_keys: list[str] | None = None,
     from sdk.client import BackendClient, register_status_observer
     from sdk.ipc import handlers
 
-    if not local_exec.is_available():
-        print("error: the `claude` CLI is not installed/authenticated on this machine.")
-        print("       install it and run `claude setup-token`, then retry.")
+    if not local_exec.can_run_locally():
+        print(f"error: {local_exec.NO_LOCAL_CLI_MESSAGE}")
         sys.exit(1)
 
     try:

{devops_bot_sdk-1.6.56 → devops_bot_sdk-1.6.57}/sdk/ui/setup_manager.py

@@ -77,6 +77,19 @@ def claude_readiness() -> dict:
                 "auth_method": None, "email": None, "org": None, "error": str(exc)}
 
 
+def fallback_readiness() -> dict:
+    """AI Draftsman fallback CLI readiness (installed + logged in) for /status.
+
+    Reads the stored login only — no server round trip on every /status.
+    """
+    try:
+        from sdk.local_exec import fallback_status
+        return fallback_status()
+    except Exception as exc:  # noqa: BLE001
+        return {"installed": False, "logged_in": False, "verified": None, "path": None,
+                "account": None, "base_url": None, "disabled": False, "error": str(exc)}
+
+
 def environment_info() -> dict:
     """Env snapshot for the /status endpoint and setup wizard."""
     vp = running_venv()
@@ -92,6 +105,7 @@ def environment_info() -> dict:
         "agentsystem_exists": root.exists(),
         "sdk_version": sdk_version(),
         "claude": claude_readiness(),
+        "fallback": fallback_readiness(),
     }
 
 

{devops_bot_sdk-1.6.56 → devops_bot_sdk-1.6.57}/tests/test_fallback_cli.py

@@ -173,3 +173,129 @@ def test_no_npm_reports_why(tmp_path, monkeypatch, no_claude):
     result = asyncio.run(local_exec.run_claude_local("x", str(tmp_path / "p")))
     assert result["ok"] is False
     assert "Node.js 20+" in result["error"]
+
+
+def _fake_auth_cli(tmp_path, *, status, agents_exit=0):
+    """An `aidraftsman` stand-in for the auth commands: records argv, prints `status`."""
+    record = tmp_path / "auth.json"
+    script = tmp_path / "aidraftsman"
+    script.write_text(f"""#!{sys.executable}
+import json, sys
+argv = sys.argv[1:]
+log = json.load(open({str(record)!r})) if __import__("os").path.exists({str(record)!r}) else []
+json.dump(log + [argv], open({str(record)!r}, "w"))
+if argv[:2] == ["auth", "status"]:
+    print(json.dumps({status!r}))
+elif argv[:2] == ["agents", "list"]:
+    if {agents_exit!r}:
+        sys.stderr.write("Request failed (401): Invalid API key")
+    sys.exit({agents_exit!r})
+""")
+    script.chmod(0o755)
+    return script, record
+
+
+def test_ad_on_path_is_found(tmp_path, monkeypatch):
+    monkeypatch.delenv("AGENTOS_FALLBACK_CLI")
+    monkeypatch.setattr(local_exec, "_setting", lambda key: "")
+    monkeypatch.setattr(local_exec.shutil, "which",
+                        lambda name: "/opt/bin/ad" if name == "ad" else None)
+    assert local_exec.fallback_cli_path() == "/opt/bin/ad"
+
+
+def test_status_reports_stored_login(tmp_path, monkeypatch):
+    cli, record = _fake_auth_cli(tmp_path, status={
+        "authenticated": True, "baseUrl": "https://dev-api.aidraftsman.ai/",
+        "account": "Consultancy Outfit"})
+    monkeypatch.setenv("AGENTOS_FALLBACK_CLI", str(cli))
+    monkeypatch.delenv("AD_API_KEY", raising=False)
+
+    st = local_exec.fallback_status()
+    assert st["installed"] and st["logged_in"] and st["error"] is None
+    assert st["account"] == "Consultancy Outfit"
+    assert st["verified"] is None
+    assert json.loads(record.read_text()) == [["auth", "status", "--json"]]
+
+
+def test_status_not_logged_in_says_how(tmp_path, monkeypatch):
+    cli, _ = _fake_auth_cli(tmp_path, status={"authenticated": False})
+    monkeypatch.setenv("AGENTOS_FALLBACK_CLI", str(cli))
+    monkeypatch.delenv("AD_API_KEY", raising=False)
+
+    st = local_exec.fallback_status(verify=True)
+    assert st["logged_in"] is False
+    assert "agentos fallback login" in st["error"]
+
+
+def test_status_verify_catches_a_rejected_key(tmp_path, monkeypatch):
+    cli, record = _fake_auth_cli(tmp_path, status={"authenticated": True}, agents_exit=2)
+    monkeypatch.setenv("AGENTOS_FALLBACK_CLI", str(cli))
+
+    st = local_exec.fallback_status(verify=True)
+    assert st["verified"] is False and st["logged_in"] is False
+    assert "401" in st["error"]
+    assert json.loads(record.read_text())[-1] == ["agents", "list", "--json"]
+
+
+def test_status_when_disabled(monkeypatch):
+    st = local_exec.fallback_status()
+    assert st["disabled"] and not st["installed"]
+
+
+@pytest.mark.parametrize("kwargs, expected", [
+    ({"method": "browser", "no_browser": True},
+     ["auth", "login", "--method", "browser", "--no-browser"]),
+    ({"api_key": "k" * 20, "no_browser": False},
+     ["auth", "login", "--api-key", "k" * 20, "--method", "api-key"]),
+    ({"method": "api-key", "base_url": "https://x.example/", "no_browser": False},
+     ["auth", "login", "--method", "api-key", "--base-url", "https://x.example/"]),
+])
+def test_login_passes_the_method_through(tmp_path, monkeypatch, kwargs, expected):
+    cli, record = _fake_auth_cli(tmp_path, status={})
+    monkeypatch.setenv("AGENTOS_FALLBACK_CLI", str(cli))
+
+    assert local_exec.fallback_login(**kwargs) == 0
+    assert json.loads(record.read_text()) == [expected]
+
+
+def test_login_on_a_headless_box_does_not_try_a_browser(tmp_path, monkeypatch):
+    cli, record = _fake_auth_cli(tmp_path, status={})
+    monkeypatch.setenv("AGENTOS_FALLBACK_CLI", str(cli))
+    monkeypatch.setenv("SSH_CONNECTION", "1.2.3.4 5 6.7.8.9 22")
+
+    local_exec.fallback_login(method="browser")
+    assert json.loads(record.read_text())[0][-1] == "--no-browser"
+
+
+def test_fallback_auth_failure_points_at_login(tmp_path, monkeypatch, no_claude):
+    cli, _ = _fake_cli(tmp_path, exit_code=2, stderr="Request failed (401)")
+    monkeypatch.setenv("AGENTOS_FALLBACK_CLI", str(cli))
+
+    result = asyncio.run(local_exec.run_fallback_cli("x", str(tmp_path / "p")))
+    assert result["auth_expired"] is True
+    assert "agentos fallback login" in result["error"]
+
+
+@pytest.mark.parametrize("claude, fallback, expected", [
+    (True, {"installed": False, "logged_in": False}, True),
+    (False, {"installed": True, "logged_in": True}, True),
+    (False, {"installed": True, "logged_in": False}, False),
+    (False, {"installed": False, "logged_in": False}, False),
+])
+def test_can_run_locally(monkeypatch, claude, fallback, expected):
+    monkeypatch.setattr(local_exec, "is_available", lambda: claude)
+    monkeypatch.setattr(local_exec, "fallback_status", lambda **k: fallback)
+    assert local_exec.can_run_locally() is expected
+
+
+def test_no_claude_at_all_runs_on_a_logged_in_fallback(tmp_path, monkeypatch, no_claude):
+    """The whole path with claude absent: the gate opens, the spawn falls back."""
+    cli, record = _fake_cli(tmp_path, payload={"result": "done", "usage": {}})
+    monkeypatch.setenv("AGENTOS_FALLBACK_CLI", str(cli))
+    monkeypatch.setattr(local_exec, "fallback_status",
+                        lambda **k: {"installed": True, "logged_in": True})
+
+    assert local_exec.can_run_locally() is True
+    result = asyncio.run(local_exec.run_claude_local("x", str(tmp_path / "p")))
+    assert result["ok"] is True and result["model"] == "aidraftsman:auto"
+    assert record.exists()

{devops_bot_sdk-1.6.56 → devops_bot_sdk-1.6.57}/tests/test_task_file_and_plan_run.py

@@ -292,6 +292,20 @@ class TestRunGuards:
             sent.append(e)
         out = _run(plan_run.run_task({"title": "x", "project_path": "/r"}, send=send))
         assert out["status"] == "failed" and out["reason"] == "claude_cli_missing"
+        assert "agentos fallback login" in sent[0]["data"]["message"]
+
+    def test_no_claude_but_a_logged_in_fallback_gets_past_the_gate(self, monkeypatch):
+        monkeypatch.setattr("sdk.local_exec.is_available", lambda: False)
+        monkeypatch.setattr("sdk.local_exec.fallback_status",
+                            lambda **k: {"installed": True, "logged_in": True})
+        sent: list[dict] = []
+
+        async def send(e):
+            sent.append(e)
+        out = _run(plan_run.run_task({"title": "x", "instructions": "no path here"},
+                                     send=send))
+        # Past the CLI gate, so it stops at the NEXT guard instead.
+        assert out["reason"] == "no_target"
 
 
 class TestCli: