agentwire-dev 1.43.0__tar.gz → 1.44.0__tar.gz

{agentwire_dev-1.43.0 → agentwire_dev-1.44.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentwire-dev
-Version: 1.43.0
+Version: 1.44.0
 Summary: Multi-session voice web interface for AI coding agents
 Project-URL: Homepage, https://agentwire.dev
 Project-URL: Repository, https://github.com/dotdevdotdev/agentwire-dev
@@ -694,6 +694,7 @@ Requires-Dist: mcp>=1.2.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: pyyaml>=6.0
+Requires-Dist: qrcode>=7.4
 Requires-Dist: requests>=2.28.0
 Requires-Dist: resend>=2.0.0
 Requires-Dist: useful-moonshine-onnx>=20250101; python_version < '3.14'

{agentwire_dev-1.43.0 → agentwire_dev-1.44.0}/agentwire/__init__.py

@@ -1,3 +1,3 @@
 """AgentWire - Multi-session voice web interface for AI coding agents."""
 
-__version__ = "1.43.0"
+__version__ = "1.44.0"

{agentwire_dev-1.43.0 → agentwire_dev-1.44.0}/agentwire/__main__.py

@@ -820,9 +820,6 @@ def _start_portal_local(args, attach: bool = True) -> int:
     When attach is False (used by `agentwire up`), the portal is started
     detached and we return without attaching.
     """
-    from .network import NetworkContext
-    from .tunnels import TunnelManager
-
     session_name = get_portal_session_name()
 
     if tmux_session_exists(session_name):
@@ -832,31 +829,10 @@ def _start_portal_local(args, attach: bool = True) -> int:
             subprocess.run(["tmux", "attach-session", "-t", session_name])
         return 0
 
-    # Ensure required tunnels are up before starting portal
-    ctx = NetworkContext.from_config()
-    required_tunnels = ctx.get_required_tunnels()
-
-    if required_tunnels:
-        print("Ensuring tunnels to remote services...")
-        tm = TunnelManager()
-
-        for spec in required_tunnels:
-            status = tm.check_tunnel(spec)
-
-            if status.status == "up":
-                print(f"  [ok] {spec.remote_machine}:{spec.remote_port} (already up)")
-            else:
-                print(f"  [..] Creating tunnel to {spec.remote_machine}:{spec.remote_port}...", end=" ", flush=True)
-                result = tm.create_tunnel(spec, ctx)
-
-                if result.status == "up":
-                    print("[ok]")
-                else:
-                    print("[!!]")
-                    print(f"      Warning: Could not create tunnel: {result.error}")
-                    print(f"      The portal may not be able to reach {spec.remote_machine}.")
-
-        print()
+    # No tunnel auto-spawn (#420): agentwire owns only the local portal
+    # boundary. Reaching the portal from elsewhere is bring-your-own
+    # (cloudflared/tailscale/ssh -L), and `agentwire tunnels *` remains as an
+    # opt-in manual helper for the vestigial remote-service-split case.
 
     # Build the server command
     # --dev runs from source with uv run (picks up code changes immediately)
@@ -1224,6 +1200,80 @@ def cmd_portal_token(args) -> int:
     return 0
 
 
+def cmd_portal_pair(args) -> int:
+    """Create a short-lived pairing code (+ QR) for a new device."""
+    from .devices import PAIRING_TTL_SECONDS, create_pairing
+
+    pairing = create_pairing(name=getattr(args, "name", None) or "device")
+
+    portal_url = _default_portal_url()
+    pair_url = f"{portal_url}/pair?code={pairing.code}"
+    ttl_min = PAIRING_TTL_SECONDS // 60
+
+    print(f"Pairing code: {pairing.code}")
+    print(f"  Name:  {pairing.name}")
+    print(f"  Expires in {ttl_min} minutes.")
+    print()
+    print("On the device, open:")
+    print(f"  {pair_url}")
+    print("or visit", f"{portal_url}/pair", "and enter the code.")
+    print()
+
+    try:
+        import qrcode  # type: ignore
+
+        qr = qrcode.QRCode(border=1)
+        qr.add_data(pair_url)
+        qr.make()
+        qr.print_ascii(invert=True)
+    except Exception:
+        print("(install `qrcode` to render a scannable QR here)")
+
+    return 0
+
+
+def cmd_portal_devices(args) -> int:
+    """List paired portal devices."""
+    from .devices import DeviceRegistry
+
+    registry = DeviceRegistry.load()
+    json_mode = getattr(args, "json", False)
+
+    if json_mode:
+        _output_json({"success": True, "devices": [d.public() for d in registry.devices]})
+        return 0
+
+    if not registry.devices:
+        print("No paired devices. The host bootstrap token (agentwire portal token)")
+        print("is the only credential. Add one with: agentwire portal pair")
+        return 0
+
+    print(f"{'ID':<14}{'NAME':<24}{'LAST SEEN':<22}STATUS")
+    for d in registry.devices:
+        status = "revoked" if d.revoked else "active"
+        print(
+            f"{d.id:<14}{(d.name or '')[:23]:<24}"
+            f"{(d.last_seen or 'never'):<22}{status}"
+        )
+    return 0
+
+
+def cmd_portal_revoke(args) -> int:
+    """Revoke one paired device without affecting the others."""
+    from .devices import DeviceRegistry
+
+    registry = DeviceRegistry.load()
+    if registry.revoke(args.device_id):
+        print(f"Revoked device '{args.device_id}'. It now gets 401 on every route.")
+        return 0
+    print(
+        f"No active device with id '{args.device_id}'. "
+        "List them with: agentwire portal devices",
+        file=sys.stderr,
+    )
+    return 1
+
+
 def cmd_portal_restart(args) -> int:
     """Restart the AgentWire portal (stop + start)."""
     import time
@@ -3005,6 +3055,30 @@ def _record_session_creator(session_name: str, created_by: str | None, via: str)
     store_session_metadata(session_name, metadata)
 
 
+def _display_parent(session_name: str, path: str = "") -> "str | None":
+    """The session that should visually own this one in the sidebar.
+
+    Display-only relationship (powers sidebar nesting, issue #448) — NOT a
+    lifecycle coupling. Mirrors prompt_router.resolve_parent's precedence for
+    pane-0 sessions, minus the liveness check (the sidebar decides whether to
+    nest based on whether the parent is actually in the list):
+      1. Creator recorded at `agentwire new` time (session metadata).
+      2. `.agentwire.yml` `parent:` field (from the session's path).
+    Returns None for top-level sessions (no recorded parent).
+    """
+    bare = session_name.split("@")[0]
+    creator = load_session_metadata(bare).get("created_by")
+    if isinstance(creator, str) and creator and creator != bare:
+        return creator
+    try:
+        parent = get_parent_from_config(Path(path) if path else None)
+    except Exception:
+        parent = None
+    if parent and parent != bare:
+        return parent
+    return None
+
+
 def cmd_notify(args) -> int:
     """Send a notification to the portal about session/pane state changes.
 
@@ -3347,6 +3421,7 @@ def cmd_list(args) -> int:
                             "machine": None,
                             "type": cfg.get("type"),
                             "roles": cfg.get("roles", []),
+                            "parent": _display_parent(parts[0], path),
                         }
                         if usage_limit_parked(parts[0]):
                             session_info["usage_limit"] = True
@@ -6248,8 +6323,11 @@ def cmd_machine_add(args) -> int:
     print()
     print("Next steps:")
     print("  1. Ensure SSH access: ssh", f"{user}@{host}" if user else host)
-    print("  2. Start tunnel: autossh -M 0 -f -N -R 8765:localhost:8765", machine_id)
-    print("  3. Restart portal: agentwire portal stop && agentwire portal start")
+    print("  2. Restart portal: agentwire portal stop && agentwire portal start")
+    print()
+    print("Remote session management uses plain SSH — no tunnel needed. To reach")
+    print("the portal from another network, bring your own tunnel (cloudflared/")
+    print("tailscale); see docs/wiki/deployment/remote-access.md.")
     print()
     print("For full setup guide, run: /machine-setup in a Claude session")
 
@@ -6287,28 +6365,6 @@ def cmd_machine_remove(args) -> int:
     print(f"Removing machine '{machine_id}' (host: {host})...")
     print()
 
-    # Step 2: Kill autossh tunnel
-    print("Stopping tunnel...")
-    result = subprocess.run(
-        ["pkill", "-f", f"autossh.*{machine_id}"],
-        capture_output=True,
-    )
-    if result.returncode == 0:
-        print(f"  ✓ Killed autossh tunnel for {machine_id}")
-    else:
-        # Also try by host if different from id
-        if host != machine_id:
-            result = subprocess.run(
-                ["pkill", "-f", f"autossh.*{host}"],
-                capture_output=True,
-            )
-            if result.returncode == 0:
-                print(f"  ✓ Killed autossh tunnel for {host}")
-            else:
-                print("  - No tunnel running (or already stopped)")
-        else:
-            print("  - No tunnel running (or already stopped)")
-
     # Step 3: Remove from machines.json
     print("Updating machines.json...")
     machines_data["machines"] = [m for m in machines if m.get("id") != machine_id]
@@ -6326,21 +6382,17 @@ def cmd_machine_remove(args) -> int:
     print("1. Remove SSH config entry:")
     print(f"   Edit ~/.ssh/config and remove the 'Host {machine_id}' block")
     print()
-    print("2. Remove from tunnel startup script (if using):")
-    print("   Edit ~/.local/bin/agentwire-tunnels")
-    print(f"   Remove '{machine_id}' from the MACHINES list")
-    print()
-    print("3. Delete GitHub deploy keys:")
+    print("2. Delete GitHub deploy keys:")
     print("   gh repo deploy-key list --repo <user>/<repo>")
     print(f"   # Find keys titled '{machine_id}' and delete them:")
     print("   gh repo deploy-key delete <key-id> --repo <user>/<repo>")
     print()
-    print("4. Destroy remote machine:")
+    print("3. Destroy remote machine:")
     print("   Option A: Delete user only")
     print("     ssh root@<ip> 'pkill -u agentwire; userdel -r agentwire'")
     print("   Option B: Destroy the VM entirely via provider console")
     print()
-    print("5. Restart portal to pick up changes:")
+    print("4. Restart portal to pick up changes:")
     print("   agentwire portal stop && agentwire portal start")
     print()
 
@@ -7062,7 +7114,7 @@ def cmd_safety_logs(args) -> int:
 
 def cmd_safety_install(args) -> int:
     """CLI command: agentwire safety install"""
-    return cli_safety.safety_install_cmd()
+    return cli_safety.safety_install_cmd(assume_yes=getattr(args, "yes", False))
 
 
 def cmd_safety_tooldefs_list(args) -> int:
@@ -7075,6 +7127,79 @@ def cmd_safety_tooldefs_show(args) -> int:
     return cli_safety.safety_tooldefs_show_cmd(args.tool)
 
 
+def _render_damage_control_section() -> int:
+    """Print the damage-control health block. Returns the count of issues found.
+
+    Covers the four #462 blind spots plus DC hook staleness: the global kill
+    switch (``safety.enabled: false``), installed-rules drift vs the bundled
+    rules, PreToolUse matcher registration, and DC hook-script staleness.
+    """
+    issues = 0
+
+    # Kill switch — config.safety.enabled gates ALL damage control. A silent
+    # `false` is the loudest possible failure, so flag it first and hard.
+    try:
+        from .config import load_config as _load_config_typed
+        safety_enabled = _load_config_typed().safety.enabled
+    except Exception as e:
+        print(f"  [..] Could not read safety config: {e}")
+        safety_enabled = True
+    if not safety_enabled:
+        print("  [!!] Damage control is DISABLED (safety.enabled: false)")
+        print("       ALL command/path/outbound gating is off.")
+        print("       Fix: set safety.enabled: true in ~/.agentwire/config.yaml")
+        issues += 1
+    else:
+        print("  [ok] Damage control enabled (safety.enabled: true)")
+
+    try:
+        from . import cli_safety
+    except Exception as e:
+        print(f"  [..] Could not load safety module: {e}")
+        return issues
+
+    # DC hook-script staleness (bash/edit/write/mcp-tool + audit_logger).
+    hook_drift = cli_safety.damage_control_hook_drift()
+    stale_hooks = [f for f, s in hook_drift.items() if s == "stale"]
+    missing_hooks = [f for f, s in hook_drift.items() if s == "missing"]
+    if stale_hooks or missing_hooks:
+        if missing_hooks:
+            print(f"  [!!] DC hook scripts missing: {', '.join(sorted(missing_hooks))}")
+        if stale_hooks:
+            print(f"  [!!] DC hook scripts STALE: {', '.join(sorted(stale_hooks))}")
+        print("       Fix: agentwire safety install --yes")
+        issues += 1
+    else:
+        print("  [ok] DC hook scripts current")
+
+    # Installed-rules drift vs bundled rules (the incident's missing files).
+    rule_drift = cli_safety.rules_drift()
+    missing_rules = [f for f, s in rule_drift.items() if s == "missing"]
+    stale_rules = [f for f, s in rule_drift.items() if s == "stale"]
+    if missing_rules:
+        print(f"  [!!] Damage-control rules NOT installed: {', '.join(sorted(missing_rules))}")
+        print("       Fix: agentwire safety install --yes")
+        issues += 1
+    elif stale_rules:
+        # Stale = installed copy differs from bundled. Could be an intentional
+        # customization, so warn (not error) and don't auto-overwrite.
+        print(f"  [..] Damage-control rules differ from bundled: {', '.join(sorted(stale_rules))}")
+        print("       (customized? `agentwire safety install --yes` leaves these untouched)")
+    else:
+        print("  [ok] Damage-control rules installed and match bundled")
+
+    # Matcher presence in ~/.claude/settings.json.
+    missing_matchers = cli_safety.missing_damage_control_matchers()
+    if missing_matchers:
+        print(f"  [!!] PreToolUse matchers not registered: {', '.join(missing_matchers)}")
+        print("       Fix: agentwire safety install --yes")
+        issues += 1
+    else:
+        print("  [ok] PreToolUse damage-control matchers registered")
+
+    return issues
+
+
 def _render_voice_loop_section(config, ctx) -> int:
     """Print the voice-loop (push-to-talk) preflight. Returns failures found.
 
@@ -7256,6 +7381,36 @@ def cmd_doctor(args) -> int:
             print(f"  [..] {label}: not found ({why})")
             print("     Run: agentwire hooks install")
 
+    # 4b. Damage control (safety) — the kill switch, install drift, and the
+    # PreToolUse matcher registration. The #462 incident: a global disable and
+    # missing rule files were both invisible to every diagnostic.
+    print("\nChecking damage control (safety)...")
+    issues_found += _render_damage_control_section()
+
+    # 4c. Local checkout vs origin/main — rebuild reinstalls whatever is checked
+    # out, so a never-pulled main silently ships stale code. Today only worktree
+    # creation fetches; surface the drift here too.
+    print("\nChecking source checkout...")
+    src_root = Path(__file__).parent.parent
+    if not (src_root / "pyproject.toml").exists():
+        try:
+            src_root = get_source_dir()
+        except Exception:
+            src_root = None
+    if src_root is None:
+        print("  [..] Could not locate source checkout — skipping git-drift check")
+    else:
+        behind, err = _git_behind_origin(src_root)
+        if err:
+            print(f"  [..] Source checkout: skipped git-drift check ({err})")
+        elif behind and behind > 0:
+            print(f"  [!!] Local main is {behind} commit(s) behind origin/main")
+            print(f"       {src_root}")
+            print("       Fix: git pull --ff-only  (then agentwire rebuild)")
+            issues_found += 1
+        else:
+            print("  [ok] Local main up to date with origin/main")
+
     # Check custom services (registry-driven: built-in notifications bridge
     # + user-defined services from services.custom)
     print("\nChecking custom services...")
@@ -7653,15 +7808,70 @@ def cmd_voiceclone_delete(args) -> int:
 UV_CACHE_DIR = Path.home() / ".cache" / "uv"
 
 
+def _git_behind_origin(repo: Path, base: str = "main", do_fetch: bool = True):
+    """How many commits ``origin/<base>`` is ahead of the checkout's HEAD.
+
+    Returns ``(behind, error)``: ``behind`` is the commit count (0 = up to date),
+    or ``None`` with a human-readable ``error`` string when the comparison can't
+    be made (not a git repo, no remote, offline fetch failure, etc.).
+    """
+    if not (repo / ".git").exists():
+        return None, "not a git checkout"
+    if do_fetch:
+        fetch = subprocess.run(
+            ["git", "fetch", "origin", base],
+            cwd=repo, capture_output=True, text=True,
+        )
+        if fetch.returncode != 0:
+            return None, (fetch.stderr or fetch.stdout or "git fetch failed").strip()
+    count = subprocess.run(
+        ["git", "rev-list", "--count", f"HEAD..origin/{base}"],
+        cwd=repo, capture_output=True, text=True,
+    )
+    if count.returncode != 0:
+        return None, (count.stderr or count.stdout or "git rev-list failed").strip()
+    try:
+        return int(count.stdout.strip()), None
+    except ValueError:
+        return None, f"unexpected rev-list output: {count.stdout.strip()!r}"
+
+
 def cmd_rebuild(args) -> int:
     """Rebuild: clear uv cache, uninstall, reinstall from source.
 
     This is the correct way to pick up source changes when developing.
     `uv tool install . --force` does NOT work - it uses cached wheels.
     """
+    force = getattr(args, "force", False)
+
     print("Rebuilding agentwire-dev...")
     print()
 
+    # Resolve the source checkout up front so the git-drift guard and the
+    # install step agree on which tree they're operating over.
+    project_root = Path(__file__).parent.parent
+    if not (project_root / "pyproject.toml").exists():
+        project_root = get_source_dir()
+
+    # Git-drift guard: rebuild is otherwise git-blind and will happily reinstall
+    # stale code when local main was never pulled after a remote merge. Refuse
+    # (unless --force) so the fix happens before the reinstall, not after.
+    behind, err = _git_behind_origin(project_root)
+    if err:
+        print(f"  - Skipping git-drift check ({err})")
+    elif behind and behind > 0:
+        print(f"  [!!] Local checkout is {behind} commit(s) behind origin/main.")
+        print(f"       {project_root}")
+        print("       Rebuild would reinstall stale code. Run first:")
+        print("         git pull --ff-only")
+        if not force:
+            print("       (or re-run with --force to rebuild anyway)")
+            return 1
+        print("       --force given: rebuilding from the behind checkout anyway.")
+    else:
+        print("  ✓ Checkout up to date with origin/main")
+    print()
+
     # Step 1: Clear uv cache
     if UV_CACHE_DIR.exists():
         print(f"Clearing uv cache ({UV_CACHE_DIR})...")
@@ -7683,13 +7893,7 @@ def cmd_rebuild(args) -> int:
         # Might not be installed, that's fine
         print("  - Not installed (continuing)")
 
-    # Step 3: Reinstall from current directory
-    # Find the project root (where pyproject.toml is)
-    project_root = Path(__file__).parent.parent
-    if not (project_root / "pyproject.toml").exists():
-        # Fallback to configured source directory
-        project_root = get_source_dir()
-
+    # Step 3: Reinstall from the source checkout resolved above.
     print(f"Installing from {project_root}...")
     result = subprocess.run(
         ["uv", "tool", "install", "."],
@@ -8527,6 +8731,17 @@ def install_hooks(force: bool = False, copy: bool = False) -> dict[str, str]:
         if event:
             register_hook_in_settings(event, hook_name)
 
+    # Heal the full damage-control surface (hook scripts + rules + tooldefs +
+    # PreToolUse matchers), not just the settings.json matchers. This closes the
+    # documented post-rebuild gap: CLAUDE.md tells users to re-run `hooks install`
+    # after a rebuild, so it must actually sync the DC files/rules — drift-aware,
+    # never clobbering a customized rule.
+    try:
+        from agentwire.cli_safety import heal_damage_control
+        heal_damage_control(quiet=True)
+    except Exception:
+        pass
+
     return results
 
 
@@ -10258,8 +10473,18 @@ def _set_task_enabled(name: str, enabled: bool) -> int:
 
     tasks[name]["enabled"] = enabled
 
-    with open(board_path, "w") as f:
-        yaml.dump(raw, f, default_flow_style=False, sort_keys=False)
+    # Atomic + validated write — never leave scheduler.yaml half-written (#449).
+    from .scheduler import _atomic_write
+
+    text = yaml.dump(raw, default_flow_style=False, sort_keys=False)
+
+    def _validate(tmp_path: str) -> None:
+        with open(tmp_path) as f:
+            reparsed = yaml.safe_load(f)
+        if not isinstance(reparsed, dict) or "tasks" not in reparsed:
+            raise ValueError("scheduler board failed re-parse validation")
+
+    _atomic_write(board_path, text, validate=_validate)
 
     action = "Enabled" if enabled else "Disabled"
     print(f"{action}: {name}")
@@ -10929,6 +11154,27 @@ def main() -> int:
     )
     portal_token.set_defaults(func=cmd_portal_token)
 
+    # portal pair — mint a pairing code (+QR) for a new device
+    portal_pair = portal_subparsers.add_parser(
+        "pair", help="Pair a new device (prints a short-lived code + QR)"
+    )
+    portal_pair.add_argument("--name", help="Friendly device name (e.g. 'phone')")
+    portal_pair.set_defaults(func=cmd_portal_pair)
+
+    # portal devices — list paired devices
+    portal_devices = portal_subparsers.add_parser(
+        "devices", help="List paired portal devices"
+    )
+    portal_devices.add_argument("--json", action="store_true", help="Output JSON")
+    portal_devices.set_defaults(func=cmd_portal_devices)
+
+    # portal revoke — revoke one device
+    portal_revoke = portal_subparsers.add_parser(
+        "revoke", help="Revoke one paired device by id"
+    )
+    portal_revoke.add_argument("device_id", help="Device id (see `portal devices`)")
+    portal_revoke.set_defaults(func=cmd_portal_revoke)
+
     # === tts command group ===
     tts_parser = subparsers.add_parser("tts", help="Manage TTS server")
     tts_subparsers = tts_parser.add_subparsers(dest="tts_command")
@@ -11690,7 +11936,12 @@ def main() -> int:
 
     # safety install
     safety_install = safety_subparsers.add_parser(
-        "install", help="Install damage control hooks (interactive)"
+        "install", help="Install/heal damage control hooks, rules, and matchers"
+    )
+    safety_install.add_argument(
+        "-y", "--yes", action="store_true",
+        help="Non-interactive, drift-aware heal (install missing + update stale "
+             "owned hooks; never clobbers existing rules)",
     )
     safety_install.set_defaults(func=cmd_safety_install)
 
@@ -11735,6 +11986,10 @@ def main() -> int:
     rebuild_parser = subparsers.add_parser(
         "rebuild", help="Clear uv cache and reinstall from source (for development)"
     )
+    rebuild_parser.add_argument(
+        "--force", action="store_true",
+        help="Rebuild even when the local checkout is behind origin/main",
+    )
     rebuild_parser.set_defaults(func=cmd_rebuild)
 
     # === uninstall command ===