agentwire-dev 1.67.0__tar.gz → 1.69.0__tar.gz

{agentwire_dev-1.67.0 → agentwire_dev-1.69.0}/.github/workflows/security.yml

@@ -66,6 +66,16 @@ jobs:
     # deps are bumped explicitly in pyproject; transitive fixes land via lock
     # bumps. See docs/wiki/security/pip-audit.md for the residual-CVE rationale.
     continue-on-error: true
+    # The weekly cron opens/updates the tracking issue, which the DEFAULT token
+    # does not necessarily allow — a repo set to read-only default permissions
+    # would fail the `gh issue` call. Declared explicitly so the durable half of
+    # the visibility fix can't silently no-op. (No `pull-requests: write`: this
+    # deliberately does not comment on PRs — a fork PR gets a read-only token,
+    # so that flow would silently fail for exactly the external contributors it
+    # would exist to serve.)
+    permissions:
+      contents: read
+      issues: write
     steps:
       - uses: actions/checkout@v4
       - name: Install uv
@@ -85,14 +95,42 @@ jobs:
       # HTTP request-handling CVEs are not on a reachable path. Documented +
       # ignored here so the advisory signal stays meaningful; revisit when mcp /
       # chatterbox-tts relax the ceiling. See docs/wiki/security/pip-audit.md.
+      # PYSEC-2026-3483 is the deprecated WebSocket SERVER transport
+      # (mcp.server.websocket) missing Host/Origin validation. agentwire runs
+      # its MCP server on stdio (mcp_server.py: mcp.run(transport="stdio")) and
+      # never imports that module, so it is not on a reachable path. Its fix
+      # needs mcp>=1.28.1, which pulls pydantic 2.13 and cascades the tts
+      # extra's whole chain (torch 2.6 -> 2.13 plus the CUDA stack, 32 packages)
+      # — a bad trade against an unreachable advisory. 1.27.2 clears the other
+      # two mcp advisories at a one-package diff. Revisit when the torch bump is
+      # wanted on its own merits. See docs/wiki/security/pip-audit.md.
       - name: Audit runtime dependencies
+        id: audit
+        continue-on-error: true
         run: >
           uvx pip-audit==2.10.1 -r requirements.txt
+          --format json --output audit-runtime.json
           --ignore-vuln PYSEC-2026-161
           --ignore-vuln CVE-2026-48818
           --ignore-vuln CVE-2026-48817
           --ignore-vuln CVE-2026-54283
           --ignore-vuln CVE-2026-54282
+          --ignore-vuln PYSEC-2026-3483
+      # The job stays advisory (continue-on-error above), but its RESULT is no
+      # longer invisible: this prints ::warning:: annotations, which GitHub
+      # renders on the run and PR checks views without anyone opening the job
+      # log, and writes a table to the step summary. `if: always()` so a
+      # crashed audit reports "UNKNOWN, which is not clean" rather than nothing
+      # — the exact shape of #900, where a red audit rendered as green.
+      # --min-packages is a coverage floor, not a version assertion: zero
+      # advisories over zero packages is not a clean bill of health. The
+      # runtime export is ~124 packages, so anything under 50 means the export
+      # produced nothing to audit and the run is reported UNKNOWN, not clean.
+      - name: Report advisories (never blocks)
+        if: always()
+        run: >
+          uv run --no-project python scripts/pip_audit_report.py
+          audit-runtime.json --scope runtime --min-packages 50
       # Full audit including optional extras (tts/stt: torch, onnxruntime,
       # gradio, ...). Weekly only and never ignore-filtered — surfaces the full
       # backlog for review without blocking or spamming every PR.
@@ -101,4 +139,38 @@ jobs:
         run: uv export --no-emit-project --all-extras --format requirements-txt -o requirements-all.txt
       - name: Full audit (weekly cron, optional extras)
         if: github.event_name == 'schedule'
-        run: uvx pip-audit==2.10.1 -r requirements-all.txt
+        continue-on-error: true
+        run: >
+          uvx pip-audit==2.10.1 -r requirements-all.txt
+          --format json --output audit-all.json
+      - name: Report full audit + open/update the tracking issue
+        if: always() && github.event_name == 'schedule'
+        env:
+          GH_TOKEN: ${{ github.token }}
+          AUDIT_RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+        run: |
+          uv run --no-project python scripts/pip_audit_report.py audit-all.json \
+            --scope "all extras" --min-packages 100 --issue-body issue-body.md
+          # ONE issue, reused. Annotations and summaries belong to a run nobody
+          # revisits; an issue is what actually stops advisories accumulating
+          # unseen — which is how #900 reached eight.
+          title='pip-audit: unresolved advisories in the dependency lock'
+          # --state all, NOT --state open: an open-only search cannot see the
+          # issue this workflow closed last week, so a recurrence would file a
+          # SECOND issue and the "one issue, reused" promise would quietly
+          # become "one per close/recur cycle".
+          existing=$(gh issue list --state all --search "$title in:title" \
+                       --json number,state --jq '.[0] | "\(.number) \(.state)"' || true)
+          number=${existing%% *}
+          state=${existing##* }
+          if grep -q ': clean' issue-body.md; then
+            if [ -n "$number" ] && [ "$state" = "OPEN" ]; then
+              gh issue comment "$number" --body-file issue-body.md
+              gh issue close "$number" --comment "pip-audit is clean; closing. This issue is reopened automatically if findings return."
+            fi
+          elif [ -z "$number" ]; then
+            gh issue create --title "$title" --label "area:security" --body-file issue-body.md
+          else
+            [ "$state" = "CLOSED" ] && gh issue reopen "$number"
+            gh issue comment "$number" --body-file issue-body.md
+          fi

{agentwire_dev-1.67.0 → agentwire_dev-1.69.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentwire-dev
-Version: 1.67.0
+Version: 1.69.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

{agentwire_dev-1.67.0 → agentwire_dev-1.69.0}/agentwire/__init__.py

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

{agentwire_dev-1.67.0 → agentwire_dev-1.69.0}/agentwire/__main__.py

@@ -183,24 +183,27 @@ Command Categories:
     #   - diff:   structured git diff for the mobile Review window
     #   - prompts: prompt routing (rides the limits watchdog)
     #   - msg:    polite agent-to-agent inbox (rides the watchdog)
-    from . import diff_cli, limits_cli, msg_cli, pane_cli, prompts_cli, send_cli  # noqa: I001  # session_cli kept on its own line below to minimize Phase 1 #495 merge conflicts
+    from . import alerts_cli, diff_cli, limits_cli, msg_cli, pane_cli, prompts_cli, send_cli  # noqa: I001  # session_cli kept on its own line below to minimize Phase 1 #495 merge conflicts
     from . import session_cli
     from . import channels_cli, config_cli, portal_cli, tts_cli
     from . import scheduler_cli, ensure_cli, tasks_cli
     from . import doctor_cli, history_cli, machine_cli, safety_cli
     from . import handoff_cli, hooks_cli, mcp_cli, roles_cli, tunnels_cli
     from . import notify_cli, palette_cli, push_cli, repo_cli, system_cli, wiki_cli
-    from . import tabs_cli, wait_cli, worktree_cli
+    from . import restart_cli, tabs_cli, wait_cli, worktree_cli
+    from . import buddy_cli  # BETA: gated on beta.voice_layer (default off)
     from .council import cli as council_cli
 
     _REGISTRARS = [  # noqa: N806  # registry constant; Phase 1 of #495 appends here
         diff_cli.register_diff_parser,
         prompts_cli.register_prompts_parser,
         msg_cli.register_msg_parser,
+        alerts_cli.register_alerts_parser,
         limits_cli.register_limits_parser,
         pane_cli.register_pane_parser,
         send_cli.register_send_parser,
         session_cli.register_session_parser,
+        restart_cli.register_restart_parser,
         portal_cli.register_portal_parser,
         tts_cli.register_tts_parser,
         channels_cli.register_channels_parser,
@@ -227,6 +230,7 @@ Command Categories:
         tabs_cli.register_tabs_parser,
         wait_cli.register_wait_parser,
         worktree_cli.register_helper_parser,
+        buddy_cli.register_buddy_parser,
     ]
     for _reg in _REGISTRARS:
         _reg(subparsers)

agentwire_dev-1.69.0/agentwire/alerts_cli.py

@@ -0,0 +1,153 @@
+"""``agentwire alerts`` — who hears the machine's own detectors (#982).
+
+Fleet detectors (expired login, usage-limit park, dead-lettered report-backs, a
+root pane blocked with nowhere to route) have always been able to email the
+OWNER. ``fleet_alerts`` lets them address a SESSION as typed mail instead, and
+this is the surface that turns that on: without a CLI verb the subscription API
+would be reachable only from inside the tree that calls it, which is precisely
+the shape "CLI is the single source of truth" exists to prevent.
+
+Subscription is a renewable **lease**, so ``list`` reports the expiry rather
+than a boolean: a subscriber that stopped renewing has silently stopped
+hearing anything, and that is a state an operator has to be able to see.
+"""
+
+from __future__ import annotations
+
+import json
+
+from . import fleet_alerts
+
+
+def _emit(payload: dict, json_mode: bool, lines: "list[str] | None" = None) -> int:
+    if json_mode:
+        print(json.dumps(payload, indent=2))
+    else:
+        for line in lines or []:
+            print(line)
+    return 0 if payload.get("success", True) else 1
+
+
+def cmd_alerts_subscribe(args) -> int:
+    json_mode = getattr(args, "json", False)
+    try:
+        lease = fleet_alerts.subscribe(args.session)
+    except Exception as exc:
+        return _emit(
+            {"success": False, "error": str(exc)}, json_mode, [f"error: {exc}"]
+        )
+    return _emit(
+        {"success": True, "session": args.session, "lease": lease},
+        json_mode,
+        [
+            f"'{args.session}' now receives fleet alerts.",
+            f"  lease expires: {lease['expires_at']}",
+            "  Renew before then — an expired lease goes quiet, it does not warn.",
+        ],
+    )
+
+
+def cmd_alerts_unsubscribe(args) -> int:
+    json_mode = getattr(args, "json", False)
+    dropped = fleet_alerts.unsubscribe(args.session)
+    if not dropped:
+        return _emit(
+            {"success": False, "error": f"'{args.session}' was not subscribed"},
+            json_mode,
+            [f"'{args.session}' was not subscribed."],
+        )
+    return _emit(
+        {"success": True, "session": args.session},
+        json_mode,
+        [f"'{args.session}' no longer receives fleet alerts."],
+    )
+
+
+def cmd_alerts_list(args) -> int:
+    """Who is subscribed — and whether this answer can be trusted.
+
+    ``list`` reads the same candidate index the emit path does, so a lost index
+    makes both of them say "nobody". That would be the worst property this
+    command could have: the one surface built to make a silent stop VISIBLE
+    would agree with the silent stop. So the index's presence is reported
+    alongside the answer, and its absence is not rendered as a confident zero.
+    """
+    json_mode = getattr(args, "json", False)
+    names = fleet_alerts.subscribers()
+    index_present = fleet_alerts.subscribers_index_path().exists()
+    rows = [{"session": n, "lease": fleet_alerts.subscription(n)} for n in names]
+    if names:
+        lines = [
+            "Sessions receiving fleet alerts:",
+            *(f"  {r['session']}  (lease expires {(r['lease'] or {}).get('expires_at')})"
+              for r in rows),
+        ]
+    elif index_present:
+        lines = ["No session is subscribed to fleet alerts."]
+    else:
+        lines = [
+            "No subscriber index — so this is NOT a confident 'nobody subscribed'.",
+            "Either nobody ever subscribed, or the index was lost; from here those "
+            "look identical, and while it is missing every alert reaches nobody.",
+            "Settle it (cheap, and it rebuilds the index either way):",
+            "  agentwire alerts reindex",
+        ]
+    return _emit(
+        {
+            "success": True,
+            "subscribers": names,
+            "leases": rows,
+            "index_present": index_present,
+        },
+        json_mode,
+        lines,
+    )
+
+
+def cmd_alerts_reindex(args) -> int:
+    """Rebuild the candidate index from the session records.
+
+    The alert path never walks the record store — that cost sits on the
+    synchronous permission-hook path — so a lost index means fewer alerts until
+    somebody rebuilds it. This is that somebody.
+    """
+    json_mode = getattr(args, "json", False)
+    names = fleet_alerts.reindex()
+    return _emit(
+        {"success": True, "subscribers": names},
+        json_mode,
+        [f"Reindexed: {len(names)} live subscriber(s)." , *(f"  {n}" for n in names)],
+    )
+
+
+def register_alerts_parser(subparsers) -> None:
+    parser = subparsers.add_parser(
+        "alerts",
+        help="Who hears the machine's own detectors (fleet alerts)",
+        description=(
+            "Fleet detectors — expired login, usage-limit park, dead-lettered "
+            "report-backs, a root pane blocked with nowhere to route — email the "
+            "owner. They can also address a SESSION as typed mail: an escalation "
+            "for the two conditions only a human can clear, a note or a request "
+            "for the rest. A session subscribes here, on a renewable lease."
+        ),
+    )
+    sub = parser.add_subparsers(dest="alerts_command", required=True)
+
+    p = sub.add_parser("subscribe", help="Lease fleet alerts for a session")
+    p.add_argument("session", help="Session name (must have a session record)")
+    p.add_argument("--json", action="store_true", help="JSON output")
+    p.set_defaults(func=cmd_alerts_subscribe)
+
+    p = sub.add_parser("unsubscribe", help="Drop a session's fleet-alert lease")
+    p.add_argument("session")
+    p.add_argument("--json", action="store_true", help="JSON output")
+    p.set_defaults(func=cmd_alerts_unsubscribe)
+
+    p = sub.add_parser("list", help="Sessions with a live lease, and its expiry")
+    p.add_argument("--json", action="store_true", help="JSON output")
+    p.set_defaults(func=cmd_alerts_list)
+
+    p = sub.add_parser("reindex", help="Rebuild the subscriber index from records")
+    p.add_argument("--json", action="store_true", help="JSON output")
+    p.set_defaults(func=cmd_alerts_reindex)