@agentsdock/server 1.0.10-beta.1 → 1.0.10-beta.6

package/server/server_instances.py

@@ -17,6 +17,7 @@ import os
 from pathlib import Path
 import plistlib
 import re
+import select
 import shlex
 import shutil
 import socket
@@ -24,7 +25,9 @@ import stat
 import subprocess
 import sys
 import tempfile
+import termios
 import time
+import tty
 from urllib.parse import urlsplit
 
 INSTANCE_PROTOCOL = 1
@@ -135,6 +138,26 @@ def read_config(instance: Instance) -> dict[str, str]:
     return result
 
 
+def split_layout(instance: Instance, platform: str = sys.platform):
+    """Default-only split detection; invalid evidence never falls back to legacy."""
+    if instance.name != "default":
+        return None
+    marker = instance.runtime / "execution-layout.json"
+    if not marker.exists() and not marker.is_symlink():
+        return None
+    import execution_install as files
+    from execution_uninstall import _service_files
+    layout = files.installed_layout(instance.runtime)
+    expected_platform = "Darwin" if platform == "darwin" else "Linux" if platform.startswith("linux") else None
+    if ((layout.install_root, layout.config_root, layout.state_root, layout.home, layout.platform)
+            != (instance.runtime, instance.config, instance.state, instance.home, expected_platform)):
+        raise ValueError("Default execution roots/platform do not match this instance.")
+    for role in ("worker", "gateway"):
+        check_path(layout.service_path(role), instance.home)
+    _service_files(layout)
+    return layout
+
+
 def validate_binding(instance: Instance, platform: str = sys.platform) -> None:
     for path in (instance.runtime, instance.config, instance.state, instance.logs, instance.service_file(platform)):
         check_path(path, instance.home)
@@ -142,6 +165,8 @@ def validate_binding(instance: Instance, platform: str = sys.platform) -> None:
     for key, value in instance.environment().items():
         if key in env and env[key] != value:
             raise ValueError(f"{instance.name}: {key} does not match this instance; refusing service changes.")
+    if split_layout(instance, platform) is not None:
+        return
     service = instance.service_file(platform)
     if service.exists():
         data = read_regular(service)
@@ -367,6 +392,22 @@ def run(command: list[str], **kwargs):
 
 
 def service_status(instance: Instance, platform: str = sys.platform) -> str:
+    try:
+        layout = split_layout(instance, platform)
+        if layout is not None:
+            from execution_manage import NativeServices, read_lifecycle_intent
+            native = NativeServices(layout)
+            native.validate_registered_bindings()
+            snapshot = native.snapshot()
+            states = {item["state"] for item in snapshot.values()}
+            intent = read_lifecycle_intent(layout)
+            if states <= {"absent", "stopped"}:
+                return "stopped"
+            if states == {"running"}:
+                return "pending" if intent is not None else "running"
+            return "partial"
+    except (OSError, ValueError, RuntimeError, subprocess.TimeoutExpired):
+        return "unknown"
     command = ["launchctl", "print", f"gui/{os.getuid()}/{launchd_label(instance.name)}"] if platform == "darwin" else ["systemctl", "--user", "show", service_name(instance.name) + ".service", "--property=ActiveState", "--value"]
     try:
         result = subprocess.run(command, capture_output=True, text=True, timeout=3, check=False)
@@ -611,6 +652,147 @@ def show(instance: Instance, *, network: dict[str, str] | None = None):
     print()
 
 
+def show_status(instance: Instance, *, network: dict[str, str]) -> None:
+    """Read-only per-instance summary; never print configuration or tokens."""
+    item = describe(instance)
+    print(terminal_color(f"Server ({item['name']}):", "34"))
+    print(f"  Status:   {item['status']}")
+    addresses = []
+    if item["port"]:
+        choices = connection_choices(read_config(instance).get("AGENTSDOCK_AGENT_BIND", "0.0.0.0"),
+                                     item["port"], item["addresses"], network)
+        if choices["tailscale"]:
+            addresses.append(f"{choices['tailscale']} (Tailscale / other networks)")
+        for key, label in (("lan", "Same Wi-Fi / LAN"), ("local", "This machine only"),
+                           ("other", "Other / unverified")):
+            addresses.extend(f"{url} ({label})" for url in choices[key])
+    print("  Address:  " + (addresses[0] if addresses else "Not configured"))
+    for address in addresses[1:]:
+        print("            " + address)
+    print(f"  Version:  {item['version'] or 'unknown'}")
+    print(f"  Port:     {item['port'] or 'Not configured'}")
+    print()
+
+
+def read_token_menu_key(fd: int) -> str:
+    key = os.read(fd, 1)
+    if key in (b"", b"\x03", b"\x04"):
+        return "cancel"
+    if key in (b"\r", b"\n"):
+        return "enter"
+    if key != b"\x1b":
+        return "other"
+    sequence = b""
+    while len(sequence) < 16 and select.select([fd], [], [], 0.15)[0]:
+        part = os.read(fd, 1)
+        if not part:
+            return "cancel"
+        sequence += part
+        if sequence in (b"[A", b"OA"):
+            return "up"
+        if sequence in (b"[B", b"OB"):
+            return "down"
+        if sequence[:1] not in (b"[", b"O") or (len(sequence) > 1 and 0x40 <= part[0] <= 0x7e):
+            return "other"
+    return "cancel" if not sequence else "other"
+
+
+def arrow_token_choice(rows: list[str], fd: int, settings: list) -> int | None:
+    """Render a bounded terminal menu and restore input mode before token output."""
+    size = shutil.get_terminal_size(fallback=(80, 24))
+    visible = min(len(rows), max(1, size.lines - 6), 10)
+    width = max(1, size.columns - 1)
+    selected, start = 0, 0
+    hint = "Use ↑/↓ to choose; Enter to select; Esc to cancel."
+
+    def render(redraw=False):
+        if redraw:
+            sys.stdout.write(f"\x1b[{visible + 1}A")
+        for index in range(start, start + visible):
+            row = ("  > " if index == selected else "    ") + rows[index]
+            row = row[:width]
+            if index == selected:
+                row = terminal_color(row, "1;36")
+            sys.stdout.write("\r\x1b[2K" + row + "\n")
+        sys.stdout.write("\r\x1b[2K" + hint[:width] + "\n")
+        sys.stdout.flush()
+
+    try:
+        tty.setcbreak(fd, termios.TCSANOW)
+        sys.stdout.write("\x1b[?25l")
+        render()
+        while True:
+            key = read_token_menu_key(fd)
+            if key == "cancel":
+                return None
+            if key == "enter":
+                return selected
+            if key not in ("up", "down"):
+                continue
+            selected = (selected + (1 if key == "down" else -1)) % len(rows)
+            start = min(start, selected) if selected < start else max(start, selected - visible + 1)
+            render(redraw=True)
+    except KeyboardInterrupt:
+        return None
+    finally:
+        termios.tcsetattr(fd, termios.TCSANOW, settings)
+        sys.stdout.write("\x1b[?25h\n")
+        sys.stdout.flush()
+
+
+def choose_token_instance(registry: Registry) -> Instance | None:
+    """Select by stable instance name; never default or expose unselected tokens."""
+    items = registry.instances()
+    if not items:
+        print("No installations found. Run agentsdock setup to create your first server.")
+        return None
+    if not (sys.stdin.isatty() and sys.stdout.isatty()):
+        raise ValueError("Choose a server in an interactive terminal, or run agentsdock token NAME "
+                         "(for example: agentsdock token default). No token was shown.")
+    print("\nChoose a server to view its access token:\n")
+    rows = []
+    for index, instance in enumerate(items, 1):
+        config = read_config(instance)
+        port = config.get("AGENTSDOCK_AGENT_PORT") or "not configured"
+        rows.append(f"{instance.name:<20} {service_status(instance):<10} Port: {port}")
+    if os.environ.get("TERM", "dumb") not in ("", "dumb"):
+        try:
+            fd = sys.stdin.fileno()
+            settings = termios.tcgetattr(fd)
+        except (OSError, ValueError, termios.error):
+            pass  # Basic terminals retain the explicit numbered/name prompt.
+        else:
+            index = arrow_token_choice(rows, fd, settings)
+            if index is None:
+                print("Cancelled; no token was shown.")
+                return None
+            selected = items[index]
+            if selected.name not in {item.name for item in registry.instances()}:
+                raise ValueError("That server is no longer available. Run agentsdock token again. No token was shown.")
+            return selected
+    for index, row in enumerate(rows, 1):
+        print(f"  {index}. {row}")
+    print()
+    names = {item.name: item for item in items}
+    while True:
+        try:
+            answer = input("Enter a number or server name (Enter to cancel): ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            answer = ""
+        if not answer:
+            print("Cancelled; no token was shown.")
+            return None
+        selected = names.get(answer)
+        if re.fullmatch(r"[1-9][0-9]{0,5}", answer) and int(answer) <= len(items):
+            selected = items[int(answer) - 1]
+        if selected is not None:
+            if selected.name not in {item.name for item in registry.instances()}:
+                raise ValueError("That server is no longer available. Run agentsdock token again. No token was shown.")
+            return selected
+        print(f"Please enter a number from 1 to {len(items)} or a listed server name (Enter cancels).")
+
+
 def terminal_color(text: str, code: str) -> str:
     color = sys.stdout.isatty() and os.environ.get("TERM") != "dumb" and "NO_COLOR" not in os.environ
     return f"\033[{code}m{text}\033[0m" if color else text
@@ -719,6 +901,11 @@ def release_uninstalled_name(instance: Instance, registry: Registry) -> None:
 
 def control(instance: Instance, action: str, platform: str = sys.platform):
     validate_binding(instance, platform)
+    layout = split_layout(instance, platform)
+    if layout is not None:
+        from execution_manage import LifecycleController
+        LifecycleController(layout).run(action)
+        return
     if not instance.service_file(platform).exists():
         raise ValueError(f"{instance.name}: no installed service.")
     if platform == "darwin":
@@ -747,8 +934,11 @@ def parser() -> argparse.ArgumentParser:
     result = argparse.ArgumentParser(description="Independent AgentsServer instances for the current OS user. Defaults to list.")
     commands = result.add_subparsers(dest="command")
     commands.add_parser("list")
+    commands.add_parser("token", help="Choose an existing server and display only its access token")
     info = commands.add_parser("info")
     info.add_argument("name", type=instance_name)
+    status = commands.add_parser("status", help="Show readable details for all instances or one name")
+    status.add_argument("name", nargs="?", type=instance_name)
     new = commands.add_parser("new")
     new.add_argument("--name", type=instance_name)
     new.add_argument("--port", type=int)
@@ -785,13 +975,30 @@ def main(argv: list[str] | None = None) -> int:
             validate_binding(instance)
             print(instance.shell_bindings())
             return 0
-        if args.command in {None, "list", "info"}:
+        if args.command == "token":
+            selected = choose_token_instance(registry)
+            if selected is None:
+                return 0
+            try:
+                run(["/bin/bash", str(ROOT / "install.sh"), "--instance", selected.name, "--show-token"],
+                    env=clean_environment(selected), cwd=ROOT)
+                return 0
+            except subprocess.CalledProcessError as exc:
+                return exc.returncode if exc.returncode > 0 else 1
+        if args.command in {None, "list", "info", "status"}:
             items = registry.instances()
-            if args.command == "info":
+            if args.command in {"info", "status"} and args.name:
                 items = [item for item in items if item.name == args.name]
                 if not items:
                     raise ValueError("Unknown instance.")
+            if args.command == "info":
                 print(json.dumps(describe(items[0]), indent=2))
+            elif args.command == "status":
+                network = tailscale_status() if items else None
+                for item in items:
+                    show_status(item, network=network)
+                if not items:
+                    print("No installations found. Run agentsdock setup to create your first server.")
             else:
                 network = tailscale_status() if items else None
                 print("NAME                 STATUS     PORT")
@@ -916,13 +1123,13 @@ def main(argv: list[str] | None = None) -> int:
                         control(item, args.command)
                     if args.command != "remove":
                         print(f"{item.name}: {args.command} completed", flush=True)
-                except (OSError, ValueError, KeyError, subprocess.CalledProcessError) as exc:
+                except (OSError, ValueError, RuntimeError, KeyError, subprocess.CalledProcessError) as exc:
                     print(f"{item.name}: failed ({exc})", file=sys.stderr)
                     failures += 1
             if args.command == "remove" and not failures:
                 print("\n" + terminal_color("Successful!", "32"), flush=True)
             return int(bool(failures))
-    except (OSError, ValueError, KeyError) as exc:
+    except (OSError, ValueError, RuntimeError, KeyError) as exc:
         print(f"Instance manager: {exc}", file=sys.stderr)
         return 1
 

package/server/update_handoff.py

@@ -30,9 +30,11 @@ def _no_activation(root: Path) -> None:
 
 def _no_handoff_recovery_overlap(root: Path) -> None:
     _no_activation(root)
-    marker = root / ".execution-uninstall.json"
-    if marker.exists() or marker.is_symlink():
-        raise RuntimeError("uninstall already owns execution recovery")
+    for name in (".execution-uninstall.json", ".execution-lifecycle.json"):
+        marker = root / name
+        if marker.exists() or marker.is_symlink():
+            owner = "uninstall" if name == ".execution-uninstall.json" else "native lifecycle"
+            raise RuntimeError(owner + " already owns execution recovery")
 
 
 def _read_handoff(root: Path, path: Path) -> dict[str, Any]:
@@ -68,14 +70,7 @@ def _read_handoff(root: Path, path: Path) -> dict[str, Any]:
 
 
 def _installed_layout(root: Path) -> files.ExecutionLayout:
-    data, _mode = files._read_file(root / files.LAYOUT_NAME, private=True)
-    value = json.loads(data)
-    if not isinstance(value, dict):
-        raise ValueError("installed execution layout is invalid")
-    layout = files.ExecutionLayout.from_dict(value.get("layout"))
-    if layout.install_root != root or value != files.layout_manifest(layout):
-        raise ValueError("installed execution layout changed")
-    return layout
+    return files.installed_layout(root)
 
 
 def _matching_status(handoff: dict, layout: files.ExecutionLayout, record: dict,