Fall back to ~/.cache/airlock/sock for long sandbox paths

AF_UNIX sun_path caps at 104 bytes on macOS (108 on Linux). Deeply
nested project paths overflow that, so `airlock start` fails to
bind cli.sock at `<sandbox_dir>/cli.sock` with EINVAL and `airlock
exec` can never find it.

Add crate::cache::cli_sock_path which returns the in-sandbox path
when it fits, else a stable short fallback at
`~/.cache/airlock/sock/<sha256-prefix-of-sandbox_dir>.sock`. Both
server (cmd_start) and client (cmd_exec) compute the same path from
the sandbox dir, so no pointer file is needed.

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

Author: milankinen

app/airlock-cli/src/cache.rs

@@ -5,7 +5,9 @@
 //! Per-sandbox state (CA, disk image, overlay, etc.) lives in
 //! `<project>/.airlock/sandbox/` — see `sandbox.rs`.
 
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
+
+use sha2::{Digest, Sha256};
 
 /// On-disk format version for the per-layer cache. Bumped whenever the
 /// on-disk contract changes (e.g. the extractor now sets
@@ -50,6 +52,33 @@ pub fn cache_dir() -> anyhow::Result<PathBuf> {
     Ok(dir)
 }
 
+/// Where the CLI RPC Unix socket lives for the sandbox at `sandbox_dir`.
+///
+/// Default is `<sandbox_dir>/cli.sock`. `AF_UNIX` has a hard 104-byte
+/// `sun_path` limit on macOS (108 on Linux); deeply nested project
+/// paths overflow that, so we fall back to
+/// `~/.cache/airlock/sock/<hash>.sock` — a short, stable location
+/// derived from the sandbox dir so `airlock start` and `airlock exec`
+/// both compute the same path without any pointer file.
+///
+/// The parent directory is created on demand.
+pub fn cli_sock_path(sandbox_dir: &Path) -> anyhow::Result<PathBuf> {
+    // 103 = min(sun_path) across linux/macos, minus trailing NUL.
+    const SUN_PATH_SAFE: usize = 103;
+
+    let default = sandbox_dir.join(airlock_common::CLI_SOCK_FILENAME);
+    if default.as_os_str().len() <= SUN_PATH_SAFE {
+        return Ok(default);
+    }
+
+    let mut hasher = Sha256::new();
+    hasher.update(sandbox_dir.as_os_str().as_encoded_bytes());
+    let hash = hex::encode(&hasher.finalize()[..8]);
+    let dir = cache_dir()?.join("sock");
+    std::fs::create_dir_all(&dir)?;
+    Ok(dir.join(format!("{hash}.sock")))
+}
+
 /// Root of the OCI cache (`~/.cache/airlock/oci/`), created if absent.
 /// Holds the `images/` and `layers/` subtrees — kept under a dedicated
 /// namespace so other cache kinds (VM assets, …) don't collide.

app/airlock-cli/src/cli/cmd_exec.rs

@@ -160,16 +160,20 @@ pub async fn main(args: ExecArgs) -> anyhow::Result<i32> {
     Ok(exit_code)
 }
 
-/// Walk up from `start` looking for `.airlock/sandbox/<CLI_SOCK_FILENAME>`.
-/// Returns the first match, or `None` if nothing is found before the
-/// filesystem root.
+/// Walk up from `start` looking for `.airlock/sandbox/`. For each
+/// match resolve the CLI sock path — which is either that directory's
+/// `cli.sock` or a hash-keyed fallback under `~/.cache/airlock/sock/`
+/// when the in-sandbox path would exceed the `AF_UNIX` limit. Returns
+/// the first resolved path that exists on disk.
 fn find_cli_sock(start: &std::path::Path) -> Option<PathBuf> {
     for dir in start.ancestors() {
-        let candidate = dir
-            .join(".airlock")
-            .join("sandbox")
-            .join(airlock_common::CLI_SOCK_FILENAME);
-        if candidate.exists() {
+        let sandbox_dir = dir.join(".airlock").join("sandbox");
+        if !sandbox_dir.is_dir() {
+            continue;
+        }
+        if let Ok(candidate) = crate::cache::cli_sock_path(&sandbox_dir)
+            && candidate.exists()
+        {
             return Some(candidate);
         }
     }

app/airlock-cli/src/cli/cmd_start.rs

@@ -226,7 +226,7 @@ async fn run(
     // The server needs a copy of the sandbox's resolved env so it can layer
     // `airlock exec -e KEY=VAL` overrides on top without the exec client
     // having to re-resolve the project.
-    let sock_path = project.sandbox_dir.join(airlock_common::CLI_SOCK_FILENAME);
+    let sock_path = crate::cache::cli_sock_path(&project.sandbox_dir)?;
     let base_env = vm.env.clone();
     tokio::task::spawn_local(cli_server::serve(sock_path, supervisor.clone(), base_env));