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

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

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

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

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

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

@@ -137,6 +137,7 @@ sdk/ui/static/schedules.html
 sdk/ui/static/setup.html
 sdk/ui/static/styles.css
 sdk/ui/static/tickets.html
+sdk/vendor/aidraftsman-cli-0.1.0.tgz
 tests/test_activity_collectors.py
 tests/test_activity_core.py
 tests/test_activity_macos.py
@@ -167,6 +168,7 @@ tests/test_epic_decompose_run.py
 tests/test_epic_inherited_agent_id.py
 tests/test_epic_session_isolation.py
 tests/test_estimator.py
+tests/test_fallback_cli.py
 tests/test_firewall_open_on_update.py
 tests/test_formats.py
 tests/test_git_action.py

{devops_bot_sdk-1.6.54 → devops_bot_sdk-1.6.56}/pyproject.toml

@@ -68,7 +68,7 @@ where = ["."]
 include = ["sdk*"]
 
 [tool.setuptools.package-data]
-sdk = ["py.typed", "ui/static/*"]
+sdk = ["py.typed", "ui/static/*", "vendor/*.tgz"]
 
 [tool.ruff]
 line-length   = 100

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

@@ -34,7 +34,7 @@ Rules:
   - All data egress through submit_webhook only
 """
 
-__version__ = "1.6.54"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
+__version__ = "1.6.56"   # 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.54 → devops_bot_sdk-1.6.56}/sdk/ipc/handlers.py

@@ -3920,12 +3920,15 @@ _HOME_PATH_RE = re.compile(r"(?<![\w.])~(?:/[A-Za-z0-9._\- ]+)+")
 # `[\\/]+` in the separator position, not a single `\\`: a doubled separator is a
 # thing people write (`D://Nexus-AI` — the exact form in one bug report) and the
 # old pattern rejected it outright, sending the ticket to the ~/AgentOS fallback.
-_WIN_PATH_RE = re.compile(r"[A-Za-z]:[\\/]+(?:[^\\/:*?\"<>|\r\n]+[\\/]*)+")
+# The drive letter must not follow a word character: in `https://host/...` the
+# `s:` of the scheme otherwise reads as drive S:, so any ticket quoting a web link
+# "named" the folder `s://host/...` and was refused as unresolvable.
+_WIN_PATH_RE = re.compile(r"(?<![A-Za-z0-9_])[A-Za-z]:[\\/]+(?:[^\\/:*?\"<>|\r\n]+[\\/]*)+")
 # Windows path written with FORWARD slashes (e.g. C:/Users/me/new_tasks) — common on
 # Windows. Segments here also allow spaces, for the same reason the backslash form
 # does; over-capture is settled afterwards by `_trim_to_existing_dir`, not by trying
 # to tell a folder name from prose with a regex.
-_WIN_FS_PATH_RE = re.compile(r"[A-Za-z]:/+(?:[^\\/:*?\"<>|\r\n]+/*)+")
+_WIN_FS_PATH_RE = re.compile(r"(?<![A-Za-z0-9_])[A-Za-z]:/+(?:[^\\/:*?\"<>|\r\n]+/*)+")
 # A QUOTED path (single/double/back quotes) — the reliable way to give a path that
 # contains spaces, on any OS. Accepts a drive letter with EITHER separator (C:\ or C:/).
 _QUOTED_PATH_RE = re.compile(r"""["'`]\s*((?:[A-Za-z]:[\\/]|~/|/)[^"'`\r\n]+?)\s*["'`]""")

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

@@ -552,7 +552,7 @@ def _local_mcp_servers() -> dict[str, dict]:
     return servers
 
 
-async def run_claude_local(
+async def _run_claude_cli(
     prompt: str,
     project_path: str,
     *,
@@ -1042,3 +1042,305 @@ async def run_claude_local(
         provider=provider,
         model=cli_model["name"] or None,
     ))
+
+
+# ── Fallback: the AI Draftsman CLI ─────────────────────────────────────────
+# When the `claude` CLI is not working — not installed, logged out, out of
+# usage, or dying before it even starts a session — the ticket is re-run on
+# our own AI Draftsman CLI (`aidraftsman`, npm package @aidraftsman/cli) instead
+# of failing or parking. It is the same job against the same project dir: the
+# 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).
+#
+# 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
+# prompt would be "continue" with no context behind it), and the permission
+# mode defaults to acceptEdits — file edits apply, but a shell command that is
+# not read-only is denied rather than run unguarded. Set
+# AGENTOS_FALLBACK_PERMISSION_MODE=bypass to let it run every command.
+#
+# Settings (process env or ~/.agentos/.env):
+#   AGENTOS_FALLBACK_CLI              path to the CLI (default: PATH, then bundled), or "off"
+#   AGENTOS_FALLBACK_AGENT            agent id/name for `--agent` (default: gateway's choice)
+#   AGENTOS_FALLBACK_PERMISSION_MODE  default | acceptEdits | plan | bypass
+
+_FALLBACK_MODES = ("default", "acceptEdits", "plan", "bypass")
+
+
+def _setting(key: str) -> str:
+    value = os.environ.get(key, "").strip()
+    if value:
+        return value
+    try:
+        from sdk.config import _dotenv_value
+        return (_dotenv_value(key) or "").strip()
+    except Exception:  # noqa: BLE001 — a config hiccup must never break resolution
+        return ""
+
+
+#: The CLI ships inside the SDK (sdk/vendor/*.tgz) so every box has it without
+#: a separate install step; it is npm-installed from there on first use.
+_VENDOR_DIR = Path(__file__).parent / "vendor"
+
+
+def _fallback_disabled() -> bool:
+    return _setting("AGENTOS_FALLBACK_CLI").lower() in ("off", "0", "false", "no", "none")
+
+
+def _bundled_tarball() -> Path | None:
+    tarballs = sorted(_VENDOR_DIR.glob("aidraftsman-cli-*.tgz"))
+    return tarballs[-1] if tarballs else None
+
+
+def _bundled_bin(tarball: Path) -> Path:
+    """Where the bundled tarball's `aidraftsman` lands once installed.
+
+    One prefix per tarball name, so an SDK update that ships a new CLI version
+    installs it fresh rather than reusing the old one.
+    """
+    prefix = config._CONFIG_DIR / "aidraftsman" / tarball.name.removesuffix(".tgz")
+    name = "aidraftsman.cmd" if sys.platform == "win32" else "aidraftsman"
+    return prefix / "node_modules" / ".bin" / name
+
+
+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
+    :func:`ensure_fallback_cli` for that.
+    """
+    if _fallback_disabled():
+        return None
+    override = _setting("AGENTOS_FALLBACK_CLI")
+    if override and Path(override).exists():
+        return override
+    found = shutil.which("aidraftsman")
+    if found:
+        return found
+    tarball = _bundled_tarball()
+    if tarball and _bundled_bin(tarball).exists():
+        return str(_bundled_bin(tarball))
+    return None
+
+
+def _install_bundled(tarball: Path) -> str | None:
+    """``npm install`` the bundled tarball into a private prefix (no sudo, no -g)."""
+    npm = shutil.which("npm")
+    if not npm:
+        print("aidraftsman fallback unavailable: npm not found (Node.js 20+ required)", flush=True)
+        return None
+    bin_path = _bundled_bin(tarball)
+    prefix = bin_path.parents[2]
+    prefix.mkdir(parents=True, exist_ok=True)
+    cmd = [npm, "install", "--prefix", str(prefix), "--no-audit", "--no-fund",
+           "--omit=dev", str(tarball)]
+    if sys.platform == "win32" and npm.lower().endswith((".cmd", ".bat")):
+        cmd = [os.environ.get("COMSPEC", "cmd.exe"), "/c", *cmd]
+    print(f"installing bundled {tarball.name} into {prefix}", flush=True)
+    try:
+        proc = subprocess.run(cmd, capture_output=True, text=True, errors="replace",
+                              timeout=600)
+    except Exception as exc:  # noqa: BLE001 — never raise into a ticket run
+        print(f"aidraftsman install failed: {exc}", flush=True)
+        return None
+    if proc.returncode != 0 or not bin_path.exists():
+        print(f"aidraftsman install failed: {(proc.stderr or proc.stdout).strip()[-300:]}",
+              flush=True)
+        return None
+    return str(bin_path)
+
+
+async def ensure_fallback_cli() -> str | None:
+    """:func:`fallback_cli_path`, installing the bundled CLI first if needed."""
+    found = fallback_cli_path()
+    if found or _fallback_disabled():
+        return found
+    tarball = _bundled_tarball()
+    if not tarball:
+        return None
+    return await asyncio.to_thread(_install_bundled, tarball)
+
+
+def _claude_not_working(result: dict[str, Any]) -> bool:
+    """True when the run failed because of the `claude` CLI, not the task.
+
+    A task that ran and failed on its own merits (an error result, a full
+    context window, a capped response) would fail the same way elsewhere, so
+    those stay with the caller's existing recovery.
+    """
+    if result.get("ok"):
+        return False
+    if result.get("auth_expired") or result.get("limit_exceeded"):
+        return True
+    if result.get("context_exceeded") or result.get("output_cap_exceeded"):
+        return False
+    # No session id means the CLI never got as far as its init event: missing,
+    # crashed on start-up, or hung before doing anything.
+    return not result.get("session_id")
+
+
+def _git_changed_files(path: Path) -> set[str] | None:
+    """Paths `git status` reports as changed/untracked, or None outside a repo."""
+    try:
+        proc = subprocess.run(["git", "status", "--porcelain", "-uall"], cwd=str(path),
+                              capture_output=True, text=True, timeout=30)
+    except Exception:  # noqa: BLE001 — no git, or a slow repo: just skip the list
+        return None
+    if proc.returncode != 0:
+        return None
+    out = set()
+    for line in proc.stdout.splitlines():
+        name = line[3:].split(" -> ")[-1].strip().strip('"')
+        if name:
+            out.add(str(path / name))
+    return out
+
+
+async def run_fallback_cli(
+    prompt: str,
+    project_path: str,
+    *,
+    timeout: float = _DEFAULT_TIMEOUT_S,
+    github_token: str | None = None,
+    extra_env: dict[str, str] | None = None,
+    tier: str | None = None,
+    provider: str | None = None,
+) -> dict[str, Any]:
+    """Run ``prompt`` on the AI Draftsman CLI. Same result shape as the claude run."""
+    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).",
+                       tier=tier, provider=provider)
+
+    path = Path(project_path).expanduser()
+    path.mkdir(parents=True, exist_ok=True)
+
+    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]
+    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]
+
+    env = dict(os.environ)
+    if extra_env:
+        env.update({k: str(v) for k, v in extra_env.items() if v is not None})
+    if github_token:
+        env["GH_TOKEN"] = github_token
+        env["GITHUB_TOKEN"] = github_token
+        env["GIT_CONFIG_COUNT"] = "1"
+        env["GIT_CONFIG_KEY_0"] = (
+            f"url.https://x-access-token:{github_token}@github.com/.insteadOf"
+        )
+        env["GIT_CONFIG_VALUE_0"] = "https://github.com/"
+
+    before = _git_changed_files(path)
+    print(f"aidraftsman fallback spawn | mode={mode} | {path}", flush=True)
+    proc = await asyncio.create_subprocess_exec(
+        *cmd, cwd=str(path), env=env,
+        stdin=asyncio.subprocess.PIPE,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    try:
+        stdout, stderr = await asyncio.wait_for(
+            proc.communicate((prompt or "").encode("utf-8")), timeout=timeout)
+    except asyncio.TimeoutError:
+        proc.kill()
+        return _result(ok=False, error=f"aidraftsman CLI timed out after {timeout:.0f}s",
+                       tier=tier, provider=provider, model="aidraftsman")
+    except asyncio.CancelledError:
+        try:
+            proc.kill()
+        except ProcessLookupError:
+            pass
+        raise
+
+    after = _git_changed_files(path)
+    files_changed = sorted(after - before) if before is not None and after is not None else []
+    err_text = stderr.decode("utf-8", errors="replace").strip()
+
+    data: dict[str, Any] = {}
+    for line in reversed(stdout.decode("utf-8", errors="replace").splitlines()):
+        try:
+            data = json.loads(line)
+            break
+        except json.JSONDecodeError:
+            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}"
+        return _result(ok=False, error=err, files_changed=files_changed,
+                       auth_expired=proc.returncode == 2 or _is_auth_error(err),
+                       tier=tier, provider=provider, model="aidraftsman")
+
+    usage = data.get("usage") or {}
+    in_tok = int(usage.get("prompt_tokens", 0) or 0)
+    out_tok = int(usage.get("completion_tokens", 0) or 0)
+    text = str(data.get("result") or "")
+    return _result(
+        ok=True,
+        result=text,
+        longest_text=text,
+        input_tokens=in_tok,
+        output_tokens=out_tok,
+        total_tokens=int(usage.get("total_tokens", 0) or 0) or in_tok + out_tok,
+        files_changed=files_changed,
+        tier=tier,
+        provider=provider,
+        model=f"aidraftsman:{data.get('agent') or 'auto'}",
+    )
+
+
+async def run_claude_local(
+    prompt: str,
+    project_path: str,
+    *,
+    allowed_tools: list[str] | None = None,
+    on_event: EventHandler | None = None,
+    timeout: float = _DEFAULT_TIMEOUT_S,
+    github_token: str | None = None,
+    resume_session_id: str | None = None,
+    approval_dir: str | None = None,
+    idle_timeout: float = _IDLE_TIMEOUT_S,
+    max_output_tokens: int | None = None,
+    extra_env: dict[str, str] | None = None,
+    unset_env: list[str] | None = None,
+    settings_env: dict[str, str] | None = None,
+    tier: str | None = None,
+    provider: str | None = None,
+) -> dict[str, Any]:
+    """Run the local `claude` CLI; if the CLI itself is not working, re-run on
+    the AI Draftsman CLI. See ``_run_claude_cli`` for the arguments and the
+    result shape, and the fallback notes above ``run_fallback_cli``.
+    """
+    result = await _run_claude_cli(
+        prompt, project_path,
+        allowed_tools=allowed_tools, on_event=on_event, timeout=timeout,
+        github_token=github_token, resume_session_id=resume_session_id,
+        approval_dir=approval_dir, idle_timeout=idle_timeout,
+        max_output_tokens=max_output_tokens, extra_env=extra_env,
+        unset_env=unset_env, settings_env=settings_env, tier=tier, provider=provider,
+    )
+    if resume_session_id or not _claude_not_working(result) or _fallback_disabled():
+        return result
+
+    print(f"claude CLI not working ({(result.get('error') or '')[:200]}) — "
+          f"falling back to aidraftsman", flush=True)
+    fallback = await run_fallback_cli(
+        prompt, project_path, timeout=timeout, github_token=github_token,
+        extra_env=extra_env, tier=tier, provider=provider,
+    )
+    if fallback["ok"]:
+        return fallback
+    # Both failed: keep the claude result (its limit/auth flags drive the
+    # caller's parking and alerts) and say what the fallback hit too.
+    result["error"] = f"{result.get('error')} | aidraftsman fallback: {fallback.get('error')}"
+    return result

devops_bot_sdk-1.6.56/tests/test_fallback_cli.py

@@ -0,0 +1,175 @@
+"""`run_claude_local` falls back to the AI Draftsman CLI when claude is not working."""
+from __future__ import annotations
+
+import asyncio
+import json
+import sys
+
+import pytest
+
+from sdk import local_exec
+
+pytestmark = pytest.mark.skipif(sys.platform == "win32", reason="POSIX script stand-in")
+
+
+def _fake_cli(tmp_path, *, exit_code=0, payload=None, stderr=""):
+    """An `aidraftsman` stand-in: records argv/stdin/cwd, writes a file, prints JSON."""
+    record = tmp_path / "record.json"
+    script = tmp_path / "aidraftsman"
+    script.write_text(f"""#!{sys.executable}
+import json, os, sys
+prompt = sys.stdin.read()
+json.dump({{"argv": sys.argv[1:], "prompt": prompt, "cwd": os.getcwd()}}, open({str(record)!r}, "w"))
+open("made_by_fallback.txt", "w").write("x")
+sys.stderr.write({stderr!r})
+if {payload!r} is not None:
+    print(json.dumps({payload!r}))
+sys.exit({exit_code})
+""")
+    script.chmod(0o755)
+    return script, record
+
+
+@pytest.fixture()
+def no_claude(monkeypatch):
+    monkeypatch.setattr(local_exec, "claude_cli_path", lambda: None)
+
+
+def test_falls_back_when_claude_is_missing(tmp_path, monkeypatch, no_claude):
+    project = tmp_path / "proj"
+    cli, record = _fake_cli(tmp_path, payload={
+        "result": "fixed it", "session_id": "ad-1", "agent": "dev",
+        "usage": {"prompt_tokens": 7, "completion_tokens": 3, "total_tokens": 10},
+        "permission_denials": []})
+    monkeypatch.setenv("AGENTOS_FALLBACK_CLI", str(cli))
+    monkeypatch.setenv("AGENTOS_FALLBACK_AGENT", "dev")
+
+    result = asyncio.run(local_exec.run_claude_local("do the ticket", str(project), tier="t2"))
+
+    assert result["ok"] is True
+    assert result["result"] == "fixed it"
+    assert result["total_tokens"] == 10
+    assert result["model"] == "aidraftsman:dev"
+    assert result["tier"] == "t2"
+    seen = json.loads(record.read_text())
+    assert seen["prompt"] == "do the ticket"
+    assert seen["cwd"] == str(project)
+    assert seen["argv"] == ["-p", "--output-format", "json",
+                            "--permission-mode", "acceptEdits", "--agent", "dev"]
+
+
+def test_falls_back_on_usage_limit(tmp_path, monkeypatch):
+    cli, _ = _fake_cli(tmp_path, payload={"result": "ok", "usage": {}})
+    monkeypatch.setenv("AGENTOS_FALLBACK_CLI", str(cli))
+
+    async def _limited(*a, **k):
+        return local_exec._result(ok=False, error="usage limit reached",
+                                  limit_exceeded=True, session_id="s-1")
+    monkeypatch.setattr(local_exec, "_run_claude_cli", _limited)
+
+    result = asyncio.run(local_exec.run_claude_local("x", str(tmp_path / "p")))
+    assert result["ok"] is True and result["model"] == "aidraftsman:auto"
+
+
+@pytest.mark.parametrize("claude_result", [
+    # The task itself failed after claude started — would fail elsewhere too.
+    {"ok": False, "error": "tests failed", "session_id": "s-1"},
+    {"ok": False, "error": "prompt too long", "context_exceeded": True},
+    {"ok": True, "result": "done", "session_id": "s-1"},
+])
+def test_no_fallback_when_claude_itself_worked(tmp_path, monkeypatch, claude_result):
+    cli, record = _fake_cli(tmp_path, payload={"result": "ok"})
+    monkeypatch.setenv("AGENTOS_FALLBACK_CLI", str(cli))
+
+    async def _run(*a, **k):
+        return local_exec._result(**claude_result)
+    monkeypatch.setattr(local_exec, "_run_claude_cli", _run)
+
+    result = asyncio.run(local_exec.run_claude_local("x", str(tmp_path / "p")))
+    assert result["ok"] is claude_result["ok"]
+    assert not record.exists()
+
+
+def test_no_fallback_when_resuming_a_claude_session(tmp_path, monkeypatch, no_claude):
+    cli, record = _fake_cli(tmp_path, payload={"result": "ok"})
+    monkeypatch.setenv("AGENTOS_FALLBACK_CLI", str(cli))
+
+    result = asyncio.run(local_exec.run_claude_local(
+        "continue", str(tmp_path / "p"), resume_session_id="s-9"))
+    assert result["ok"] is False
+    assert not record.exists()
+
+
+def test_both_failing_keeps_claude_result_and_names_both(tmp_path, monkeypatch, no_claude):
+    cli, _ = _fake_cli(tmp_path, exit_code=2, stderr="You are not logged in.")
+    monkeypatch.setenv("AGENTOS_FALLBACK_CLI", str(cli))
+
+    result = asyncio.run(local_exec.run_claude_local("x", str(tmp_path / "p")))
+    assert result["ok"] is False
+    assert "Claude Code CLI not found" in result["error"]
+    assert "aidraftsman fallback: You are not logged in." in result["error"]
+
+
+def test_off_disables_the_fallback(monkeypatch):
+    monkeypatch.setenv("AGENTOS_FALLBACK_CLI", "off")
+    assert local_exec.fallback_cli_path() is None
+
+
+def test_files_changed_from_git(tmp_path, monkeypatch, no_claude):
+    import subprocess
+    project = tmp_path / "proj"
+    project.mkdir()
+    subprocess.run(["git", "init", "-q"], cwd=project, check=True)
+    cli, _ = _fake_cli(tmp_path, payload={"result": "ok"})
+    monkeypatch.setenv("AGENTOS_FALLBACK_CLI", str(cli))
+
+    result = asyncio.run(local_exec.run_claude_local("x", str(project)))
+    assert result["files_changed"] == [str(project / "made_by_fallback.txt")]
+
+
+def test_tarball_is_bundled():
+    assert local_exec._bundled_tarball() is not None
+
+
+def test_installs_bundled_cli_when_none_on_path(tmp_path, monkeypatch, no_claude):
+    """No CLI on PATH → npm-install the bundled tarball into ~/.agentos, then run it."""
+    cli, record = _fake_cli(tmp_path, payload={"result": "from bundle"})
+    npm_log = tmp_path / "npm.json"
+    npm = tmp_path / "npm"
+    npm.write_text(f"""#!{sys.executable}
+import json, os, sys
+args = sys.argv[1:]
+json.dump(args, open({str(npm_log)!r}, "w"))
+bin_dir = os.path.join(args[args.index("--prefix") + 1], "node_modules", ".bin")
+os.makedirs(bin_dir)
+os.symlink({str(cli)!r}, os.path.join(bin_dir, "aidraftsman"))
+""")
+    npm.chmod(0o755)
+    monkeypatch.delenv("AGENTOS_FALLBACK_CLI")
+    monkeypatch.setattr(local_exec, "_setting", lambda key: "")
+    monkeypatch.setattr(local_exec.config, "_CONFIG_DIR", tmp_path / ".agentos")
+    monkeypatch.setattr(local_exec.shutil, "which",
+                        lambda name: str(npm) if name == "npm" else None)
+
+    result = asyncio.run(local_exec.run_claude_local("x", str(tmp_path / "p")))
+
+    assert result["ok"] is True and result["result"] == "from bundle"
+    args = json.loads(npm_log.read_text())
+    assert args[-1] == str(local_exec._bundled_tarball())
+    assert str(tmp_path / ".agentos" / "aidraftsman") in args[args.index("--prefix") + 1]
+    # Second run finds the installed copy without calling npm again.
+    npm_log.unlink()
+    assert local_exec.fallback_cli_path().startswith(str(tmp_path / ".agentos"))
+    asyncio.run(local_exec.run_claude_local("x", str(tmp_path / "p")))
+    assert not npm_log.exists()
+
+
+def test_no_npm_reports_why(tmp_path, monkeypatch, no_claude):
+    monkeypatch.delenv("AGENTOS_FALLBACK_CLI")
+    monkeypatch.setattr(local_exec, "_setting", lambda key: "")
+    monkeypatch.setattr(local_exec.config, "_CONFIG_DIR", tmp_path / ".agentos")
+    monkeypatch.setattr(local_exec.shutil, "which", lambda name: None)
+
+    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"]

{devops_bot_sdk-1.6.54 → devops_bot_sdk-1.6.56}/tests/test_project_path_resolution.py

@@ -177,6 +177,18 @@ class TestResolveProjectPath:
         # the fact the person fixing the ticket needs.
         assert "/home/nobody/definitely-missing" in (got.unresolved or "")
 
+    def test_a_web_link_is_not_a_drive_path(self, tmp_path):
+        """`https://host/...` once read as drive S: and the ticket was refused."""
+        got = handlers.resolve_project_path(
+            _task(humanInstructions=(
+                "Extract all item statements verbatim from the standard at "
+                "https://skillsengland.education.gov.uk/apprenticeships/[ST0890]. "
+                "Map each item's recommended AI capabilities.")),
+            {"workspace_root": str(tmp_path)},
+        )
+        assert got.source == "workspace-root"
+        assert got.unresolved is None
+
     def test_an_explicit_override_wins(self, tmp_path):
         got = handlers.resolve_project_path(
             _task(humanInstructions="Work in /somewhere/else"),