fix: store separate socket proxies for socket based tooling

Author: zekker6

CHANGELOG.md

@@ -4,6 +4,11 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased](https://github.com/zekker6/devsandbox/compare/v0.17.3...HEAD)
 
+### Fixed
+
+- **A second session for the same project no longer breaks a running session's notifications, Docker access, and kitty remote control.** The portal, Docker, and kitty proxies each created their unix socket at a path keyed only on the project (`<sandbox home>/.dbus-proxy/bus`, `<sandbox home>/docker.sock`, `<sandbox home>/.kitty.sock`), but sandbox home is shared by every session for that project. Starting a second session unlinked the live session's socket and re-created it, and that session's exit deleted the path outright - leaving the first session with `DBUS_SESSION_BUS_ADDRESS`, `DOCKER_HOST`, and `KITTY_LISTEN_ON` pointing at a path that no longer existed. `notify-send` failed with `Could not connect: No such file or directory` for the rest of the session, with no way to recover short of restarting it. Each session's sockets now live in a directory private to the owning process (`<sandbox home>/.run/<pid>/`), so concurrent sessions cannot disturb each other; directories left by sessions that are gone are reclaimed on the next start. `DBUS_SESSION_BUS_ADDRESS` is unchanged; `DOCKER_HOST` and `KITTY_LISTEN_ON` now point at `$HOME/.run/<pid>/docker.sock` and `$HOME/.run/<pid>/kitty.sock` inside the sandbox.
+- **A socket path too long for the kernel is now reported as such.** The proxy socket paths above sit under an already-long sandbox home, and `bind(2)` rejects anything past 107 bytes (103 on macOS) with a bare `invalid argument` - which the portal surfaced only as an opaque "proxy socket not created" timeout. The portal, Docker, and kitty proxies now fail with the path, its length, the limit, and the remedy (a shorter project directory name).
+
 ## [v0.17.3](https://github.com/zekker6/devsandbox/releases/tag/v0.17.3) - 2026-06-24
 
 ### Added

docs/tools.md

@@ -520,7 +520,7 @@ socket = "/path/to/docker.sock"
 
 ### How It Works
 
-1. A Unix socket proxy is created at `$HOME/docker.sock` inside the sandbox
+1. A Unix socket proxy is created at `$HOME/.run/<pid>/docker.sock` inside the sandbox, where `<pid>` is the devsandbox process that owns the session. Sandbox home is shared by every session for the project, so the socket is kept per-session to stop a second session from unlinking a live one's socket.
 2. The `DOCKER_HOST` environment variable is set to point to this socket
 3. All requests are filtered before being forwarded to the host Docker socket
 4. Write operations are blocked with an HTTP 403 error
@@ -609,14 +609,14 @@ extra_capabilities = ["list_owned"]    # additive only; launch_* entries are rej
 
 | Resource | Mode | Purpose |
 |----------|------|---------|
-| Proxy socket (`$HOME/.kitty.sock`) | read-write (proxy is local to the sandbox home) | kitty remote-control via the filtering proxy |
+| Proxy socket (`$HOME/.run/<pid>/kitty.sock`) | read-write (proxy is local to the sandbox home) | kitty remote-control via the filtering proxy |
 | `kitty` binary | read-only | CLI for `kitty @ launch`, `kitty @ ls`, etc. |
 
 The host's real kitty socket is **not** bind-mounted into the sandbox.
 
 ### Environment Variables
 
-- `KITTY_LISTEN_ON` - rewritten to `unix:$HOME/.kitty.sock` inside the sandbox. Host value is never exposed.
+- `KITTY_LISTEN_ON` - rewritten to `unix:$HOME/.run/<pid>/kitty.sock` inside the sandbox, where `<pid>` is the devsandbox process owning the session. Host value is never exposed.
 - `KITTY_WINDOW_ID`, `KITTY_PID` - passed through from host (read-only signals about the host pane).
 
 ### Limitations
@@ -698,7 +698,7 @@ notifications = false
 4. `DBUS_SESSION_BUS_ADDRESS` inside the sandbox points to the proxy socket
 5. A `.flatpak-info` file is created so `xdg-desktop-portal` recognizes the sandbox as a valid Flatpak-like application
 
-The proxy is started before the sandbox launches and stopped when the sandbox exits.
+The proxy is started before the sandbox launches and stopped when the sandbox exits. Each session runs its own proxy with its own socket on the host, so starting or exiting a second session for the same project leaves a running session's notifications working.
 
 ### Checking Portal Status
 

internal/isolator/docker_test.go

@@ -1177,12 +1177,12 @@ func TestGetToolBindings_DockerHostRemapped(t *testing.T) {
 		t.Fatal("DOCKER_HOST environment variable not found in tool bindings")
 	}
 
-	// DOCKER_HOST should point to /home/sandboxuser, not host homeDir
+	// DOCKER_HOST should point under /home/sandboxuser, not host homeDir
 	if strings.Contains(dockerHost, "/home/testuser") {
 		t.Errorf("DOCKER_HOST should not contain host homeDir, got: %s", dockerHost)
 	}
-	if !strings.Contains(dockerHost, "/home/sandboxuser/docker.sock") {
-		t.Errorf("DOCKER_HOST should point to /home/sandboxuser/docker.sock, got: %s", dockerHost)
+	if !strings.HasPrefix(dockerHost, "unix:///home/sandboxuser/") || !strings.HasSuffix(dockerHost, "/docker.sock") {
+		t.Errorf("DOCKER_HOST should point to a docker.sock under /home/sandboxuser, got: %s", dockerHost)
 	}
 }
 

internal/sandbox/tools/active.go

@@ -43,6 +43,12 @@ func (r *ActiveToolsRunner) start(ctx context.Context) (bool, error) {
 	home := r.cfg.HomeDir
 	sandboxHome := r.cfg.SandboxHome
 
+	// Reclaim socket dirs from runs that are gone. Must happen before any tool
+	// creates its sockets, so that a PID reused from a crashed run starts clean.
+	if _, err := cleanupStaleRunDirs(sandboxHome); err != nil && r.logger != nil {
+		r.logger.LogErrorf("tools", "clean stale run dirs: %v", err)
+	}
+
 	// Find and start active tools
 	for _, tool := range Available(home) {
 		at, ok := tool.(ActiveTool)

internal/sandbox/tools/docker.go

@@ -2,6 +2,7 @@ package tools
 
 import (
 	"context"
+	"fmt"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -93,9 +94,11 @@ func (d *Docker) Available(homeDir string) bool {
 }
 
 // socketPath returns the path where the proxy socket will be created.
-// It's placed in sandboxHome so it's visible inside the sandbox.
+// It's placed in sandboxHome so it's visible inside the sandbox, under this
+// process's run directory so that a concurrent session for the same project
+// cannot unlink a live socket.
 func (d *Docker) socketPath(sandboxHome string) string {
-	return filepath.Join(sandboxHome, dockerSocketName)
+	return filepath.Join(runDir(sandboxHome), dockerSocketName)
 }
 
 // Configure implements ToolWithConfig.
@@ -131,10 +134,10 @@ func (d *Docker) Environment(homeDir, sandboxHome string) []EnvVar {
 		return nil
 	}
 
-	// The socket is created at sandboxHome/docker.sock on the host,
-	// but sandboxHome is mounted at $HOME inside the sandbox.
-	// So we return $HOME/docker.sock as the path visible inside the sandbox.
-	sandboxVisiblePath := filepath.Join(homeDir, dockerSocketName)
+	// The socket is created under sandboxHome on the host, but sandboxHome is
+	// mounted at $HOME inside the sandbox, so the same relative path under
+	// homeDir is what the sandbox sees.
+	sandboxVisiblePath := filepath.Join(runDir(homeDir), dockerSocketName)
 	return []EnvVar{
 		{Name: "DOCKER_HOST", Value: "unix://" + sandboxVisiblePath},
 	}
@@ -153,7 +156,15 @@ func (d *Docker) Start(ctx context.Context, homeDir, sandboxHome string) error {
 	notice.Warn("Docker socket proxy enabled. The sandbox can access ALL existing Docker containers on this host.")
 	notice.Warn("This might allow accessing host resources. Ensure you trust the sandbox content.")
 
+	if _, err := ensureRunDir(sandboxHome); err != nil {
+		return fmt.Errorf("docker: %w", err)
+	}
+
 	listenPath := d.socketPath(sandboxHome)
+	if err := checkSocketPath(listenPath); err != nil {
+		return fmt.Errorf("docker: %w", err)
+	}
+
 	d.proxy = dockerproxy.New(d.hostSocket, listenPath)
 	if d.logger != nil {
 		d.proxy.SetLogger(d.logger)

internal/sandbox/tools/docker_test.go

@@ -4,6 +4,8 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
+	"strconv"
+	"strings"
 	"testing"
 )
 
@@ -96,11 +98,33 @@ func TestDocker_Environment_Enabled(t *testing.T) {
 		t.Errorf("expected DOCKER_HOST, got %q", env[0].Name)
 	}
 
-	// Socket path is homeDir/docker.sock (where sandboxHome is mounted inside sandbox)
-	expected := "unix://" + homeDir + "/docker.sock"
+	// Socket path is under homeDir, where sandboxHome is mounted inside the
+	// sandbox, and mirrors the host-side path under sandboxHome.
+	expected := "unix://" + filepath.Join(runDir(homeDir), "docker.sock")
 	if env[0].Value != expected {
 		t.Errorf("expected %q, got %q", expected, env[0].Value)
 	}
+
+	hostPath := d.socketPath(sandboxHome)
+	sandboxPath := strings.TrimPrefix(env[0].Value, "unix://")
+	if rel := strings.TrimPrefix(hostPath, sandboxHome); rel != strings.TrimPrefix(sandboxPath, homeDir) {
+		t.Errorf("socket path %q under sandbox home does not mirror %q under home dir", hostPath, sandboxPath)
+	}
+}
+
+// The socket must be private to this process: sandbox home is shared by every
+// session for the project, and Go unlinks the socket path on listener close,
+// so a shared path lets one session's exit break a live session's DOCKER_HOST.
+func TestDocker_SocketPath_IsProcessScoped(t *testing.T) {
+	d := &Docker{enabled: true}
+	path := d.socketPath("/sandbox/home")
+
+	if !strings.Contains(path, strconv.Itoa(os.Getpid())) {
+		t.Errorf("expected docker socket path to be scoped to the PID, got %q", path)
+	}
+	if filepath.Dir(path) == "/sandbox/home" {
+		t.Errorf("expected docker socket below sandbox home, got %q", path)
+	}
 }
 
 func TestDocker_Bindings(t *testing.T) {

internal/sandbox/tools/kitty.go

@@ -17,7 +17,7 @@ func init() {
 }
 
 const (
-	kittyProxySocketName = ".kitty.sock"
+	kittyProxySocketName = "kitty.sock"
 	kittyModeAuto        = "auto"
 	kittyModeDisabled    = "disabled"
 	kittyModeEnforce     = "enforce"
@@ -112,7 +112,7 @@ func (k *Kitty) Environment(homeDir, _ string) []EnvVar {
 		return nil
 	}
 	return []EnvVar{
-		{Name: "KITTY_LISTEN_ON", Value: "unix:" + filepath.Join(homeDir, kittyProxySocketName)},
+		{Name: "KITTY_LISTEN_ON", Value: "unix:" + filepath.Join(runDir(homeDir), kittyProxySocketName)},
 		{Name: "KITTY_WINDOW_ID", FromHost: true},
 		{Name: "KITTY_PID", FromHost: true},
 	}
@@ -199,7 +199,15 @@ func (k *Kitty) Start(ctx context.Context, _, sandboxHome string) error {
 		Owned:          owned,
 	})
 
-	listenPath := filepath.Join(sandboxHome, kittyProxySocketName)
+	if _, err := ensureRunDir(sandboxHome); err != nil {
+		return fmt.Errorf("kitty: %w", err)
+	}
+
+	listenPath := filepath.Join(runDir(sandboxHome), kittyProxySocketName)
+	if err := checkSocketPath(listenPath); err != nil {
+		return fmt.Errorf("kitty: %w", err)
+	}
+
 	k.proxy = kittyproxy.New(hostSock, listenPath, filter, owned)
 	if k.logger != nil {
 		k.proxy.SetLogger(k.logger)

internal/sandbox/tools/kitty_test.go

@@ -136,7 +136,7 @@ func TestKitty_AggregateAndStart_StartsProxyWhenConsumerPresent(t *testing.T) {
 	k := &Kitty{}
 	k.Configure(GlobalConfig{}, nil)
 
-	// sandboxHome must also be short: kitty's proxy listens at <sandboxHome>/.kitty.sock.
+	// sandboxHome must also be short: kitty's proxy listens under <sandboxHome>.
 	sandboxHome := shortSocketDir(t)
 	if err := k.Start(context.Background(), sandboxHome, sandboxHome); err != nil {
 		t.Fatalf("Start: %v", err)
@@ -146,7 +146,7 @@ func TestKitty_AggregateAndStart_StartsProxyWhenConsumerPresent(t *testing.T) {
 	if k.proxy == nil {
 		t.Fatal("expected proxy to be started when consumer present")
 	}
-	expected := filepath.Join(sandboxHome, ".kitty.sock")
+	expected := filepath.Join(runDir(sandboxHome), kittyProxySocketName)
 	if _, err := os.Stat(expected); err != nil {
 		t.Errorf("proxy socket not created: %v", err)
 	}
@@ -158,12 +158,56 @@ func TestKitty_AggregateAndStart_StartsProxyWhenConsumerPresent(t *testing.T) {
 			listen = e.Value
 		}
 	}
-	wantPrefix := "unix:" + filepath.Join(sandboxHome, ".kitty.sock")
+	wantPrefix := "unix:" + expected
 	if listen != wantPrefix {
 		t.Errorf("KITTY_LISTEN_ON = %q, want %q", listen, wantPrefix)
 	}
 }
 
+// The proxy socket must be private to this process: sandbox home is shared by
+// every session for the project, and closing the listener unlinks the path, so
+// a shared path lets one session's exit break a live session's KITTY_LISTEN_ON.
+func TestKitty_SocketPath_IsProcessScoped(t *testing.T) {
+	dir := shortSocketDir(t)
+	upstream := filepath.Join(dir, "upstream.sock")
+	l, err := net.Listen("unix", upstream)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = l.Close() }()
+
+	t.Setenv("KITTY_LISTEN_ON", "unix:"+upstream)
+	Register(fakeKittyConsumer{})
+	defer Unregister("fake-kitty-consumer")
+
+	k := &Kitty{}
+	k.Configure(GlobalConfig{}, nil)
+
+	sandboxHome := shortSocketDir(t)
+	if err := k.Start(context.Background(), sandboxHome, sandboxHome); err != nil {
+		t.Fatalf("Start: %v", err)
+	}
+	defer func() { _ = k.Stop() }()
+
+	// A concurrent session's socket, in its own run dir under the same home.
+	peerDir := filepath.Join(sandboxHome, runDirName, "1")
+	if err := os.MkdirAll(peerDir, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	peerSocket := filepath.Join(peerDir, kittyProxySocketName)
+	if err := os.WriteFile(peerSocket, nil, 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := k.Stop(); err != nil {
+		t.Fatalf("Stop: %v", err)
+	}
+
+	if _, err := os.Stat(peerSocket); err != nil {
+		t.Errorf("Stop removed a concurrent session's socket: %v", err)
+	}
+}
+
 func TestKitty_DisabledMode(t *testing.T) {
 	dir := shortSocketDir(t)
 	upstream := filepath.Join(dir, "upstream.sock")

internal/sandbox/tools/portal.go

@@ -22,6 +22,7 @@ type Portal struct {
 	xdgRuntime    string // XDG_RUNTIME_DIR value (from host env or /run/user/<uid>)
 	logger        ErrorLogger
 	proxyCmd      *exec.Cmd
+	proxyDir      string // host directory holding the proxy socket
 	proxySocket   string // path to the proxy socket file
 }
 
@@ -70,8 +71,11 @@ func (p *Portal) SetLogger(logger ErrorLogger) {
 }
 
 // proxySocketDir returns the directory for the proxy socket inside sandbox home.
+// It is private to this process so that a concurrent session for the same
+// project cannot unlink a live socket. Its own subdirectory keeps the other
+// tools' sockets out of the read-only bind published at XDG_RUNTIME_DIR.
 func (p *Portal) proxySocketDir(sandboxHome string) string {
-	return filepath.Join(sandboxHome, ".dbus-proxy")
+	return filepath.Join(runDir(sandboxHome), "dbus")
 }
 
 // buildProxyArgs constructs xdg-dbus-proxy arguments.
@@ -107,9 +111,16 @@ func (p *Portal) Start(ctx context.Context, homeDir, sandboxHome string) error {
 		return fmt.Errorf("portal: create proxy socket dir: %w", err)
 	}
 
+	p.proxyDir = proxyDir
 	p.proxySocket = filepath.Join(proxyDir, "bus")
 
-	// Remove stale socket from previous run
+	// xdg-dbus-proxy reports an unbindable socket only by never creating it,
+	// which would surface here as an opaque timeout.
+	if err := checkSocketPath(p.proxySocket); err != nil {
+		return fmt.Errorf("portal: %w", err)
+	}
+
+	// Remove stale socket left by an earlier run that held this PID.
 	_ = os.Remove(p.proxySocket)
 
 	proxyArgs := p.buildProxyArgs(busAddr, p.proxySocket)
@@ -140,9 +151,12 @@ func (p *Portal) Stop() error {
 	_ = p.proxyCmd.Process.Kill()
 	_ = p.proxyCmd.Wait()
 
-	// Clean up socket
-	if p.proxySocket != "" {
-		_ = os.Remove(p.proxySocket)
+	// Clean up socket. The directory is private to this process, so removing it
+	// whole cannot affect a concurrent session.
+	if p.proxyDir != "" {
+		if err := os.RemoveAll(p.proxyDir); err != nil {
+			return fmt.Errorf("portal: remove proxy socket dir: %w", err)
+		}
 	}
 	return nil
 }

internal/sandbox/tools/portal_integration_test.go

@@ -44,11 +44,21 @@ func TestPortal_Integration_ProxyStartStop(t *testing.T) {
 	}
 
 	// Verify socket exists
-	proxySocket := filepath.Join(sandboxHome, ".dbus-proxy", "bus")
+	proxySocket := filepath.Join(p.proxySocketDir(sandboxHome), "bus")
 	if _, err := os.Stat(proxySocket); err != nil {
 		t.Fatalf("proxy socket not found: %v", err)
 	}
 
+	// A concurrent session's socket must survive this instance's teardown.
+	peerDir := filepath.Join(sandboxHome, runDirName, "1", "dbus")
+	if err := os.MkdirAll(peerDir, 0o700); err != nil {
+		t.Fatal(err)
+	}
+	peerSocket := filepath.Join(peerDir, "bus")
+	if err := os.WriteFile(peerSocket, nil, 0o600); err != nil {
+		t.Fatal(err)
+	}
+
 	// Stop proxy
 	err = p.Stop()
 	if err != nil {
@@ -59,4 +69,7 @@ func TestPortal_Integration_ProxyStartStop(t *testing.T) {
 	if _, err := os.Stat(proxySocket); !os.IsNotExist(err) {
 		t.Error("expected proxy socket to be cleaned up after Stop")
 	}
+	if _, err := os.Stat(peerSocket); err != nil {
+		t.Errorf("Stop removed a concurrent session's socket: %v", err)
+	}
 }