devops-bot-sdk 1.7.45__tar.gz → 1.7.46__tar.gz

{devops_bot_sdk-1.7.45 → devops_bot_sdk-1.7.46}/PKG-INFO

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

{devops_bot_sdk-1.7.45 → devops_bot_sdk-1.7.46}/devops_bot_sdk.egg-info/PKG-INFO

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

{devops_bot_sdk-1.7.45 → devops_bot_sdk-1.7.46}/devops_bot_sdk.egg-info/SOURCES.txt

@@ -235,6 +235,7 @@ tests/test_log_colors_backlog.py
 tests/test_mcp_route_contract.py
 tests/test_memory_guard.py
 tests/test_model_policy.py
+tests/test_one_allowed_ip.py
 tests/test_panel_help.py
 tests/test_panel_ticket_schedules.py
 tests/test_parallel_tickets.py

{devops_bot_sdk-1.7.45 → devops_bot_sdk-1.7.46}/sdk/__init__.py

@@ -1,6 +1,6 @@
 """AgentOS Desktop SDK — thin HTTPS/SSE client for the Electron app.
 
-Version: 1.7.45
+Version: 1.7.46
 
 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.7.45"   # SINGLE SOURCE OF TRUTH — bump on every change; pyproject,
+__version__ = "1.7.46"   # 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.7.45 → devops_bot_sdk-1.7.46}/sdk/cli.py

@@ -104,11 +104,17 @@ Command surface:
         default; `--apply` executes them and needs root / Administrator. The host
         firewall is a separate layer the allowlist cannot reach, and the two drifting
         apart is what silently blinded every VPS when the backend's egress IP moved.
-        `--any` opens the port to every source instead, leaving
-        IPAllowlistMiddleware as the gate — the more robust choice when the
-        backend's egress IP can move, since a stale per-IP kernel rule drops the
-        SYN before the allowlist is ever consulted. This is what runs
-        automatically after a self-update. See sdk.firewall.
+        `--apply` also removes the open-to-any rule and any rule for an IP no
+        longer allowed; this is what runs automatically after a self-update.
+        `--any` opens the port to every source instead (not recommended: every
+        scanner then reaches the panel). See sdk.firewall.
+
+    agentos allow-ip [IP | --clear]
+        Show, set or clear THE one outside IP allowed to reach the panel (besides
+        this machine and the backend). Only one at a time: a new IP replaces the
+        old one in the allowlist and the host firewall. Same-machine only — this
+        command over SSH, or the panel opened at http://127.0.0.1:8765 on the box;
+        the remote API refuses. The firewall half needs root. See sdk.firewall.
 
     agentos swagger [--open] [--json [PATH]] [--port N]
         Where the panel's Swagger UI is and whether it can actually be reached:
@@ -223,6 +229,10 @@ def main() -> None:
         _github_command(rest)
         return
 
+    if noun == "allow-ip":
+        from sdk import firewall
+        sys.exit(firewall.allow_ip_cli(rest))
+
     if noun == "firewall":
         from sdk import firewall
         sys.exit(firewall.cli(rest))
@@ -264,7 +274,7 @@ def main() -> None:
 
 
 def _print_usage() -> None:
-    print("usage: agentos <configure|chat|agent|ticket|integration|default-agents|agentd|github|report|browser|fallback|help|doctor|firewall|activity-setup|swagger> ...")
+    print("usage: agentos <configure|chat|agent|ticket|integration|default-agents|agentd|github|report|browser|fallback|help|doctor|firewall|allow-ip|activity-setup|swagger> ...")
     print()
     print('  agentos version (or --version)     # installed SDK version, Python and install path')
     print('  agentos help "<your problem>" [--file PATH]…  # DevOps Bot Help: reads your logs + the SDK (+ screenshots/logs you attach)')
@@ -284,7 +294,8 @@ def _print_usage() -> None:
     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 allow-ip [IP | --clear]                     # the ONE outside IP allowed to reach the panel")
+    print("  agentos firewall [--apply] [--revoke IP] [--port N]  # limit 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")
 

{devops_bot_sdk-1.7.45 → devops_bot_sdk-1.7.46}/sdk/config.py

@@ -227,36 +227,64 @@ def _parse_ip_list(raw: str) -> list[str]:
 
 
 def get_allowed_ips() -> list[str]:
-    """Client IPs permitted to reach the ``agentos-ui`` API (``/api/ui/*``).
+    """Client IPs permitted to reach the ``agentos-ui`` server: the built-in backend
+    IP(s) plus AT MOST ONE user IP.
 
-    This is the allowlist for the *inbound* half of the two-way link: the AI
-    backend (and only it) may call back into the SDK server. Loopback is always
-    trusted separately — this list is for the AI-backend IP(s) you whitelist.
+    ONE user IP at a time is the rule — the panel is reachable from a single
+    outside address, so a leaked token is useless anywhere else and the host
+    firewall (`sdk.firewall.ensure_restricted`) admits exactly that address.
+    Loopback and this host's own IPs are always trusted separately.
 
-    Sources, merged (all optional), each accepting a comma/space-separated or
-    bracketed list of strings:
-      - ``.env`` key ``AGENTOS_UI_ALLOWED_IPS`` (``~/.agentos/.env`` or CWD ``.env``)
-      - process env ``AGENTOS_UI_ALLOWED_IPS``
-      - config.toml key ``allowed_ips``
-
-    Returns a de-duplicated list (empty means "loopback only"). Supplying the
-    AI-backend IP here later is all that's needed to open the link — no code
-    change. CIDR/prefix entries are supported by the middleware.
+    The user IP is chosen by :func:`user_allowed_ip`; anything else configured is
+    ignored and reported by :func:`ignored_allowed_ips`.
     """
-    sources = [
-        ",".join(_DEFAULT_ALLOWED_IPS),                 # built-in backend IP(s) — always allowed
-        _dotenv_value("AGENTOS_UI_ALLOWED_IPS"),
-        os.environ.get("AGENTOS_UI_ALLOWED_IPS", ""),
-        _load_raw().get("allowed_ips", ""),
-    ]
+    out = list(_DEFAULT_ALLOWED_IPS)
+    user = user_allowed_ip()
+    if user and user not in out:
+        out.append(user)
+    return out
+
+
+def _single_address(value: str) -> bool:
+    """True for one host address (a bare IP, or a /32 / /128) — not a range."""
+    import ipaddress
+    try:
+        return ipaddress.ip_network(value.strip(), strict=False).num_addresses == 1
+    except ValueError:
+        return False
+
+
+def _configured_user_ips() -> list[str]:
+    """Every non-backend entry configured anywhere, oldest source first:
+    ``.env``, process env, then config.toml (the runtime / API-added one)."""
     out: list[str] = []
-    for src in sources:
+    for src in (_dotenv_value("AGENTOS_UI_ALLOWED_IPS"),
+                os.environ.get("AGENTOS_UI_ALLOWED_IPS", ""),
+                _load_raw().get("allowed_ips", "")):
         for ip in _parse_ip_list(src):
-            if ip not in out:
+            if ip not in _DEFAULT_ALLOWED_IPS and ip not in out:
                 out.append(ip)
     return out
 
 
+def user_allowed_ip() -> str | None:
+    """The ONE user IP allowed to reach the panel, or None.
+
+    The most recent wins: the runtime entry (config.toml — set by
+    ``POST /api/ui/allowlist``) over ``.env``, and within a source the LAST entry,
+    since the documented way to add an IP is to append it. CIDR ranges are never
+    chosen — a range is many IPs.
+    """
+    candidates = [ip for ip in _configured_user_ips() if _single_address(ip)]
+    return candidates[-1] if candidates else None
+
+
+def ignored_allowed_ips() -> list[str]:
+    """Configured user IPs/ranges that are NOT allowed, because only one may be."""
+    keep = user_allowed_ip()
+    return [ip for ip in _configured_user_ips() if ip != keep]
+
+
 # Built-in baseline of tools a headless agent run may use. Kept here (not in
 # local_exec) so it is one configurable setting rather than a literal buried in the
 # spawn code: the set WILL grow, and a new tool must be addable without editing
@@ -434,23 +462,23 @@ def journal_enabled() -> bool:
 
 
 def add_allowed_ip(ip: str) -> list[str]:
-    """Whitelist an IP/CIDR at RUNTIME (persisted to config.toml ``allowed_ips``).
+    """Make ``ip`` THE user IP at runtime (persisted to config.toml ``allowed_ips``).
 
-    Idempotent. The middleware re-reads the allowlist per request, so the IP is
-    honoured immediately (no restart) and stays until disabled. An IP already
-    permanently whitelisted via ``.env`` is left as-is (no runtime duplicate).
-    Returns the merged allowlist.
+    Only one user IP may reach the panel at a time, so this REPLACES whichever was
+    there before — including one from ``.env``, which it outranks while set.
+    Idempotent. The middleware sees it on the next request; the caller updates the
+    host firewall. A backend IP is already allowed and is left alone. Returns the
+    effective allowlist.
     """
     ip = (ip or "").strip()
     if not ip:
         raise ValueError("ip is required")
-    if ip in permanent_allowed_ips():                   # already permanent — nothing to add
+    if not _single_address(ip):
+        raise ValueError(f"{ip} is a range — only one IP may be allowed at a time")
+    if ip in _DEFAULT_ALLOWED_IPS:
         return get_allowed_ips()
     raw = _load_raw()                                   # preserves token_enc / base_url / etc.
-    entries = _parse_ip_list(raw.get("allowed_ips", ""))
-    if ip not in entries:
-        entries.append(ip)
-    raw["allowed_ips"] = ", ".join(entries)
+    raw["allowed_ips"] = ip
     _save_raw(raw)
     return get_allowed_ips()
 

{devops_bot_sdk-1.7.45 → devops_bot_sdk-1.7.46}/sdk/faqs.py

@@ -21,22 +21,17 @@ FAQS: list[tuple[str, str, str]] = [
     ("Basics", "How do I open the control panel from another machine?",
      "**Easiest — an SSH tunnel (nothing to open):** on your machine run "
      "`ssh -L 8765:127.0.0.1:8765 you@SERVER`, then browse `http://127.0.0.1:8765`.\n"
-     "**Directly by IP:**\n"
-     "1. On YOUR machine, find your public IP: `curl -s https://api.ipify.org; echo` → prints e.g. `203.0.113.7`\n"
-     "2. On the SERVER, allowlist it: `echo 'AGENTOS_UI_ALLOWED_IPS=203.0.113.7' >> ~/.agentos/.env` — if that "
-     "line is already there, add the IP to it instead (only the first line counts): "
-     "`sed -i 's/^AGENTOS_UI_ALLOWED_IPS=.*/&,203.0.113.7/' ~/.agentos/.env`\n"
-     "3. Check it: `grep AGENTOS_UI_ALLOWED_IPS ~/.agentos/.env` → `AGENTOS_UI_ALLOWED_IPS=203.0.113.7` "
-     "(or your earlier IPs, then `,203.0.113.7`)\n"
-     "4. Open the port: `agentos firewall --apply` (needs sudo rights; if it can't, it prints the `ufw` command to run)\n"
-     "**On a Windows server** (PowerShell): `(Invoke-RestMethod https://api.ipify.org)` for your IP; "
-     "`Add-Content \"$env:USERPROFILE\\.agentos\\.env\" \"AGENTOS_UI_ALLOWED_IPS=203.0.113.7\"` the first time, or "
-     "`(Get-Content $f) -replace '^(AGENTOS_UI_ALLOWED_IPS=.*)$','$1,203.0.113.7' | Set-Content $f` "
-     "(with `$f = \"$env:USERPROFILE\\.agentos\\.env\"`) to add to an existing line; "
-     "`agentos firewall --apply` in an Administrator PowerShell. In cmd: "
-     "`echo AGENTOS_UI_ALLOWED_IPS=203.0.113.7>> \"%USERPROFILE%\\.agentos\\.env\"` (no space before `>>`).\n"
-     "5. Browse `http://SERVER-IP:8765` and paste your co_ token. It works at once — no restart. "
-     "`agentos swagger` shows whether the port is reachable and which allowlisted IPs the firewall still blocks."),
+     "**Directly by IP** — only ONE outside IP can open the panel at a time, and only someone on the "
+     "server can set it:\n"
+     "1. On YOUR machine, find your public IP: `curl -s https://api.ipify.org; echo` → prints e.g. `203.0.113.7` "
+     "(Windows PowerShell: `Invoke-RestMethod https://api.ipify.org`)\n"
+     "2. On the SERVER (over SSH): `agentos allow-ip 203.0.113.7` — this REPLACES the previous IP, which loses access. "
+     "Or open the panel on the server itself (`http://127.0.0.1:8765`) → Dashboard → **Remote access**.\n"
+     "3. If it says the firewall needs root: `sudo agentos firewall --apply` (Windows: `agentos firewall --apply` "
+     "in an Administrator PowerShell).\n"
+     "4. Browse `http://SERVER-IP:8765` and paste your co_ token. `agentos allow-ip` shows the allowed IP; "
+     "`agentos allow-ip --clear` removes it. The remote API cannot change it, so a leaked token cannot "
+     "open the panel to another address."),
     ("Basics", "How do I use devops-bot-sdk on another machine?",
      "Install it there too — the same checklist (Python, git, SSH key, repo access, claude or ad), then "
      "`pip install \"git+ssh://git@github.com/consultancy-outfit/DevOpsBot-SDK.git\"` and `agentos configure` "

{devops_bot_sdk-1.7.45 → devops_bot_sdk-1.7.46}/sdk/firewall.py

@@ -24,8 +24,7 @@ it adds a per-IP rule for every allowlisted address and REMOVES the open-to-any
 rule. It used to run ``--any``, and that left every VPS with 8765 open to the
 internet: each brute-force/scanner request then reached Python before the
 allowlist refused it, and a flood pinned the panel at 100% CPU. Open-to-any is
-now only kept when the operator chose it — ``AGENTOS_UI_PUBLIC=1`` (public mode
-needs the port reachable) or ``AGENTOS_FIREWALL_OPEN_ANY=1``.
+now only kept when the operator chose it with ``AGENTOS_FIREWALL_OPEN_ANY=1``.
 
 Applying is deliberately opt-in: editing a live firewall is exactly the operation
 that can lock an operator out of their own box, so the default is to print and let
@@ -118,8 +117,8 @@ def allow_any_rules(port: int, system: str | None = None) -> list[str]:
     That reasoning held for *access* but not for *load*: every request from the
     internet still costs a Python round-trip before the allowlist refuses it, and
     a brute-force flood took panels to 100% CPU. So this is no longer the default
-    — :func:`ensure_restricted` is — and is kept for public mode and for an
-    operator who opts in with ``AGENTOS_FIREWALL_OPEN_ANY=1``. A backend IP move
+    — :func:`ensure_restricted` is — and is kept only for an operator who opts
+    in with ``AGENTOS_FIREWALL_OPEN_ANY=1``. A backend IP move
     is still self-healing: the new IP goes in ``_DEFAULT_ALLOWED_IPS`` and the
     next self-update adds its rule.
     """
@@ -246,24 +245,27 @@ def _net(value: str):
 def open_any_opted_in() -> bool:
     """Has the operator chosen to keep the port open to any source?
 
-    True for ``AGENTOS_UI_PUBLIC=1`` (public mode is unreachable otherwise) or an
-    explicit ``AGENTOS_FIREWALL_OPEN_ANY=1``. Read from the process env or
-    ``~/.agentos/.env``, like every other ``AGENTOS_UI_*`` toggle.
+    Only an explicit ``AGENTOS_FIREWALL_OPEN_ANY=1`` — read from the process env
+    or ``~/.agentos/.env``, like every other ``AGENTOS_UI_*`` toggle. (The removed
+    ``AGENTOS_UI_PUBLIC=1`` used to imply it.)
     """
     try:
-        from sdk.ui.ip_allowlist import _TRUE, _setting, public_mode
+        from sdk.ui.ip_allowlist import _TRUE, _setting
     except Exception:  # noqa: BLE001 — never fail open on an import hiccup
         return False
-    return public_mode() or _setting("AGENTOS_FIREWALL_OPEN_ANY").lower() in _TRUE
+    return _setting("AGENTOS_FIREWALL_OPEN_ANY").lower() in _TRUE
 
 
 def ensure_restricted(port: int | None = None, *, apply: bool = True,
                       ips: list[str] | None = None) -> tuple[bool, str]:
-    """Limit ``port`` to the allowlisted IPs. Returns ``(changed, message)``. Never raises.
+    """Limit ``port`` to EXACTLY the allowlisted IPs. Returns ``(changed, message)``.
+    Never raises.
 
     Adds a per-IP rule for each allowlisted address that lacks one, THEN removes
-    the open-to-any rule — in that order, and the removal is skipped if any add
-    failed, so the backend never loses its route mid-change. Same contract as
+    the open-to-any rule and every per-IP rule for an address no longer allowed
+    (only one user IP may reach the panel, so replacing it must close the old
+    one) — in that order, and the removals are skipped if any add failed, so the
+    backend never loses its route mid-change. Same contract as
     :func:`ensure_open` otherwise: unreadable state is never treated as closed,
     an unprivileged run only returns the commands, and macOS never applies.
 
@@ -299,18 +301,23 @@ def ensure_restricted(port: int | None = None, *, apply: bool = True,
                        f"to the allowlist yourself:\n{printable}")
 
     have = {n for n in (_net(x) for x in sources) if n is not None}
+    want = {n for n in (_net(ip) for ip in ips) if n is not None}
     missing = [ip for ip in ips if _net(ip) is not None and _net(ip) not in have]
+    stale = sorted(x for x in sources if _net(x) is not None and _net(x) not in want)
     open_any = "Anywhere" in sources
 
-    if not missing and not open_any:
+    if not missing and not open_any and not stale:
         return (False, f"TCP {port} is restricted to the allowlist" + inactive_note)
 
-    rules = allow_rules(missing, port, sysname)
-    if open_any:
-        rules.append(revoke_any_rule(port, sysname))
+    removals = ([revoke_any_rule(port, sysname)] if open_any else []) + [
+        revoke_rule(x, port, sysname) for x in stale]
+    rules = allow_rules(missing, port, sysname) + removals
     printable = "  " + "\n  ".join(rules)
-    what = (f"TCP {port} is open to ANY source" if open_any
-            else f"TCP {port} is missing a rule for: {', '.join(missing)}")
+    what = "; ".join(w for w in (
+        f"TCP {port} is open to ANY source" if open_any else "",
+        f"missing a rule for: {', '.join(missing)}" if missing else "",
+        f"still allows: {', '.join(stale)}" if stale else "",
+    ) if w)
 
     if not apply or sysname == "darwin":
         return (False, f"{what}. To restrict it to the allowlist:\n{printable}" + inactive_note)
@@ -323,38 +330,31 @@ def ensure_restricted(port: int | None = None, *, apply: bool = True,
         # The any-rule stays: removing it now could cut the backend off.
         return (False, f"could not add allowlist rules for TCP {port}: {'; '.join(failed)}"
                        f"\nThe open-to-any rule was left in place.")
-    if open_any:
-        failed = _apply_rules([revoke_any_rule(port, sysname)])
+    if removals:
+        _apply_rules(removals)
         still = port_sources(port, sysname, collapse=False) or set()
-        if failed or "Anywhere" in still:
-            return (bool(missing), f"TCP {port} is still open to any source — a rule the SDK "
-                                   f"did not create allows it. Find and delete it:\n  "
-                                   + ("sudo ufw status numbered" if sysname == "linux" else
-                                      "netsh advfirewall firewall show rule name=all dir=in")
-                                   + inactive_note)
-        return (True, f"restricted TCP {port} to the allowlist ({len(ips)} IP(s))" + inactive_note)
-    return (True, f"added allowlist rule(s) for TCP {port}: {', '.join(missing)}" + inactive_note)
-
-
-def apply_ip(ip: str, *, add: bool = True, port: int | None = None) -> tuple[bool, str]:
-    """Add (or remove) the kernel rule for one runtime-allowlisted ``ip``. Never raises.
-
-    Called by the ``/api/ui/allowlist`` routes so a newly whitelisted IP is not
-    dropped by the host firewall until the next self-update. Applies only when
-    the panel is privileged and the port is not deliberately open to any source;
-    otherwise returns the command for the operator to run.
+        left = sorted(x for x in still
+                      if x == "Anywhere" or (_net(x) is not None and _net(x) not in want))
+        if left:
+            return (True, f"TCP {port} still allows {', '.join(left)} — a rule the SDK did "
+                          f"not create. Find and delete it:\n  "
+                          + ("sudo ufw status numbered" if sysname == "linux" else
+                             "netsh advfirewall firewall show rule name=all dir=in")
+                          + inactive_note)
+    return (True, f"restricted TCP {port} to the allowlist: {', '.join(ips)}" + inactive_note)
+
+
+def sync_rules(port: int | None = None) -> tuple[bool, str]:
+    """Bring the host firewall in line with the allowlist after it changed.
+
+    Called when the one user IP is set or cleared (CLI or panel), so the new IP's
+    rule is added and the old one's removed straight away rather than at the next
+    self-update. Leaves a deliberately open port alone. Never raises.
     """
-    port = ui_port() if port is None else port
-    sysname = _system()
-    rule = (allow_rules([ip], port, sysname)[0] if add else revoke_rule(ip, port, sysname))
     if open_any_opted_in():
-        return (False, "port is open to any source by choice — no per-IP rule needed")
-    if sysname not in ("linux", "windows") or not _is_privileged():
-        return (False, f"run on the host to update its firewall:\n  {rule}")
-    failed = _apply_rules([rule])
-    if failed:
-        return (False, f"firewall rule failed: {failed[0]}")
-    return (True, f"firewall rule {'added' if add else 'removed'} for {ip}")
+        return (False, "port is open to any source by choice (AGENTOS_FIREWALL_OPEN_ANY) — "
+                       "no per-IP rules to change")
+    return ensure_restricted(port)
 
 
 def revoke_rule(ip: str, port: int, system: str | None = None) -> str:
@@ -607,5 +607,61 @@ def cli(argv: list[str]) -> int:
     return 0 if changed or "restricted to the allowlist" in msg else 1
 
 
+def allow_ip_cli(argv: list[str]) -> int:
+    """``agentos allow-ip [IP | --clear]`` — set, show or clear THE one user IP.
+
+    Only one outside IP may reach the panel at a time; setting a new one replaces
+    the old one in the allowlist and in the host firewall. This command is one of
+    the two ways to change it — both need someone on the machine (this one over
+    SSH, or the panel opened at http://127.0.0.1:8765 on the box); the remote API
+    refuses. Run it as the user the panel runs as, so it edits that user's
+    ~/.agentos/config.toml; the firewall half needs root and prints the command
+    otherwise.
+    """
+    from sdk import config
+
+    def show() -> None:
+        user = config.user_allowed_ip()
+        print(f"Allowed user IP : {user or '(none — only this machine and the backend)'}")
+        print(f"Backend IPs     : {', '.join(config._DEFAULT_ALLOWED_IPS)}")
+        ignored = config.ignored_allowed_ips()
+        if ignored:
+            print(f"Ignored         : {', '.join(ignored)}  (only one user IP is allowed at a time)")
+
+    args = [a for a in argv if a.strip()]
+    if not args or args[0] in ("--show", "show"):
+        show()
+        return 0
+
+    if args[0] in ("--clear", "clear", "--remove"):
+        user = config.user_allowed_ip()
+        runtime = [ip for ip in config.runtime_allowed_ips() if ip == user]
+        if not runtime:
+            if user:
+                print(f"{user} comes from AGENTOS_UI_ALLOWED_IPS in ~/.agentos/.env — "
+                      "remove it there.")
+                return 1
+            print("No user IP is allowed — nothing to clear.")
+            return 0
+        config.remove_allowed_ip(user)
+        print(f"✓ removed {user}")
+    else:
+        ip = args[0]
+        before = config.user_allowed_ip()
+        try:
+            config.add_allowed_ip(ip)
+        except ValueError as exc:
+            print(f"error: {exc}")
+            return 2
+        print(f"✓ {ip} is now the one IP allowed to reach the panel")
+        if before and before != ip:
+            print(f"  (replaced {before} — it no longer has access)")
+
+    changed, msg = sync_rules()
+    print(("↻ " if changed else "") + msg)
+    show()
+    return 0
+
+
 if __name__ == "__main__":  # pragma: no cover
     sys.exit(cli(sys.argv[1:]))

{devops_bot_sdk-1.7.45 → devops_bot_sdk-1.7.46}/sdk/help_data/areas.json

@@ -80,6 +80,15 @@
   "latest_pr": 143,
   "latest_date": "2026-10-16"
  },
+ {
+  "area": "General",
+  "changes_30d": 1,
+  "features_30d": 0,
+  "fixes_30d": 0,
+  "latest": "security: remove public mode; ONE outside IP at a time, set only on the server (allow-ip + Remote access)",
+  "latest_pr": 189,
+  "latest_date": "2026-10-30"
+ },
  {
   "area": "Local Exec",
   "changes_30d": 1,

{devops_bot_sdk-1.7.45 → devops_bot_sdk-1.7.46}/sdk/help_data/commands.json

@@ -509,12 +509,22 @@
   "doc": "https://github.com/consultancy-outfit/DevOpsBot-SDK/blob/main/docs/COMMANDS.md",
   "id": "agentos doctor"
  },
+ {
+  "command": "agentos allow-ip",
+  "syntax": "agentos allow-ip [IP | --clear]",
+  "program": "agentos",
+  "area": "Other",
+  "description": "the ONE outside IP allowed to reach the panel (on the server only)",
+  "valid": true,
+  "doc": "https://github.com/consultancy-outfit/DevOpsBot-SDK/blob/main/docs/COMMANDS.md",
+  "id": "agentos allow-ip"
+ },
  {
   "command": "agentos firewall",
   "syntax": "agentos firewall [--apply] [--any] [--revoke IP] [--port N]",
   "program": "agentos",
   "area": "Admin",
-  "description": "open the control panel's port (allowlisted IPs, or any source with --any)",
+  "description": "limit the control panel's port to the allowlisted IPs",
   "valid": true,
   "doc": "https://github.com/consultancy-outfit/DevOpsBot-SDK/blob/main/docs/COMMANDS.md",
   "id": "agentos firewall"

{devops_bot_sdk-1.7.45 → devops_bot_sdk-1.7.46}/sdk/help_data/help.json

@@ -57,6 +57,10 @@
  },
  {
   "issue": "After `agentos-auto update`: \"no systemd unit 'agentos-ui' — restart the panel manually\", \"could not read the firewall state (needs root …) … sudo ufw allow 8765/tcp\", \"VPS health: not reported — not_assigned_vps\"",
-  "fix": "Not errors. The update restarts the panel so it runs the new code (`sdk/ui/service.py`), checks the panel's port is open for remote access (`sdk/firewall.py` — it never runs sudo itself, so unprivileged it prints the command instead), and reports VPS health only from the VPS assigned to the account (`sdk/vps_health.py`). On a laptop or any machine that is not the assigned VPS all three are expected and need no action; on the VPS, open the port with the printed command if the panel must be reachable remotely, and restart `agentos-ui` if it runs by hand."
+  "fix": "Not errors. The update restarts the panel so it runs the new code (`sdk/ui/service.py`), limits the panel's port to the allowed IPs — the backend and the one outside IP; it removes any open-to-everyone rule (`sdk/firewall.py` `ensure_restricted` — it never runs sudo itself, so unprivileged it prints the commands instead), and reports VPS health only from the VPS assigned to the account (`sdk/vps_health.py`). On a laptop or any machine that is not the assigned VPS all three are expected and need no action; on the VPS, run `sudo agentos firewall --apply`, and restart `agentos-ui` if it runs by hand. \"ufw is INACTIVE\" in that output means no rule is enforced at all: `sudo ufw allow OpenSSH && sudo ufw enable`."
+ },
+ {
+  "issue": "Panel at 100% CPU / slow, lots of 403s or unknown IPs in `ss -tn sport = :8765`",
+  "fix": "Internet scanners reaching an open 8765. On 1.7.45+ refusals are cheap and capped, but the fix is the firewall: `sudo agentos firewall --apply`, then `sudo ufw status verbose` (8765 → only the allowed IPs; Status active). Older SDKs re-opened the port to everyone on every update — `agentos-auto update` first."
  }
 ]

{devops_bot_sdk-1.7.45 → devops_bot_sdk-1.7.46}/sdk/help_data/pages.json

@@ -3,7 +3,7 @@
   "page": "Dashboard",
   "file": "index.html",
   "heading": "Daily ticket activity",
-  "summary": ""
+  "summary": "Bot — waiting for work To Do— In Progress— Done— Backlog— Daily ticket activity 7 days 30 days To Do In Progress Done Backlog Up next0 Remote access Allowed IP: —"
  },
  {
   "page": "Run & Logs",

{devops_bot_sdk-1.7.45 → devops_bot_sdk-1.7.46}/sdk/help_data/releases.json

@@ -1,4 +1,14 @@
 [
+ {
+  "pr": 189,
+  "date": "2026-10-30",
+  "merged_at": "2026-10-30T14:14:39+05:00",
+  "type": "Other",
+  "area": "General",
+  "title": "security: remove public mode; ONE outside IP at a time, set only on the server (allow-ip + Remote access)",
+  "version": "1.7.46",
+  "url": "https://github.com/consultancy-outfit/DevOpsBot-SDK/pull/189"
+ },
  {
   "pr": 188,
   "date": "2026-10-29",

devops_bot_sdk-1.7.46/sdk/help_data/snapshot.json

@@ -0,0 +1,17 @@
+[
+ {
+  "version": "1.7.46",
+  "commit": "5f00536",
+  "pushed_at": "2026-10-30T14:14:39+05:00",
+  "generated_at": "2026-10-30T09:15:50+00:00",
+  "commands": 59,
+  "commands_invalid": 0,
+  "commands_undocumented": 0,
+  "panel_pages": 11,
+  "tests": 2597,
+  "prs_7d": 25,
+  "prs_30d": 41,
+  "features_30d": 12,
+  "fixes_30d": 18
+ }
+]