fix: relocate daemon socket for deep paths (GH#1001)

On Unix systems, socket paths are limited to 104 chars (macOS) or 108 chars
(Linux). Deep workspace paths like /Volumes/External Drive/Dropbox/...
would exceed this limit and cause daemon startup failures.

This fix:
- Adds ShortSocketPath() which computes /tmp/beads-{hash}/bd.sock for
  paths that would exceed the limit
- Keeps backward compatibility: short paths still use .beads/bd.sock
- Updates daemon discovery to check both locations
- Uses SHA256 hash of canonical workspace path for unique directories

Closes GH#1001

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

internal/rpc/socket_path.go

@@ -0,0 +1,112 @@
+//go:build !windows
+
+package rpc
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+
+	"github.com/steveyegge/beads/internal/utils"
+)
+
+// MaxUnixSocketPath is the maximum length for Unix socket paths.
+// macOS has a 104-byte limit (including null terminator), Linux has 108.
+// We use 103 to be safe across platforms.
+const MaxUnixSocketPath = 103
+
+// ShortSocketPath returns a short socket path suitable for Unix sockets.
+// On Unix systems with socket path length limits (macOS: 104 chars, Linux: 108),
+// this function returns a path in /tmp/beads-{hash}/ to avoid exceeding limits.
+//
+// The hash is derived from the canonicalized workspace path, ensuring:
+// - Different workspaces get different socket directories
+// - The same workspace always gets the same hash (deterministic)
+// - Symlinks and case differences resolve to the same hash
+//
+// If the computed .beads/bd.sock path is short enough, it returns that directly.
+// This preserves backwards compatibility for workspaces with short paths.
+func ShortSocketPath(workspacePath string) string {
+	// Canonicalize path for consistent hashing across symlinks and case
+	canonical := utils.NormalizePathForComparison(workspacePath)
+	if canonical == "" {
+		canonical = workspacePath
+	}
+
+	// Compute the "natural" socket path in .beads/
+	naturalPath := filepath.Join(workspacePath, ".beads", "bd.sock")
+
+	// If natural path is short enough, use it (backwards compatible)
+	if len(naturalPath) <= MaxUnixSocketPath {
+		return naturalPath
+	}
+
+	// Path too long - use /tmp with hash
+	return shortSocketDir(canonical)
+}
+
+// shortSocketDir returns a socket path in /tmp/beads-{hash}/.
+// The hash is 8 hex characters derived from SHA256 of the workspace path.
+func shortSocketDir(canonicalPath string) string {
+	hash := sha256.Sum256([]byte(canonicalPath))
+	hashStr := hex.EncodeToString(hash[:4]) // 8 hex chars from 4 bytes
+
+	dir := filepath.Join(tmpDir(), "beads-"+hashStr)
+	return filepath.Join(dir, "bd.sock")
+}
+
+// tmpDir returns the appropriate temp directory for sockets.
+// On macOS, /tmp is a symlink to /private/tmp, but /tmp is shorter.
+func tmpDir() string {
+	if runtime.GOOS == "darwin" {
+		// On macOS, prefer /tmp over $TMPDIR which can be long
+		// (/var/folders/xx/xxxxxxxxxxxx/T/)
+		return "/tmp"
+	}
+	// On Linux and other Unix, use /tmp
+	return "/tmp"
+}
+
+// EnsureSocketDir creates the socket directory if it doesn't exist.
+// Returns the socket path (unchanged) and any error.
+// This should be called by the daemon before listening.
+func EnsureSocketDir(socketPath string) (string, error) {
+	dir := filepath.Dir(socketPath)
+
+	// Only create if it's a /tmp/beads-* directory
+	// Don't create .beads directories - those should exist
+	if strings.HasPrefix(dir, filepath.Join(tmpDir(), "beads-")) {
+		if err := os.MkdirAll(dir, 0700); err != nil {
+			return "", err
+		}
+	}
+
+	return socketPath, nil
+}
+
+// CleanupSocketDir removes the socket directory if it's in /tmp/beads-*.
+// This should be called when the daemon shuts down.
+func CleanupSocketDir(socketPath string) error {
+	dir := filepath.Dir(socketPath)
+
+	// Only remove if it's a /tmp/beads-* directory we created
+	if strings.HasPrefix(dir, filepath.Join(tmpDir(), "beads-")) {
+		// Remove socket file first
+		_ = os.Remove(socketPath)
+		// Remove directory (will fail if not empty, which is fine)
+		return os.Remove(dir)
+	}
+
+	// For .beads/ directories, just remove the socket file
+	return os.Remove(socketPath)
+}
+
+// NeedsShortPath returns true if the workspace path would result in a socket
+// path exceeding Unix limits.
+func NeedsShortPath(workspacePath string) bool {
+	naturalPath := filepath.Join(workspacePath, ".beads", "bd.sock")
+	return len(naturalPath) > MaxUnixSocketPath
+}

internal/rpc/socket_path_test.go

@@ -0,0 +1,159 @@
+//go:build !windows
+
+package rpc
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestShortSocketPath_ShortPath(t *testing.T) {
+	// Short paths should use the natural .beads/bd.sock location
+	workspacePath := "/tmp/myrepo"
+	socketPath := ShortSocketPath(workspacePath)
+
+	expected := filepath.Join(workspacePath, ".beads", "bd.sock")
+	if socketPath != expected {
+		t.Errorf("ShortSocketPath(%q) = %q, want %q", workspacePath, socketPath, expected)
+	}
+}
+
+func TestShortSocketPath_LongPath(t *testing.T) {
+	// Long paths should use /tmp/beads-{hash}/bd.sock
+	// Create a path that's definitely over 103 chars when .beads/bd.sock is added
+	longPath := "/Volumes/External Drive/Dropbox/Projects/Clients/Company/product-name-with-extra-long-name"
+	socketPath := ShortSocketPath(longPath)
+
+	// Should be relocated to /tmp
+	if !strings.HasPrefix(socketPath, "/tmp/beads-") {
+		t.Errorf("ShortSocketPath(%q) = %q, want path starting with /tmp/beads-", longPath, socketPath)
+	}
+
+	// Should end with bd.sock
+	if !strings.HasSuffix(socketPath, "/bd.sock") {
+		t.Errorf("ShortSocketPath(%q) = %q, want path ending with /bd.sock", longPath, socketPath)
+	}
+
+	// Path should be short enough
+	if len(socketPath) > MaxUnixSocketPath {
+		t.Errorf("ShortSocketPath(%q) = %q (len=%d), want len <= %d", longPath, socketPath, len(socketPath), MaxUnixSocketPath)
+	}
+}
+
+func TestShortSocketPath_Deterministic(t *testing.T) {
+	// Same workspace should always produce same socket path
+	workspacePath := "/Volumes/External Drive/Some/Long/Path/To/A/Repository"
+	path1 := ShortSocketPath(workspacePath)
+	path2 := ShortSocketPath(workspacePath)
+
+	if path1 != path2 {
+		t.Errorf("ShortSocketPath is not deterministic: %q != %q", path1, path2)
+	}
+}
+
+func TestShortSocketPath_DifferentWorkspaces(t *testing.T) {
+	// Different workspaces should produce different socket paths
+	workspace1 := "/Volumes/External/Project1/With/Long/Path/Here"
+	workspace2 := "/Volumes/External/Project2/With/Long/Path/Here"
+
+	path1 := ShortSocketPath(workspace1)
+	path2 := ShortSocketPath(workspace2)
+
+	if path1 == path2 {
+		t.Errorf("Different workspaces should produce different socket paths: both got %q", path1)
+	}
+}
+
+func TestNeedsShortPath(t *testing.T) {
+	tests := []struct {
+		name      string
+		workspace string
+		want      bool
+	}{
+		{
+			name:      "short path",
+			workspace: "/tmp/myrepo",
+			want:      false,
+		},
+		{
+			name:      "medium path",
+			workspace: "/Users/john/projects/myrepo",
+			want:      false,
+		},
+		{
+			name:      "long path exceeding limit",
+			workspace: "/Volumes/External Drive/Dropbox/Projects/Clients/Company/product-name-with-extra-characters-to-exceed-limit",
+			want:      true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := NeedsShortPath(tt.workspace)
+			if got != tt.want {
+				naturalPath := filepath.Join(tt.workspace, ".beads", "bd.sock")
+				t.Errorf("NeedsShortPath(%q) = %v, want %v (natural path len=%d, limit=%d)",
+					tt.workspace, got, tt.want, len(naturalPath), MaxUnixSocketPath)
+			}
+		})
+	}
+}
+
+func TestEnsureSocketDir(t *testing.T) {
+	// Test creating a /tmp/beads-* directory
+	// Manually simulate the condition where we need to create the directory
+	// by using a path format that matches our pattern
+	testSocketPath := filepath.Join("/tmp", "beads-testxyz", "bd.sock")
+
+	result, err := EnsureSocketDir(testSocketPath)
+	if err != nil {
+		t.Fatalf("EnsureSocketDir failed: %v", err)
+	}
+
+	if result != testSocketPath {
+		t.Errorf("EnsureSocketDir returned %q, want %q", result, testSocketPath)
+	}
+
+	// Clean up
+	_ = os.RemoveAll(filepath.Dir(testSocketPath))
+}
+
+func TestCleanupSocketDir(t *testing.T) {
+	// Create a test directory in /tmp
+	testDir := filepath.Join("/tmp", "beads-cleanup-test")
+	if err := os.MkdirAll(testDir, 0700); err != nil {
+		t.Fatalf("Failed to create test dir: %v", err)
+	}
+
+	socketPath := filepath.Join(testDir, "bd.sock")
+	if err := os.WriteFile(socketPath, []byte("test"), 0600); err != nil {
+		t.Fatalf("Failed to create test socket file: %v", err)
+	}
+
+	// Clean up
+	if err := CleanupSocketDir(socketPath); err != nil {
+		t.Errorf("CleanupSocketDir failed: %v", err)
+	}
+
+	// Directory should be removed
+	if _, err := os.Stat(testDir); !os.IsNotExist(err) {
+		t.Errorf("Directory %s should have been removed", testDir)
+		_ = os.RemoveAll(testDir) // Clean up for next run
+	}
+}
+
+func TestShortSocketPath_EdgeCase_ExactLimit(t *testing.T) {
+	// Test a path that's exactly at the limit
+	// .beads/bd.sock adds 15 characters
+	// So a workspace path of 88 chars + 15 = 103 (exactly at limit)
+	workspace := strings.Repeat("x", 88)
+	socketPath := ShortSocketPath(workspace)
+
+	// Should use natural path since it's exactly at the limit
+	expected := filepath.Join(workspace, ".beads", "bd.sock")
+	if socketPath != expected {
+		t.Errorf("Path at exact limit should use natural path.\nGot: %q\nWant: %q\nLen: %d", socketPath, expected, len(expected))
+	}
+}

internal/rpc/socket_path_windows.go

@@ -0,0 +1,35 @@
+//go:build windows
+
+package rpc
+
+import (
+	"os"
+	"path/filepath"
+)
+
+// MaxUnixSocketPath is not applicable on Windows (uses TCP).
+// Kept for API compatibility.
+const MaxUnixSocketPath = 103
+
+// ShortSocketPath returns the socket path for Windows.
+// Windows uses TCP instead of Unix sockets, so path length is not a concern.
+// The "socket path" is actually a file containing the TCP endpoint info.
+func ShortSocketPath(workspacePath string) string {
+	return filepath.Join(workspacePath, ".beads", "bd.sock")
+}
+
+// EnsureSocketDir is a no-op on Windows since the .beads directory
+// should already exist.
+func EnsureSocketDir(socketPath string) (string, error) {
+	return socketPath, nil
+}
+
+// CleanupSocketDir removes the socket file on Windows.
+func CleanupSocketDir(socketPath string) error {
+	return os.Remove(socketPath)
+}
+
+// NeedsShortPath always returns false on Windows since TCP is used.
+func NeedsShortPath(workspacePath string) bool {
+	return false
+}