arrayview 0.29.0__tar.gz → 0.29.1__tar.gz

{arrayview-0.29.0 → arrayview-0.29.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arrayview
-Version: 0.29.0
+Version: 0.29.1
 Summary: Fast multi-dimensional array viewer
 Project-URL: Home, https://github.com/oscarvanderheide/arrayview
 Project-URL: Source, https://github.com/oscarvanderheide/arrayview

arrayview-0.29.1/docs/vscode-window-routing-plan.md

@@ -0,0 +1,37 @@
+# VS Code Window Routing Plan
+
+## Problem
+
+ArrayView can open the viewer tab in the wrong VS Code window when multiple
+local windows and multiple remote/tunnel windows are active. The unsafe cases
+are the ones where Python cannot prove the originating window and falls back to
+writing multiple signal files or a shared signal file.
+
+## Contract
+
+- An exact `ARRAYVIEW_WINDOW_ID` wins when its registration exists.
+- A missing or stale `ARRAYVIEW_WINDOW_ID` with multiple active registrations
+  fails closed with a diagnostic.
+- PID ancestry and IPC hook matching are allowed only when they identify a
+  single window.
+- tmux client fallback is allowed only when all attached clients for the current
+  tmux session report the same `ARRAYVIEW_WINDOW_ID`.
+- File-explorer opens launched by the extension keep using the extension's own
+  `ARRAYVIEW_WINDOW_ID`.
+
+## Implementation Slice
+
+- Tighten `src/arrayview/_vscode_signal.py` window selection.
+- Add focused lifecycle tests for local ambiguity, stale exact IDs, exact-ID
+  ownership, and tmux multi-client ambiguity.
+- Avoid changing `_app.py` or the viewer frontend.
+
+## Manual Verification Targets
+
+- Local VS Code terminal, one window: opens in that window.
+- Local VS Code terminal, several windows: stale/missing exact ID prints a
+  diagnostic instead of opening elsewhere.
+- Remote/tunnel terminal, several windows: exact ID opens the matching window;
+  stale/missing ID fails closed.
+- File explorer custom editor: spawned Python receives the extension window ID
+  and opens back into the same window.

{arrayview-0.29.0 → arrayview-0.29.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "arrayview"
-version = "0.29.0"
+version = "0.29.1"
 description = "Fast multi-dimensional array viewer"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.12"

{arrayview-0.29.0 → arrayview-0.29.1}/src/arrayview/_vscode_extension.py

@@ -44,7 +44,7 @@ def _vscode_app_bundle() -> str | None:
 
 _VSCODE_EXT_INSTALLED = False  # cached so we only check once per process
 _VSCODE_EXT_FRESH_INSTALL = False  # True if we just installed it this session
-_VSCODE_EXT_VERSION = "0.14.33"  # current bundled extension version
+_VSCODE_EXT_VERSION = "0.14.34"  # current bundled extension version
 
 def _bundled_vscode_vsix_version(vsix_path: str) -> str | None:
     """Return the bundled opener extension version recorded inside the VSIX."""

{arrayview-0.29.0 → arrayview-0.29.1}/src/arrayview/_vscode_signal.py

@@ -163,7 +163,11 @@ def _find_arrayview_window_id() -> str | None:
             pass
 
     # tmux: process tree is detached from VS Code terminal; check all session clients.
+    # Only accept the fallback if every attached client for this tmux session
+    # reports the same window ID. Returning the first client is unsafe when the
+    # same session is attached from multiple VS Code windows.
     if os.environ.get("TERM_PROGRAM") == "tmux":
+        tmux_window_ids: set[str] = set()
         try:
             r_sid = subprocess.run(
                 ["tmux", "display-message", "-p", "#{session_id}"],
@@ -187,7 +191,9 @@ def _find_arrayview_window_id() -> str | None:
                         with open(f"/proc/{client_pid}/environ", "rb") as fh:
                             for entry in fh.read().split(b"\0"):
                                 if entry.startswith(b"ARRAYVIEW_WINDOW_ID="):
-                                    return entry[len(b"ARRAYVIEW_WINDOW_ID="):].decode()
+                                    val = entry[len(b"ARRAYVIEW_WINDOW_ID="):].decode()
+                                    if val:
+                                        tmux_window_ids.add(val)
                     except Exception:
                         pass
                     # macOS: ps ewwww
@@ -198,11 +204,21 @@ def _find_arrayview_window_id() -> str | None:
                         )
                         for token in r.stdout.split():
                             if token.startswith("ARRAYVIEW_WINDOW_ID="):
-                                return token[len("ARRAYVIEW_WINDOW_ID="):]
+                                val = token[len("ARRAYVIEW_WINDOW_ID="):]
+                                if val:
+                                    tmux_window_ids.add(val)
                     except Exception:
                         pass
         except Exception:
             pass
+        if len(tmux_window_ids) == 1:
+            return next(iter(tmux_window_ids))
+        if len(tmux_window_ids) > 1:
+            _vprint(
+                "[ArrayView] signal: tmux clients report multiple "
+                f"ARRAYVIEW_WINDOW_ID values: {sorted(tmux_window_ids)}",
+                flush=True,
+            )
 
     return None
 
@@ -323,53 +339,8 @@ def _write_vscode_signal(payload: dict, delay: float = 0.0, skip_compat: bool =
                 except Exception:
                     uses_pid = env_wid.isdigit()
 
-                # Guard against stale ARRAYVIEW_WINDOW_ID: when the extension
-                # host restarts (e.g. tunnel reconnection), the old process may
-                # still be alive but is no longer connected to a VS Code client.
-                # Detect this by looking for a newer registration from the same
-                # server (same first ppid — the tunnel/server parent process).
-                # Only needed for PID-based IDs (fallbackId=True); hookTag IDs
-                # are unique per IPC socket and never go stale across restarts.
-                #
-                # Skip on macOS: all extension hosts are direct children of the
-                # same main Electron process (ppids[0] == Electron PID for every
-                # window), so the "same ppids[0]" heuristic matches ALL concurrent
-                # windows and incorrectly redirects signals to the wrong window.
-                # The stable window ID feature (v0.14.0+) already handles restart
-                # continuity on macOS via EnvironmentVariableCollection, making
-                # this stale-redirect unnecessary there.
-                if uses_pid and sys.platform != "darwin" and not _is_vscode_remote():
-                    _env_ts = _reg_data.get("ts", 0)
-                    _env_ppids = _reg_data.get("ppids", [])
-                    try:
-                        for _fname in os.listdir(signal_dir):
-                            if not (_fname.startswith("window-") and _fname.endswith(".json")):
-                                continue
-                            _other_wid = _fname[7:-5]
-                            if _other_wid == env_wid:
-                                continue
-                            with open(os.path.join(signal_dir, _fname)) as _f:
-                                _other = json.load(_f)
-                            _other_ts = _other.get("ts", 0)
-                            _other_ppids = _other.get("ppids", [])
-                            if (
-                                _other_ts > _env_ts
-                                and len(_env_ppids) >= 1
-                                and len(_other_ppids) >= 1
-                                and _env_ppids[0] == _other_ppids[0]
-                            ):
-                                _vprint(
-                                    f"[ArrayView] signal: ARRAYVIEW_WINDOW_ID={env_wid} is stale "
-                                    f"(newer registration {_other_wid} found), redirecting",
-                                    flush=True,
-                                )
-                                env_wid = _other_wid
-                                _reg_data = _other
-                                uses_pid = _other.get("fallbackId", False)
-                                _env_ts = _other_ts
-                    except Exception:
-                        pass
-
+                # Trust an exact window ID. Redirecting to a newer same-parent
+                # registration can silently open the tab in a live sibling window.
                 _prefix = "pid" if uses_pid else "ipc"
                 filenames = (f"open-request-{_prefix}-{env_wid}.json",)
                 targeted_via_env = True
@@ -410,33 +381,15 @@ def _write_vscode_signal(payload: dict, delay: float = 0.0, skip_compat: bool =
                         flush=True,
                     )
                 elif len(_all_windows) > 1:
-                    if _is_vscode_remote():
-                        print(
-                            "[ArrayView] VS Code tunnel window is ambiguous: "
-                            f"ARRAYVIEW_WINDOW_ID={env_wid!r} is not registered "
-                            f"and {len(_all_windows)} VS Code windows are active. "
-                            "Open a fresh terminal in the target VS Code window "
-                            "and run ArrayView again.",
-                            flush=True,
-                        )
-                        return False
-                    else:
-                        _wfiles = []
-                        for _fn in _all_windows:
-                            _wid = _fn[7:-5]
-                            _wfiles.append(
-                                f"open-request-pid-{_wid}.json"
-                                if _wid.isdigit()
-                                else f"open-request-ipc-{_wid}.json"
-                            )
-                        data["broadcast"] = True
-                        filenames = tuple(_wfiles)
-                        targeted_via_env = True
-                        _vprint(
-                            f"[ArrayView] signal: {len(_all_windows)} windows registered, "
-                            f"broadcasting with focus guard",
-                            flush=True,
-                        )
+                    print(
+                        "[ArrayView] VS Code window is ambiguous: "
+                        f"ARRAYVIEW_WINDOW_ID={env_wid!r} is not registered "
+                        f"and {len(_all_windows)} VS Code windows are active. "
+                        "Open a fresh terminal in the target VS Code window "
+                        "and run ArrayView again.",
+                        flush=True,
+                    )
+                    return False
                 # else: 0 windows — fall through to subsequent targeting
 
         if targeted_via_env:
@@ -491,10 +444,16 @@ def _write_vscode_signal(payload: dict, delay: float = 0.0, skip_compat: bool =
                         except Exception:
                             pass
                         if len(_wfiles) > 1:
-                            data["broadcast"] = True
-                        filenames = (
-                            tuple(_wfiles) if _wfiles else (_VSCODE_SIGNAL_FILENAME,)
-                        )
+                            print(
+                                "[ArrayView] VS Code window is ambiguous: "
+                                "no exact ARRAYVIEW_WINDOW_ID or PID match is available "
+                                f"and {len(_wfiles)} VS Code windows are active. "
+                                "Open a fresh terminal in the target VS Code window "
+                                "and run ArrayView again.",
+                                flush=True,
+                            )
+                            return False
+                        filenames = tuple(_wfiles) if _wfiles else (_VSCODE_SIGNAL_FILENAME,)
                     else:
                         filenames = (
                             _VSCODE_SIGNAL_FILENAME,
@@ -535,12 +494,17 @@ def _write_vscode_signal(payload: dict, delay: float = 0.0, skip_compat: bool =
                     except Exception:
                         pass
                     if len(window_files) > 1:
-                        # Mark as broadcast so extensions check focus before opening
-                        data["broadcast"] = True
+                        print(
+                            "[ArrayView] VS Code window is ambiguous: "
+                            "no exact ARRAYVIEW_WINDOW_ID or PID match is available "
+                            f"and {len(window_files)} VS Code windows are active. "
+                            "Open a fresh terminal in the target VS Code window "
+                            "and run ArrayView again.",
+                            flush=True,
+                        )
+                        return False
                     filenames = (
-                        tuple(window_files)
-                        if window_files
-                        else (_VSCODE_SIGNAL_FILENAME,)
+                        tuple(window_files) if window_files else (_VSCODE_SIGNAL_FILENAME,)
                     )
                 else:
                     # Not in VS Code terminal: use shared file
@@ -800,4 +764,3 @@ def _cleanup_zombie_registrations(verbose: bool = False) -> int:
                 pass
 
     return removed
-

{arrayview-0.29.0 → arrayview-0.29.1}/tests/test_lifecycle_contract.py

@@ -186,6 +186,123 @@ def test_vscode_tunnel_exact_window_id_is_not_redirected_to_newer_sibling(
     assert not (signal_dir / "open-request-pid-200.json").exists()
 
 
+def test_vscode_local_exact_window_id_is_not_redirected_to_newer_sibling(
+    monkeypatch, tmp_path
+):
+    import json
+    import arrayview._vscode_signal as signal
+
+    home = tmp_path / "home"
+    signal_dir = home / ".arrayview"
+    signal_dir.mkdir(parents=True)
+    monkeypatch.setenv("HOME", str(home))
+    monkeypatch.setattr(signal, "_is_vscode_remote", lambda: False)
+    monkeypatch.setattr(signal, "_find_arrayview_window_id", lambda: "100")
+
+    (signal_dir / "window-100.json").write_text(
+        json.dumps({"pid": 100, "ppids": [10], "fallbackId": True, "ts": 1})
+    )
+    (signal_dir / "window-200.json").write_text(
+        json.dumps({"pid": 200, "ppids": [10], "fallbackId": True, "ts": 2})
+    )
+
+    opened = signal._write_vscode_signal(
+        {"url": "http://localhost:8000/?sid=abc"},
+        skip_compat=True,
+    )
+
+    assert opened is True
+    assert (signal_dir / "open-request-pid-100.json").exists()
+    assert not (signal_dir / "open-request-pid-200.json").exists()
+
+
+def test_vscode_local_stale_window_id_with_multiple_windows_fails_closed(
+    monkeypatch, tmp_path, capsys
+):
+    import json
+    import arrayview._vscode_signal as signal
+
+    home = tmp_path / "home"
+    signal_dir = home / ".arrayview"
+    signal_dir.mkdir(parents=True)
+    monkeypatch.setenv("HOME", str(home))
+    monkeypatch.setattr(signal, "_is_vscode_remote", lambda: False)
+    monkeypatch.setattr(signal, "_find_arrayview_window_id", lambda: "stale")
+    monkeypatch.setattr(signal, "_find_current_vscode_window_id", lambda: None)
+
+    for wid in ("100", "200"):
+        (signal_dir / f"window-{wid}.json").write_text(
+            json.dumps({"pid": int(wid), "ppids": [10], "fallbackId": True})
+        )
+
+    opened = signal._write_vscode_signal(
+        {"url": "http://localhost:8000/?sid=abc"},
+        skip_compat=True,
+    )
+
+    assert opened is False
+    assert "VS Code window is ambiguous" in capsys.readouterr().out
+    assert not list(signal_dir.glob("open-request-*"))
+
+
+def test_vscode_local_missing_window_match_with_multiple_windows_fails_closed(
+    monkeypatch, tmp_path, capsys
+):
+    import json
+    import arrayview._vscode_signal as signal
+
+    home = tmp_path / "home"
+    signal_dir = home / ".arrayview"
+    signal_dir.mkdir(parents=True)
+    monkeypatch.setenv("HOME", str(home))
+    monkeypatch.setattr(signal, "_is_vscode_remote", lambda: False)
+    monkeypatch.setattr(signal, "_find_arrayview_window_id", lambda: None)
+    monkeypatch.setattr(signal, "_find_current_vscode_window_id", lambda: None)
+    monkeypatch.setattr("arrayview._platform._find_vscode_ipc_hook", lambda: None)
+    monkeypatch.setattr("arrayview._platform._in_vscode_terminal", lambda: True)
+
+    for wid in ("100", "200"):
+        (signal_dir / f"window-{wid}.json").write_text(
+            json.dumps({"pid": int(wid), "ppids": [10], "fallbackId": True})
+        )
+
+    opened = signal._write_vscode_signal(
+        {"url": "http://localhost:8000/?sid=abc"},
+        skip_compat=True,
+    )
+
+    assert opened is False
+    assert "VS Code window is ambiguous" in capsys.readouterr().out
+    assert not list(signal_dir.glob("open-request-*"))
+
+
+def test_tmux_multiple_window_ids_are_ambiguous(monkeypatch):
+    import arrayview._vscode_signal as signal
+
+    monkeypatch.delenv("ARRAYVIEW_WINDOW_ID", raising=False)
+    monkeypatch.setenv("TERM_PROGRAM", "tmux")
+    monkeypatch.setattr(signal, "get_ppid", lambda _pid: -1)
+
+    class _Result:
+        def __init__(self, stdout):
+            self.stdout = stdout
+
+    def _run(cmd, *args, **kwargs):
+        if cmd[:3] == ["tmux", "display-message", "-p"]:
+            return _Result("$1\n")
+        if cmd[:3] == ["tmux", "list-clients", "-t"]:
+            return _Result("111\n222\n")
+        if cmd[:3] == ["ps", "ewwww", "-p"]:
+            pid = cmd[-1]
+            wid = "win-a" if pid == "111" else "win-b"
+            return _Result(f"COMMAND ARRAYVIEW_WINDOW_ID={wid}\n")
+        return _Result("")
+
+    monkeypatch.setattr(signal.subprocess, "run", _run)
+
+    assert signal._find_arrayview_window_id() is None
+
+
 def test_transient_waiter_notices_quick_viewer_connect_close(monkeypatch):
     import arrayview._launcher as launcher
     import arrayview._session as session_mod

{arrayview-0.29.0 → arrayview-0.29.1}/uv.lock

@@ -198,7 +198,7 @@ wheels = [
 
 [[package]]
 name = "arrayview"
-version = "0.29.0"
+version = "0.29.1"
 source = { editable = "." }
 dependencies = [
     { name = "fastapi" },

{arrayview-0.29.0 → arrayview-0.29.1}/vscode-extension/extension.js

@@ -702,6 +702,7 @@ async function openInWebviewPanel(url, title, floating = false) {
     panel.webview.html = _viewerPanelHtml(url);
 
     _openPanels.set(url, panel);
+    const pingUrl = pingUrlFromViewerUrl(url);
     let panelDisposed = false;
     panel.onDidDispose(() => {
         panelDisposed = true;

{arrayview-0.29.0 → arrayview-0.29.1}/vscode-extension/package.json

@@ -2,7 +2,7 @@
   "name": "arrayview-opener",
   "displayName": "ArrayView Opener",
   "description": "Opens ArrayView in VS Code and can promote tunnel ports to public preview",
-  "version": "0.14.33",
+  "version": "0.14.34",
   "publisher": "arrayview",
   "license": "MIT",
   "icon": "icon.png",