fix: discover custom tmux sockets and fallback to alt-screen capture

Author: bma-d

docs/changelog/260222.md

@@ -45,3 +45,28 @@ Made Lisa socket discovery resilient to older `lisa` binaries that reject `--wit
 - Verify tmux-visualiser no longer shows `unknown flag: --with-next-action` in discovery errors.
 - Verify Lisa sessions still appear when using a newer Lisa build that supports `--with-next-action`.
 - Verify fallback path still returns zero errors when `lisa session list --all-sockets --json` succeeds but has no `items`.
+
+## 260222-22:44:19 - Improve Lisa socket coverage and alt-screen capture fallback
+
+### Summary
+Made tmux-visualiser reliably detect Lisa sessions across custom sockets and show pane output that lives on alternate screen buffers.
+
+### Changed
+- Changed Lisa discovery payload parsing to consume `items[].socketPath` when provided, with project-root fallback for older payloads.
+- Changed process-table socket discovery to include all active `tmux -S` sockets rather than filtering to `lisa-*` names.
+
+### Fixed
+- Fixed missed Lisa sessions when runtime socket naming/location does not match canonical `lisa-tmux-*` patterns.
+- Fixed blank captures for sessions that render primarily in alternate screen buffers by falling back to `capture-pane -a`.
+
+### Files
+- `src/sockets.go`
+- `src/state.go`
+- `src/socket_test.go`
+- `docs/changelog/260222.md`
+
+### QA Notes
+- Verify sessions on custom socket names still appear in the visualiser.
+- Verify sessions discovered via `lisa session list --all-sockets --with-next-action --json` use explicit `socketPath` when present.
+- Verify panes that previously looked empty now render via alternate-screen fallback.
+- Verify regression suite: `go test ./src`.

src/socket_test.go

@@ -441,6 +441,47 @@ func TestListLisaSocketPathsFromLISAOldPayloadWithoutItemsReturnsEmpty(t *testin
 	}
 }
 
+func TestListLisaSocketPathsFromLISAUsesSocketPathFieldWhenPresent(t *testing.T) {
+	cfg := config{cmdTimeout: 2 * time.Second}
+	stubLisaSessionList(t, func(_ context.Context, _ bool) ([]byte, error) {
+		return []byte(`{"items":[{"projectRoot":"/tmp/proj-a","socketPath":"/tmp/custom-a.sock"},{"projectRoot":"/tmp/proj-b"}]}`), nil
+	})
+	got, err := listLisaSocketPathsFromLISA(cfg)
+	if err != nil {
+		t.Fatalf("listLisaSocketPathsFromLISA err: %v", err)
+	}
+	rootB := canonicalProjectRoot("/tmp/proj-b")
+	want := []string{
+		"/tmp/custom-a.sock",
+		tmuxSocketPathForProjectRoot(rootB),
+		tmuxLegacySocketPathForProjectRoot(rootB),
+	}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("got = %v, want %v", got, want)
+	}
+}
+
+func TestListLisaSocketPathsFromProcessTableIncludesNonLisaNamedSockets(t *testing.T) {
+	origList := listProcessCommandsFn
+	t.Cleanup(func() {
+		listProcessCommandsFn = origList
+	})
+	listProcessCommandsFn = func() ([]string, error) {
+		return []string{
+			"tmux -S /tmp/custom.sock list-sessions",
+			"tmux -S /tmp/lisa-a.sock list-sessions",
+		}, nil
+	}
+	got, err := listLisaSocketPathsFromProcessTable()
+	if err != nil {
+		t.Fatalf("listLisaSocketPathsFromProcessTable err: %v", err)
+	}
+	want := []string{"/tmp/custom.sock", "/tmp/lisa-a.sock"}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("got = %v, want %v", got, want)
+	}
+}
+
 func TestExtractTmuxSocketPathsFromCommands(t *testing.T) {
 	commands := []string{
 		"/opt/homebrew/bin/tmux -S /tmp/lisa-a.sock new -d",
@@ -608,6 +649,40 @@ func TestPaneQualifiedKey(t *testing.T) {
 	}
 }
 
+func TestCapturePaneFallsBackToAlternateScreen(t *testing.T) {
+	origRun := runTmuxOnSocketFn
+	t.Cleanup(func() {
+		runTmuxOnSocketFn = origRun
+	})
+
+	calls := make([]string, 0, 2)
+	runTmuxOnSocketFn = func(_ context.Context, _ config, socket string, args ...string) (string, error) {
+		calls = append(calls, socket+"|"+strings.Join(args, " "))
+		if len(args) == 0 || args[0] != "capture-pane" {
+			return "", errors.New("unexpected command")
+		}
+		if len(args) > 1 && args[1] == "-a" {
+			return "alt-line-1\nalt-line-2\n", nil
+		}
+		return "\n", nil
+	}
+
+	lines, err := capturePane(context.Background(), config{}, "/tmp/test.sock", "%1", 80)
+	if err != nil {
+		t.Fatalf("capturePane err: %v", err)
+	}
+	want := []string{"alt-line-1", "alt-line-2"}
+	if !reflect.DeepEqual(lines, want) {
+		t.Fatalf("lines = %v, want %v", lines, want)
+	}
+	if len(calls) != 2 {
+		t.Fatalf("calls len = %d", len(calls))
+	}
+	if !strings.Contains(calls[1], "capture-pane -a -t %1 -p -e -S -80") {
+		t.Fatalf("expected alternate-screen capture fallback, got %q", calls[1])
+	}
+}
+
 func TestListSessionsOnSocketAllPanes(t *testing.T) {
 	socketPath := "/tmp/test-all-panes.sock"
 

src/sockets.go

@@ -7,8 +7,8 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-	"os/exec"
 	"os"
+	"os/exec"
 	"path/filepath"
 	"sort"
 	"strings"
@@ -193,14 +193,7 @@ func listLisaSocketPathsFromProcessTable() ([]string, error) {
 	if err != nil {
 		return nil, err
 	}
-	paths := extractTmuxSocketPathsFromCommands(commands)
-	out := make([]string, 0, len(paths))
-	for _, path := range paths {
-		if isLikelyLisaSocketPath(path) {
-			out = append(out, path)
-		}
-	}
-	return out, nil
+	return extractTmuxSocketPathsFromCommands(commands), nil
 }
 
 func listProcessCommands() ([]string, error) {
@@ -274,19 +267,11 @@ func listLisaSocketPathsFromLISA(cfg config) ([]string, error) {
 		return nil, fmt.Errorf("lisa list failed: %s", strings.TrimSpace(string(out)))
 	}
 
-	projectRoots, err := lisaProjectRootsFromListPayload(out)
+	socketPaths, err := lisaSocketPathsFromListPayload(out)
 	if err != nil {
 		return nil, fmt.Errorf("lisa list invalid json")
 	}
-	paths := make([]string, 0, len(projectRoots)*2)
-	for _, root := range projectRoots {
-		paths = append(paths, tmuxSocketPathForProjectRoot(root))
-		legacy := tmuxLegacySocketPathForProjectRoot(root)
-		if legacy != "" && legacy != paths[len(paths)-1] {
-			paths = append(paths, legacy)
-		}
-	}
-	return dedupePaths(paths), nil
+	return socketPaths, nil
 }
 
 func runLisaSessionList(ctx context.Context, withNextAction bool) ([]byte, error) {
@@ -317,24 +302,34 @@ func lisaUnknownWithNextActionError(out []byte) bool {
 	return strings.Contains(lower, "unknown flag") && strings.Contains(lower, "--with-next-action")
 }
 
-func lisaProjectRootsFromListPayload(out []byte) ([]string, error) {
+func lisaSocketPathsFromListPayload(out []byte) ([]string, error) {
 	var payload struct {
 		Items []struct {
 			ProjectRoot string `json:"projectRoot"`
+			SocketPath  string `json:"socketPath"`
 		} `json:"items"`
 	}
 	if err := json.Unmarshal(out, &payload); err != nil {
 		return nil, err
 	}
-	roots := make([]string, 0, len(payload.Items))
+	paths := make([]string, 0, len(payload.Items)*2)
 	for _, item := range payload.Items {
+		socketPath := strings.TrimSpace(item.SocketPath)
+		if socketPath != "" {
+			paths = append(paths, filepath.Clean(socketPath))
+			continue
+		}
 		root := canonicalProjectRoot(item.ProjectRoot)
 		if root == "" {
 			continue
 		}
-		roots = append(roots, root)
+		paths = append(paths, tmuxSocketPathForProjectRoot(root))
+		legacy := tmuxLegacySocketPathForProjectRoot(root)
+		if legacy != "" {
+			paths = append(paths, legacy)
+		}
 	}
-	return dedupePaths(roots), nil
+	return dedupePaths(paths), nil
 }
 
 func canonicalProjectRoot(projectRoot string) string {
@@ -408,14 +403,6 @@ func preferredTmuxSocketDir() string {
 	return filepath.Clean(tmp)
 }
 
-func isLikelyLisaSocketPath(path string) bool {
-	base := strings.ToLower(filepath.Base(strings.TrimSpace(path)))
-	if base == "lisa-codex-nosb.sock" {
-		return true
-	}
-	return strings.HasPrefix(base, "lisa-") && strings.HasSuffix(base, ".sock")
-}
-
 func makeSocketTarget(path string) socketTarget {
 	return socketTarget{
 		path: path,

src/state.go

@@ -301,12 +301,42 @@ func capturePane(ctx context.Context, cfg config, socketPath string, paneID stri
 	if err != nil {
 		return nil, err
 	}
-	if out == "" {
+
+	primary := normalizeCaptureOutput(out)
+	if hasVisibleCapture(primary) {
+		return primary, nil
+	}
+
+	altOut, altErr := runTmuxOnSocketFn(ctx, cfg, socketPath, "capture-pane", "-a", "-t", paneID, "-p", "-e", "-S", rangeArg)
+	if altErr == nil {
+		alt := normalizeCaptureOutput(altOut)
+		if len(alt) > 0 {
+			return alt, nil
+		}
+	}
+
+	if len(primary) == 0 {
 		return []string{"(empty)"}, nil
 	}
+	return primary, nil
+}
+
+func normalizeCaptureOutput(out string) []string {
+	if out == "" {
+		return []string{}
+	}
 	result := strings.Split(out, "\n")
 	if len(result) > 0 && result[len(result)-1] == "" {
 		result = result[:len(result)-1]
 	}
-	return result, nil
+	return result
+}
+
+func hasVisibleCapture(lines []string) bool {
+	for _, line := range lines {
+		if strings.TrimSpace(line) != "" {
+			return true
+		}
+	}
+	return false
 }