From 72da120661991d252024e692de307091f89edc65 Mon Sep 17 00:00:00 2001 From: David Idris Date: Sat, 21 Nov 2026 14:18:28 +0000 Subject: [PATCH] fix(install): mount the Docker socket inside the VM on macOS On macOS the Docker daemon runs in a Linux VM (Docker Desktop, colima, OrbStack, Rancher Desktop) and resolves bind mount sources there. The installer saved the context endpoint, the Mac-side forward of the socket, as LOOPFORGE_DOCKER_SOCKET, so the platform container failed to start with "mkdir ...docker.sock: operation not supported". On macOS it now saves /var/run/docker.sock, where the daemon listens inside the VM. A rerun replaces a Mac-side value that an earlier install saved, which otherwise stayed in .env and broke every later start. A socket the operator set to any other path is kept. Linux keeps the context endpoint, so rootless Docker is unchanged. Fixes #1161 --- scripts/install.sh | 40 +++++++++++++++++++++++++++------ scripts/test-install.py | 49 ++++++++++++++++++++++++++++++++++++++++- 2 files changed, 81 insertions(+), 8 deletions(-) diff --git a/scripts/install.sh b/scripts/install.sh index be444bb8..8b39a68e 100755 --- a/scripts/install.sh +++ b/scripts/install.sh @@ -124,18 +124,44 @@ export LOOPFORGE_BIND="${LOOPFORGE_BIND:-0.0.0.0}" if [[ -n "$requested_public_url" ]]; then export LOOPFORGE_PUBLIC_URL="$requested_public_url"; fi python3 scripts/install-address.py --prepare "${AGENTFLOW_HTTP_PORT:-8090}" set -a; source .env; set +a -if [[ -z "${LOOPFORGE_DOCKER_SOCKET:-}" ]]; then +save_docker_socket() { + python3 - <<'PY' +import os,pathlib,re,shlex +p=pathlib.Path('.env') +text=re.sub(r'(?m)^LOOPFORGE_DOCKER_SOCKET=.*\n?','',p.read_text()) +p.write_text(text.rstrip('\n')+'\n\nLOOPFORGE_DOCKER_SOCKET='+shlex.quote(os.environ['LOOPFORGE_DOCKER_SOCKET'])+'\n') +PY +} +# The socket is the platform container's bind mount source, and the daemon +# resolves it on its own host. On macOS that host is a Linux VM (Docker +# Desktop, colima, OrbStack, Rancher Desktop): the context endpoint is the +# Mac-side forward of the socket, which the VM cannot mount, while the daemon +# itself listens on /var/run/docker.sock inside the VM. +vm_docker_socket=/var/run/docker.sock +docker_host= +if [[ -z "${LOOPFORGE_DOCKER_SOCKET:-}" || $(uname -s) == Darwin ]]; then docker_host="${DOCKER_HOST:-$(docker_access context inspect --format '{{(index .Endpoints "docker").Host}}' 2>/dev/null || true)}" +fi +if [[ -z "${LOOPFORGE_DOCKER_SOCKET:-}" ]]; then case "$docker_host" in - unix://*) export LOOPFORGE_DOCKER_SOCKET="${docker_host#unix://}" ;; + unix://*) + if [[ $(uname -s) == Darwin ]]; then + export LOOPFORGE_DOCKER_SOCKET="$vm_docker_socket" + else + export LOOPFORGE_DOCKER_SOCKET="${docker_host#unix://}" + fi + ;; '') export LOOPFORGE_DOCKER_SOCKET=/var/run/docker.sock ;; *) fail 'This installer requires a local Docker socket for sandbox bind mounts. Select a local/rootless Docker context or configure remote workers manually.' ;; esac - python3 - <<'PY' -import os,pathlib,shlex -with pathlib.Path('.env').open('a') as config: - config.write('\nLOOPFORGE_DOCKER_SOCKET='+shlex.quote(os.environ['LOOPFORGE_DOCKER_SOCKET'])+'\n') -PY + save_docker_socket +elif [[ $(uname -s) == Darwin && "$docker_host" == unix://* \ + && "$LOOPFORGE_DOCKER_SOCKET" == "${docker_host#unix://}" && "$LOOPFORGE_DOCKER_SOCKET" != "$vm_docker_socket" ]]; then + # Earlier installers saved the Mac-side path, and the platform container + # could not start with it. Replace that value; any other setting is kept. + printf ' Using %s inside the Docker VM instead of %s.\n' "$vm_docker_socket" "$LOOPFORGE_DOCKER_SOCKET" + export LOOPFORGE_DOCKER_SOCKET="$vm_docker_socket" + save_docker_socket fi python3 - <<'PY' import runpy diff --git a/scripts/test-install.py b/scripts/test-install.py index cd4d6e23..cacc3f34 100644 --- a/scripts/test-install.py +++ b/scripts/test-install.py @@ -45,6 +45,7 @@ def setUp(self): [[ "${MOCK_USER:-0}" == 0 || "${MOCK_PRIVILEGED:-0}" == 1 || "${MOCK_DIRECT:-0}" == 1 ]] exit fi +if [[ "$1" == context && "$2" == inspect ]]; then printf '%s\\n' "${MOCK_CONTEXT_HOST:-}"; exit; fi if [[ "$1" == image && "$2" == inspect && "${MOCK_IMAGE_PRESENT:-0}" != 1 ]]; then exit 1; fi if [[ "$1" == pull && "${MOCK_PULL_FAIL:-0}" == 1 ]]; then exit 42; fi if [[ "$1" == tag && "${MOCK_TAG_FAIL:-0}" == 1 ]]; then exit 1; fi @@ -67,7 +68,7 @@ def setUp(self): exec "$@" ''') self.environ = dict(os.environ, PATH=str(self.root / 'mock') + ':' + os.environ['PATH'], MOCK_LOG=str(self.root / 'docker.log'), MOCK_SQL_LOG=str(self.root / 'mysql.log'), AGENTFLOW_HTTP_PORT='18765', LOOPFORGE_PUBLIC_URL='https://team.example.test', LOOPFORGE_BIND='0.0.0.0') - for name in ('LOOPFORGE_DOCKER_USE_SUDO', 'LOOPFORGE_DATA_DIR', 'LOOPFORGE_IMAGE', 'COMPOSE_FILE', 'LOOPFORGE_BUILD_FROM_SOURCE', 'LOOPFORGE_PULL_POLICY', 'MIRROR', 'MOCK_USER', 'MOCK_DIRECT', 'MOCK_SUDO_DENIED', 'MOCK_IMAGE_PRESENT', 'MOCK_PULL_FAIL', 'MOCK_TAG_FAIL', 'MOCK_MIRROR_GHCR', 'MOCK_MIRROR_NJU', 'MOCK_CURL_LOG'): + for name in ('LOOPFORGE_DOCKER_USE_SUDO', 'LOOPFORGE_DATA_DIR', 'LOOPFORGE_IMAGE', 'COMPOSE_FILE', 'LOOPFORGE_BUILD_FROM_SOURCE', 'LOOPFORGE_PULL_POLICY', 'MIRROR', 'MOCK_USER', 'MOCK_DIRECT', 'MOCK_SUDO_DENIED', 'MOCK_IMAGE_PRESENT', 'MOCK_PULL_FAIL', 'MOCK_TAG_FAIL', 'MOCK_MIRROR_GHCR', 'MOCK_MIRROR_NJU', 'MOCK_CURL_LOG', 'MOCK_CONTEXT_HOST', 'DOCKER_HOST', 'LOOPFORGE_DOCKER_SOCKET'): self.environ.pop(name, None) self.environ.pop('MOCK_COLUMN_COUNT', None) @@ -124,6 +125,52 @@ def test_non_root_with_direct_access_never_uses_sudo(self): self.assert_success(self.install(MOCK_USER='1000', MOCK_DIRECT='1', MOCK_SUDO_DENIED='1')) self.assertNotIn('1 compose', (self.root / 'docker.log').read_text()) + def docker_socket_setting(self): + lines = [line for line in (self.root / '.env').read_text().splitlines() if line.startswith('LOOPFORGE_DOCKER_SOCKET=')] + self.assertEqual(len(lines), 1, lines) + return lines[0].split('=', 1)[1] + + def use_macos(self): + self.executable('uname', '#!/usr/bin/env bash\nif [[ "$1" == -s ]]; then echo Darwin; else echo arm64; fi\n') + + def set_docker_socket(self, value): + text = (self.root / '.env').read_text().replace('LOOPFORGE_DOCKER_SOCKET=' + self.docker_socket_setting(), 'LOOPFORGE_DOCKER_SOCKET=' + value) + (self.root / '.env').write_text(text) + + def test_linux_context_socket_is_the_mount_source(self): + self.assert_success(self.install(MOCK_CONTEXT_HOST='unix:///run/user/1000/docker.sock')) + self.assertEqual(self.docker_socket_setting(), '/run/user/1000/docker.sock') + + def test_macos_vm_engines_mount_the_socket_inside_the_vm(self): + self.use_macos() + for context in ('unix:///Users/dev/.colima/default/docker.sock', 'unix:///Users/dev/.docker/run/docker.sock', 'unix:///Users/dev/.orbstack/run/docker.sock', 'unix:///var/run/docker.sock'): + with self.subTest(context=context): + (self.root / '.env').unlink(missing_ok=True) + self.assert_success(self.install(MOCK_CONTEXT_HOST=context)) + self.assertEqual(self.docker_socket_setting(), '/var/run/docker.sock') + + def test_macos_rerun_replaces_the_mac_side_socket_an_earlier_install_saved(self): + self.use_macos() + context = 'unix:///Users/dev/.colima/default/docker.sock' + self.assert_success(self.install(MOCK_CONTEXT_HOST=context)) + self.set_docker_socket('/Users/dev/.colima/default/docker.sock') + before = (self.root / '.env').read_text() + result = self.install(MOCK_CONTEXT_HOST=context) + self.assert_success(result) + self.assertIn('Using /var/run/docker.sock inside the Docker VM', result.stdout) + self.assertEqual(self.docker_socket_setting(), '/var/run/docker.sock') + self.assertEqual((self.root / '.env').read_text(), before.replace('/Users/dev/.colima/default/docker.sock', '/var/run/docker.sock')) + self.assertEqual((self.root / '.env').stat().st_mode & 0o777, 0o600) + + def test_macos_rerun_keeps_a_socket_the_operator_chose(self): + self.use_macos() + self.assert_success(self.install(MOCK_CONTEXT_HOST='unix:///Users/dev/.colima/default/docker.sock')) + self.set_docker_socket('/var/run/custom-docker.sock') + result = self.install(MOCK_CONTEXT_HOST='unix:///Users/dev/.colima/default/docker.sock') + self.assert_success(result) + self.assertNotIn('inside the Docker VM', result.stdout) + self.assertEqual(self.docker_socket_setting(), '/var/run/custom-docker.sock') + def test_noninteractive_without_sudo_fails_immediately(self): result = self.install(MOCK_USER='1000', MOCK_SUDO_DENIED='1') self.assertNotEqual(result.returncode, 0)