agentwire-dev 1.65.1__tar.gz → 1.65.2__tar.gz

{agentwire_dev-1.65.1 → agentwire_dev-1.65.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentwire-dev
-Version: 1.65.1
+Version: 1.65.2
 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.65.1 → agentwire_dev-1.65.2}/agentwire/__init__.py

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

{agentwire_dev-1.65.1 → agentwire_dev-1.65.2}/agentwire/routes/desktop.py

@@ -10,6 +10,22 @@ through the composed server's MRO.
 from aiohttp import web
 
 
+def _artifact_url_hash(url: str) -> str:
+    """FNV-1a 32-bit hash of ``url``, as 8 lowercase hex chars.
+
+    Must match ``artifactUrlHash`` in static/js/desktop.js byte-for-byte —
+    the server and frontend both derive the same fallback artifact id from
+    the same URL, and a naive char-substitution slug (the prior approach)
+    let distinct URLs like "reports/jan.html" and "reports-jan.html" collide
+    onto the same id. A hash isn't lossy the way substitution is.
+    """
+    h = 0x811C9DC5
+    for b in url.encode("utf-8"):
+        h ^= b
+        h = (h * 0x01000193) & 0xFFFFFFFF
+    return f"{h:08x}"
+
+
 class DesktopRoutesMixin:
     async def api_desktop_windows(self, request):
         """GET /api/desktop/windows — query browser clients for open windows."""
@@ -173,7 +189,7 @@ class DesktopRoutesMixin:
                 "url": url,
                 "title": title,
                 "artifact_id": artifact.get("artifact_id")
-                or f"artifact-{url.replace('/', '-').replace('.', '-')}",
+                or f"artifact-{_artifact_url_hash(url)}",
             }
             if not text:
                 text = f"**{title}** is ready — click to open"

{agentwire_dev-1.65.1 → agentwire_dev-1.65.2}/agentwire/session_cli.py

@@ -62,6 +62,7 @@ from .worktree import (
     default_base_branch,
     ensure_worktree,
     git_root,
+    is_registered_worktree,
     is_valid_branch_name,
     parse_session_name,
     remove_worktree,
@@ -1561,7 +1562,17 @@ def _teardown_entry(
     Never reports worktree_removed=True while the dir is still on disk: if
     `git worktree remove --force` can't clear it, this fails LOUDLY
     (success: False) and leaves the registry entry in place, instead of
-    silently "unregistering" an orphan.
+    silently "unregistering" an orphan — UNLESS git *already had no record of
+    the path before we touched it* (see `is_registered_worktree`), in which
+    case there's no registered worktree left to protect and the leftover
+    directory (a stale build-tool cache, typically) is hard-deleted instead.
+
+    That pre-check matters: `git worktree prune` below runs unconditionally
+    and clears any entry git marks "prunable" (e.g. one whose linked `.git`
+    file was deleted) as a side effect of THIS call — checking registration
+    after prune would misread a worktree that was real and registered right
+    up until this attempt as a pre-existing orphan, and hard-delete content
+    the fail-loud path exists to protect.
 
     The worktree removal is attempted BEFORE the session is killed, and the
     session is only killed once removal is confirmed — never the reverse.
@@ -1569,10 +1580,17 @@ def _teardown_entry(
     disk with no session left to notice, on any removal failure (bad
     project_path, a stuck worktree, ...) (#740).
     """
+    was_registered = is_registered_worktree(project_path, worktree_path)
+
     # Force-remove the git worktree, then prune admin files either way.
     _, remove_error = remove_worktree(project_path, worktree_path, force=True)
     subprocess.run(["git", "-C", str(project_path), "worktree", "prune"], capture_output=True)
 
+    hard_deleted_orphan = False
+    if worktree_path.exists() and not was_registered:
+        shutil.rmtree(worktree_path, ignore_errors=True)
+        hard_deleted_orphan = not worktree_path.exists()
+
     if worktree_path.exists():
         reason = remove_error or "worktree directory still present after `git worktree remove --force`"
         return {"success": False, "session": session_name, "path": str(worktree_path),
@@ -1605,7 +1623,7 @@ def _teardown_entry(
     return {"success": True, "session": session_name, "path": str(worktree_path),
             "killed": killed, "worktree_removed": True,
             "branch": branch, "branch_deleted": branch_deleted, "branch_note": branch_note,
-            "orphaned_tabs": orphaned_tabs}
+            "orphaned_tabs": orphaned_tabs, "hard_deleted_orphan": hard_deleted_orphan}
 
 
 def _worktree_remove(args, project_path: Path, worktree_dir: Path, json_mode: bool) -> int:
@@ -1641,7 +1659,9 @@ def _worktree_remove(args, project_path: Path, worktree_dir: Path, json_mode: bo
     else:
         msg = (f"Removed worktree session '{result['session']}'"
                + (" (killed live session)" if result["killed"] else "")
-               + f"; worktree {result['path']} removed")
+               + f"; worktree {result['path']} removed"
+               + (" (git had no registration for it — hard-deleted the leftover directory)"
+                  if result.get("hard_deleted_orphan") else ""))
         if result["branch"]:
             msg += f"; branch '{result['branch']}' " + ("deleted" if result["branch_deleted"] else f"kept ({result['branch_note']})")
         if result["orphaned_tabs"]:

{agentwire_dev-1.65.1 → agentwire_dev-1.65.2}/agentwire/static/js/desktop.js

@@ -824,6 +824,24 @@ function _mountSessionWindow(session, mode, machine, id) {
     addTaskbarButton(id, sw);
 }
 
+/**
+ * FNV-1a 32-bit hash of `url`, as 8 lowercase hex chars. Must match
+ * `_artifact_url_hash` in routes/desktop.py byte-for-byte — server and
+ * frontend both derive the same fallback artifact id from the same URL. A
+ * hash isn't lossy the way the prior char-substitution slug was (distinct
+ * URLs like "reports/jan.html" and "reports-jan.html" collided onto the
+ * same id).
+ */
+function artifactUrlHash(url) {
+    let h = 0x811c9dc5;
+    const bytes = new TextEncoder().encode(url);
+    for (const b of bytes) {
+        h ^= b;
+        h = Math.imul(h, 0x01000193) >>> 0;
+    }
+    return h.toString(16).padStart(8, '0');
+}
+
 /**
  * Open an artifact window (agent-generated HTML or external URL).
  *
@@ -832,7 +850,7 @@ function _mountSessionWindow(session, mode, machine, id) {
  * @param {string|null} artifactId - Optional explicit window ID
  */
 export function openArtifactWindow(url, title = 'Artifact', artifactId = null) {
-    const id = artifactId || `artifact-${url.replace(/[\/\.]/g, '-')}`;
+    const id = artifactId || `artifact-${artifactUrlHash(url)}`;
 
     // Check if already open — restore if minimized, otherwise focus
     if (artifactWindows.has(id)) {

{agentwire_dev-1.65.1 → agentwire_dev-1.65.2}/agentwire/static/js/notifications-panel.js

@@ -86,10 +86,19 @@ class NotificationsPanel {
             this._removeToast(id, false);
         }
 
-        // Evict oldest if at capacity
+        // Evict the oldest toast NOT carrying an artifact notice, if at
+        // capacity. Artifact toasts are exempt regardless of priority: an
+        // unclicked deliverable must not silently fade (#817) — the cap
+        // only trims ordinary toasts (sticky `high`-priority ones included).
+        // If every current toast is an artifact notice, the panel
+        // temporarily exceeds MAX_TOASTS rather than dropping one.
         if (this.toasts.size >= MAX_TOASTS) {
-            const oldest = this.toasts.keys().next().value;
-            this._removeToast(oldest, false);
+            for (const id of this.toasts.keys()) {
+                if (!this.artifactNotices.has(id)) {
+                    this._removeToast(id, false);
+                    break;
+                }
+            }
         }
 
         // Resolve auto-fade: explicit timeout wins (0 = sticky); otherwise

{agentwire_dev-1.65.1 → agentwire_dev-1.65.2}/agentwire/worktree.py

@@ -309,6 +309,39 @@ def remove_worktree(project_path: Path, worktree_path: Path, *, force: bool = Tr
     return False, (result.stderr or result.stdout).strip()
 
 
+def is_registered_worktree(project_path: Path, worktree_path: Path) -> bool:
+    """Does git's own worktree registry (still) know about ``worktree_path``?
+
+    A directory can outlive its registration — e.g. `git worktree remove`
+    succeeded on a prior teardown attempt but the `rm -rf` half crashed
+    before clearing a build-tool cache dir left inside, or the admin file
+    under `.git/worktrees/` was pruned independently. In that state git
+    reports "fatal: ... is not a working tree" for every future removal
+    attempt, forever — this lets a caller distinguish that from a real
+    registered worktree that `remove --force` merely failed to clear. It
+    says nothing about whether the directory holds valuable content — that
+    judgment (e.g. "orphaned + unregistered is safe to hard-delete") belongs
+    to the caller, not this function.
+
+    Fails closed on an inconclusive read: if `git worktree list` itself
+    errors (corrupt repo, I/O, lock contention), that's reported as
+    registered rather than not — a caller gating a destructive action on
+    this should default to "assume real" when unsure, not "assume orphan".
+    """
+    result = subprocess.run(
+        ["git", "worktree", "list", "--porcelain"],
+        cwd=project_path, capture_output=True, text=True,
+    )
+    if result.returncode != 0:
+        return True
+    target = str(worktree_path.resolve())
+    for line in result.stdout.splitlines():
+        if line.startswith("worktree "):
+            if str(Path(line[len("worktree "):]).resolve()) == target:
+                return True
+    return False
+
+
 def worktree_status(worktree_path: Path) -> dict:
     """Read-only git status for a worktree. Local git only — no network, no gh.
 

{agentwire_dev-1.65.1 → agentwire_dev-1.65.2}/tests/integration/test_worktree_cmd.py

@@ -643,6 +643,38 @@ def test_remove_fails_loudly_when_dir_survives(tmp_path, monkeypatch, wt_env, ca
     assert payload["error"]
 
 
+def test_remove_hard_deletes_unregistered_orphan_directory(tmp_path, monkeypatch, wt_env, capsys):
+    """A directory git no longer registers as a worktree at all (its
+    `.git/worktrees/<name>` admin entry is gone, e.g. from a prior teardown
+    that crashed mid-way) must not get stuck failing `git worktree remove`
+    forever — since git has nothing left to lose, the leftover directory is
+    hard-deleted and teardown proceeds and succeeds."""
+    import shutil
+
+    _, clone = _origin_and_clone(tmp_path, default_branch="develop")
+    wt_dir = tmp_path / "worktrees"
+    cfg = _config(wt_dir)
+    assert _run(monkeypatch, cfg, name="orphan", project=str(clone)) == 0
+    wt_path = wt_dir / "clone-repo" / "orphan"
+    assert wt_path.exists()
+
+    # Simulate the crashed-partial-teardown state: git's own registration is
+    # gone, but the directory (with leftover content) survives on disk.
+    shutil.rmtree(clone / ".git" / "worktrees" / "orphan")
+    (wt_path / "stale-cache-file").write_text("leftover\n")
+
+    capsys.readouterr()
+    rc = _run(monkeypatch, cfg, name="orphan", project=str(clone), remove=True)
+    assert rc == 0
+    assert not wt_path.exists()
+    assert reg.entries(clone.resolve()) == []
+
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["success"] is True
+    assert payload["worktree_removed"] is True
+    assert payload["hard_deleted_orphan"] is True
+
+
 def test_remove_kills_alive_session(tmp_path, monkeypatch, wt_env, capsys):
     _, clone = _origin_and_clone(tmp_path, default_branch="develop")
     wt_dir = tmp_path / "worktrees"

{agentwire_dev-1.65.1 → agentwire_dev-1.65.2}/tests/unit/test_mcp_tools_args.py

@@ -212,6 +212,35 @@ class TestVoiceTools:
         assert "parked" in result
 
 
+class TestNotifyUserArtifactParams:
+    """#822: notify_user's artifact_url/artifact_title params (#821) had zero
+    test coverage — cover the body it builds for /api/desktop/notification."""
+
+    @patch("agentwire.mcp_notify._portal_request")
+    def test_artifact_url_sets_artifact_body_with_default_title(self, mock_req):
+        from agentwire.mcp_notify import notify_user
+        mock_req.return_value = _success(id="n1", clients=1)
+        notify_user(text="ready", artifact_url="report.html")
+        body = mock_req.call_args[0][2]
+        assert body["artifact"] == {"url": "report.html", "title": "Artifact"}
+
+    @patch("agentwire.mcp_notify._portal_request")
+    def test_artifact_title_overrides_default(self, mock_req):
+        from agentwire.mcp_notify import notify_user
+        mock_req.return_value = _success(id="n1", clients=1)
+        notify_user(text="ready", artifact_url="report.html", artifact_title="Q3 Report")
+        body = mock_req.call_args[0][2]
+        assert body["artifact"] == {"url": "report.html", "title": "Q3 Report"}
+
+    @patch("agentwire.mcp_notify._portal_request")
+    def test_no_artifact_url_omits_artifact_body(self, mock_req):
+        from agentwire.mcp_notify import notify_user
+        mock_req.return_value = _success(id="n1", clients=1)
+        notify_user(text="plain toast", artifact_title="ignored without a url")
+        body = mock_req.call_args[0][2]
+        assert "artifact" not in body
+
+
 # ---------------------------------------------------------------------------
 # Desktop tools
 # ---------------------------------------------------------------------------

{agentwire_dev-1.65.1 → agentwire_dev-1.65.2}/tests/unit/test_portal_api.py

@@ -614,6 +614,35 @@ class TestApiNotify:
         assert data["clients"] == 2
 
 
+class TestArtifactUrlHash:
+    """#822: pins `_artifact_url_hash` (routes/desktop.py) against known
+    vectors, independently cross-checked in Node against its JS twin
+    (`artifactUrlHash` in static/js/desktop.js) — the two have no shared
+    source and no JS test harness exists in this repo, so this is the only
+    automated guard against the two silently drifting apart. If you change
+    the hash algorithm on either side, recompute vectors on the OTHER side
+    (e.g. `node -e "..."` mirroring this function) before touching this
+    test — a passing Python-only test proves nothing about JS parity."""
+
+    @pytest.mark.parametrize("url,expected", [
+        ("", "811c9dc5"),
+        ("a", "e40c292c"),
+        ("reports/jan.html", "7084fac5"),
+        ("reports-jan.html", "b5f6349b"),
+        ("https://example.com", "6fbc04d3"),
+        ("council-proj-minutes/index.html", "d569834e"),
+        ("日本語", "805f5ce7"),  # multi-byte UTF-8
+        ("🦉", "11131011"),  # astral/surrogate-pair UTF-8
+    ])
+    def test_pinned_vectors(self, url, expected):
+        from agentwire.routes.desktop import _artifact_url_hash
+        assert _artifact_url_hash(url) == expected
+
+    def test_distinct_urls_that_collided_under_the_old_slug_now_differ(self):
+        from agentwire.routes.desktop import _artifact_url_hash
+        assert _artifact_url_hash("reports/jan.html") != _artifact_url_hash("reports-jan.html")
+
+
 class TestApiDesktopNotification:
     async def test_toast_reports_client_count(self, portal_client):
         """#444: posting a toast reports how many dashboards saw it live (the
@@ -630,8 +659,10 @@ class TestApiDesktopNotification:
 
     async def test_artifact_notice_defaults(self, portal_client):
         """#817: an artifact notice needs no text (synthesized from the title),
-        derives the frontend's url-slug window id, and defaults to sticky —
-        an unclicked deliverable must never silently fade."""
+        derives the frontend's hash-based window id (#822 — a lossy
+        char-substitution slug let distinct URLs collide onto the same id),
+        and defaults to sticky — an unclicked deliverable must never
+        silently fade."""
         client, server = portal_client
         server.broadcast_dashboard = AsyncMock()
         resp = await client.post("/api/desktop/notification", json={
@@ -645,9 +676,27 @@ class TestApiDesktopNotification:
         assert notice["artifact"] == {
             "url": "council-proj-minutes/index.html",
             "title": "Council minutes — proj",
-            "artifact_id": "artifact-council-proj-minutes-index-html",
+            "artifact_id": "artifact-d569834e",
         }
 
+    async def test_artifact_id_does_not_collide_across_similar_urls(self, portal_client):
+        """#822: the fallback id used to be a lossy char-substitution slug —
+        "reports/jan.html" and "reports-jan.html" both became
+        "artifact-reports-jan-html", so a new artifact could dedup-clobber a
+        different still-pending one. A hash of the full url doesn't collide
+        on this pair, so both notices coexist."""
+        client, server = portal_client
+        server.broadcast_dashboard = AsyncMock()
+        await client.post("/api/desktop/notification", json={
+            "artifact": {"url": "reports/jan.html", "title": "Jan (nested)"},
+        })
+        await client.post("/api/desktop/notification", json={
+            "artifact": {"url": "reports-jan.html", "title": "Jan (flat)"},
+        })
+        assert len(server.active_notifications) == 2
+        ids = {n["artifact"]["artifact_id"] for n in server.active_notifications.values()}
+        assert len(ids) == 2
+
     async def test_artifact_requires_url(self, portal_client):
         client, server = portal_client
         server.broadcast_dashboard = AsyncMock()
@@ -667,6 +716,23 @@ class TestApiDesktopNotification:
             })
         assert len(server.active_notifications) == 1
 
+    async def test_two_distinct_artifact_notices_coexist(self, portal_client):
+        """Two different concurrent unclicked artifact deliverables must both
+        stay pending — dedup keys on artifact_id, so distinct artifacts must
+        never clobber each other the way a same-id re-render intentionally
+        does above."""
+        client, server = portal_client
+        server.broadcast_dashboard = AsyncMock()
+        await client.post("/api/desktop/notification", json={
+            "artifact": {"url": "report-a.html", "title": "Report A"},
+        })
+        await client.post("/api/desktop/notification", json={
+            "artifact": {"url": "report-b.html", "title": "Report B"},
+        })
+        assert len(server.active_notifications) == 2
+        titles = sorted(n["artifact"]["title"] for n in server.active_notifications.values())
+        assert titles == ["Report A", "Report B"]
+
     async def test_session_sweep_spares_artifact_notices(self, portal_client):
         """The one-toast-per-session replacement must not eat a pending
         artifact notice tagged with the same session — seeing the session

{agentwire_dev-1.65.1 → agentwire_dev-1.65.2}/tests/unit/test_worktree.py

@@ -12,6 +12,7 @@ from agentwire.worktree import (
     git_common_dir,
     git_root,
     is_git_repo,
+    is_registered_worktree,
     is_valid_branch_name,
     parse_session_name,
     remove_worktree,
@@ -303,3 +304,45 @@ class TestRemoveWorktree:
         removed, error = remove_worktree(not_repo, tmp_path / "wherever")
         assert removed is False
         assert error
+
+
+# --- is_registered_worktree ---
+
+class TestIsRegisteredWorktree:
+    def test_true_for_a_live_worktree(self, tmp_path):
+        repo, _ = _make_repo(tmp_path)
+        wt = tmp_path / "repo-worktrees" / "feature"
+        assert ensure_worktree(repo, "feature", wt)
+        assert is_registered_worktree(repo, wt) is True
+
+    def test_false_once_gits_own_admin_dir_is_gone(self, tmp_path):
+        """A directory can outlive its registration (e.g. a prior teardown's
+        `rm` half crashed, or the admin dir was pruned independently) — once
+        git's `.git/worktrees/<name>` entry is gone, git itself no longer
+        considers this path a worktree, even though it still exists on disk.
+        """
+        import shutil
+
+        repo, _ = _make_repo(tmp_path)
+        wt = tmp_path / "repo-worktrees" / "feature"
+        assert ensure_worktree(repo, "feature", wt)
+
+        shutil.rmtree(repo / ".git" / "worktrees" / "feature")
+
+        assert wt.exists()  # leftover directory content untouched
+        assert is_registered_worktree(repo, wt) is False
+
+    def test_false_for_a_path_never_registered(self, tmp_path):
+        repo, _ = _make_repo(tmp_path)
+        bogus = tmp_path / "never-a-worktree"
+        bogus.mkdir()
+        assert is_registered_worktree(repo, bogus) is False
+
+    def test_fails_closed_toward_registered_when_git_errors(self, tmp_path):
+        """An inconclusive `git worktree list` (corrupt repo, I/O error, ...)
+        must not be read as "definitely orphaned" — a caller gating a
+        destructive hard-delete on this should default to treating it as a
+        real worktree when unsure, not as safe to discard."""
+        not_a_repo = tmp_path / "not-a-repo"
+        not_a_repo.mkdir()
+        assert is_registered_worktree(not_a_repo, tmp_path / "wherever") is True