Fix live workspace mounts

Author: rowantrollope

AGENTS.md

@@ -212,6 +212,9 @@ The most important implementation seams are:
   `go list` can trigger dependency downloads in those nested modules.
 - `afs setup` owns only the default local mode prompt. Workspace selection and
   local directory prompts belong under `afs ws mount`, not setup.
+- `example.afs.config.json` should mirror the canonical persisted config shape:
+  an empty `workspace.default` to force an explicit user choice; no root
+  `currentWorkspace` or `localPath` keys.
 - If a Vite UI change is present in source but `localhost:5173` still shows old
   behavior, check for duplicate Vite listeners from sibling worktrees.
   `localhost` can hit an IPv6 listener from another checkout while

README.md

@@ -171,18 +171,22 @@ The current config shape is nested and workspace-oriented:
     "tls": false
   },
   "mode": "sync",
-  "currentWorkspace": "my-repo",
-  "mount": {
-    "backend": "none",
-    "allowOther": false,
-    "mountBin": "",
-    "nfsBin": "",
-    "nfsHost": "127.0.0.1",
-    "nfsPort": 20490
+  "workspace": {
+    "default": "my-repo"
   },
-  "logs": {
-    "mount": "/tmp/afs-mount.log",
-    "sync": "/tmp/afs-sync.log"
+  "runtime": {
+    "mount": {
+      "backend": "none",
+      "allowOther": false,
+      "mountBin": "",
+      "nfsBin": "",
+      "nfsHost": "127.0.0.1",
+      "nfsPort": 20490
+    },
+    "logs": {
+      "mount": "/tmp/afs-mount.log",
+      "sync": "/tmp/afs-sync.log"
+    }
   },
   "sync": {
     "fileSizeCapMB": 2048

cmd/afs/config_commands_test.go

@@ -107,6 +107,15 @@ func TestSaveConfigPersistsDefaultWorkspaceOutsideLegacyRuntimeKeys(t *testing.T
 	if workspace["default"] != "demo" || workspace["defaultID"] != "ws_demo" {
 		t.Fatalf("workspace config = %#v, want demo/ws_demo", workspace)
 	}
+	runtime, ok := saved["runtime"].(map[string]any)
+	if !ok {
+		t.Fatalf("config should persist runtime mount/log settings under runtime key: %s", string(raw))
+	}
+	for _, key := range []string{"currentWorkspace", "currentWorkspaceID"} {
+		if _, ok := runtime[key]; ok {
+			t.Fatalf("runtime config should not persist workspace key %q: %s", key, string(raw))
+		}
+	}
 	loaded, err := loadConfig()
 	if err != nil {
 		t.Fatalf("loadConfig() returned error: %v", err)
@@ -614,15 +623,19 @@ func TestLoadConfigForUpPromptsForMissingDatabaseAndMountpoint(t *testing.T) {
 	}
 
 	raw := `{
-  "redis": {
-    "addr": "` + mr.Addr() + `"
-  },
-  "currentWorkspace": "demo",
-  "mount": {
-    "backend": "nfs",
-    "nfsBin": "/usr/bin/true"
-  }
-}`
+	  "redis": {
+	    "addr": "` + mr.Addr() + `"
+	  },
+	  "workspace": {
+	    "default": "demo"
+	  },
+	  "runtime": {
+	    "mount": {
+	      "backend": "nfs",
+	      "nfsBin": "/usr/bin/true"
+	    }
+	  }
+	}`
 	if err := os.WriteFile(configFile, []byte(raw), 0o644); err != nil {
 		t.Fatalf("WriteFile(config) returned error: %v", err)
 	}

cmd/afs/config_state.go

@@ -69,10 +69,8 @@ type persistedConfig struct {
 }
 
 type persistedRuntime struct {
-	CurrentWorkspace   string        `json:"currentWorkspace,omitempty"`
-	CurrentWorkspaceID string        `json:"currentWorkspaceID,omitempty"`
-	Mount              mountSettings `json:"mount,omitempty"`
-	Logs               logSettings   `json:"logs,omitempty"`
+	Mount mountSettings `json:"mount,omitempty"`
+	Logs  logSettings   `json:"logs,omitempty"`
 }
 
 func persistedConfigFromRuntime(cfg config) persistedConfig {
@@ -113,10 +111,8 @@ func persistedConfigFromRuntime(cfg config) persistedConfig {
 		out.Sync = &syncSettings{SyncFileSizeCapMB: cfg.SyncFileSizeCapMB}
 	}
 	out.Runtime = &persistedRuntime{
-		CurrentWorkspace:   strings.TrimSpace(cfg.CurrentWorkspace),
-		CurrentWorkspaceID: strings.TrimSpace(cfg.CurrentWorkspaceID),
-		Mount:              persistedMountSettings(cfg.mountSettings),
-		Logs:               cfg.logSettings,
+		Mount: persistedMountSettings(cfg.mountSettings),
+		Logs:  cfg.logSettings,
 	}
 	return out
 }
@@ -163,15 +159,6 @@ func loadConfig() (config, error) {
 	}
 	cfg.CurrentWorkspace = strings.TrimSpace(raw.Workspace.DefaultWorkspace)
 	cfg.CurrentWorkspaceID = strings.TrimSpace(raw.Workspace.DefaultWorkspaceID)
-	if cfg.CurrentWorkspace == "" && cfg.CurrentWorkspaceID == "" {
-		if raw.Runtime != nil {
-			cfg.CurrentWorkspace = strings.TrimSpace(raw.Runtime.CurrentWorkspace)
-			cfg.CurrentWorkspaceID = strings.TrimSpace(raw.Runtime.CurrentWorkspaceID)
-		} else {
-			cfg.CurrentWorkspace = legacy.CurrentWorkspace
-			cfg.CurrentWorkspaceID = legacy.CurrentWorkspaceID
-		}
-	}
 
 	if raw.Runtime != nil {
 		cfg.LocalPath = ""

cmd/afs/mount_commands.go

@@ -34,6 +34,11 @@ type unmountOptions struct {
 	deleteLocal bool
 }
 
+var (
+	startMountServicesForWorkspaceMount = startMountServices
+	startSyncMountForWorkspaceMount     = startSyncMount
+)
+
 func cmdMountArgs(args []string) error {
 	if len(args) > 0 && isHelpArg(args[0]) {
 		fmt.Fprint(os.Stderr, mountUsageText(filepath.Base(os.Args[0])))
@@ -165,11 +170,22 @@ func mountWorkspace(opts mountOptions) error {
 	if err != nil {
 		return err
 	}
-	cfg.Mode = modeSync
-	cfg.MountBackend = mountBackendNone
+	mode, err := effectiveMode(cfg)
+	if err != nil {
+		return err
+	}
+	if mode == modeNone {
+		return fmt.Errorf("mode is set to none; update config first")
+	}
 	cfg.CurrentWorkspace = opts.workspace
 	cfg.CurrentWorkspaceID = ""
 	cfg.LocalPath = localPath
+	if mode == modeSync {
+		cfg.Mode = modeSync
+		cfg.MountBackend = mountBackendNone
+	} else {
+		cfg.Mode = modeMount
+	}
 
 	ctx := context.Background()
 	resolvedCfg, service, closeStore, err := openAFSControlPlaneForConfig(ctx, cfg)
@@ -189,9 +205,80 @@ func mountWorkspace(opts mountOptions) error {
 	resolvedCfg.CurrentWorkspace = selection.Name
 	resolvedCfg.CurrentWorkspaceID = selection.ID
 	resolvedCfg.LocalPath = localPath
+	if mode == modeMount {
+		if err := applyWorkspaceSelection(&resolvedCfg, selection); err != nil {
+			return err
+		}
+		resolvedCfg.LocalPath = localPath
+		resolvedCfg.Mode = modeMount
+		resolvedCfg.ReadOnly = opts.readonly
+		return startLiveMount(resolvedCfg, selection, opts)
+	}
 	resolvedCfg.Mode = modeSync
 	resolvedCfg.MountBackend = mountBackendNone
-	return startSyncMount(ctx, resolvedCfg, selection, opts)
+	return startSyncMountForWorkspaceMount(ctx, resolvedCfg, selection, opts)
+}
+
+func startLiveMount(cfg config, selection workspaceSelection, opts mountOptions) error {
+	if opts.dryRun {
+		return fmt.Errorf("--dry-run is only available for sync-mode mounts")
+	}
+	if strings.TrimSpace(cfg.LocalPath) == "" {
+		return errors.New("mount requires a local directory")
+	}
+	if err := validateUpModeSelection(cfg); err != nil {
+		return err
+	}
+	st, err := startMountServicesForWorkspaceMount(cfg, opts.sessionName)
+	if err != nil {
+		return err
+	}
+	if strings.TrimSpace(st.CurrentWorkspace) == "" {
+		st.CurrentWorkspace = selection.Name
+	}
+	if strings.TrimSpace(st.CurrentWorkspaceID) == "" {
+		st.CurrentWorkspaceID = selection.ID
+	}
+	if err := registerLiveMount(st); err != nil {
+		_ = stopMount(mountRecordFromLiveState(st, ""), false)
+		return err
+	}
+	recordMountShellDirectory(st.LocalPath)
+	return nil
+}
+
+func registerLiveMount(st state) error {
+	reg, err := loadMountRegistry()
+	if err != nil {
+		return err
+	}
+	id, err := randomSuffix()
+	if err != nil {
+		return err
+	}
+	upsertMount(&reg, mountRecordFromLiveState(st, "mnt_"+id))
+	return saveMountRegistry(reg)
+}
+
+func mountRecordFromLiveState(st state, id string) mountRecord {
+	return mountRecord{
+		ID:                   id,
+		Workspace:            st.CurrentWorkspace,
+		WorkspaceID:          st.CurrentWorkspaceID,
+		LocalPath:            st.LocalPath,
+		Mode:                 modeMount,
+		MountBackend:         st.MountBackend,
+		ProductMode:          st.ProductMode,
+		ControlPlaneURL:      st.ControlPlaneURL,
+		ControlPlaneDatabase: st.ControlPlaneDatabase,
+		SessionID:            st.SessionID,
+		RedisAddr:            st.RedisAddr,
+		RedisDB:              st.RedisDB,
+		RedisKey:             st.RedisKey,
+		PID:                  st.MountPID,
+		ReadOnly:             st.ReadOnly,
+		StartedAt:            st.StartedAt,
+	}
 }
 
 func startSyncMount(ctx context.Context, cfg config, selection workspaceSelection, opts mountOptions) error {
@@ -829,6 +916,18 @@ func unmountPromptRows(records []mountRecord) [][]string {
 }
 
 func stopMount(rec mountRecord, deleteLocal bool) error {
+	if strings.TrimSpace(rec.Mode) == modeMount {
+		cfg := configFromMount(rec)
+		backend, _, err := backendForConfig(cfg)
+		if err != nil {
+			return err
+		}
+		if localPath := strings.TrimSpace(rec.LocalPath); localPath != "" && backend.IsMounted(localPath) {
+			if err := backend.Unmount(localPath); err != nil {
+				return err
+			}
+		}
+	}
 	if rec.PID > 0 && processAlive(rec.PID) {
 		if err := terminatePID(rec.PID, 5*time.Second); err != nil {
 			return err
@@ -879,6 +978,9 @@ func configFromMount(rec mountRecord) config {
 	cfg.CurrentWorkspaceID = rec.WorkspaceID
 	cfg.LocalPath = rec.LocalPath
 	cfg.Mode = rec.Mode
+	if strings.TrimSpace(rec.MountBackend) != "" {
+		cfg.MountBackend = rec.MountBackend
+	}
 	cfg.SyncLog = rec.SyncLog
 	return cfg
 }

cmd/afs/mount_commands_test.go

@@ -1,13 +1,108 @@
 package main
 
 import (
+	"context"
 	"os"
 	"path/filepath"
 	"strings"
 	"testing"
 	"time"
+
+	"github.com/alicebob/miniredis/v2"
+	"github.com/redis/go-redis/v9"
 )
 
+func TestMountWorkspaceUsesConfiguredLiveMountMode(t *testing.T) {
+	t.Helper()
+
+	withTempHome(t)
+	mr := miniredis.RunT(t)
+	rdb := redis.NewClient(&redis.Options{Addr: mr.Addr()})
+	t.Cleanup(func() {
+		_ = rdb.Close()
+	})
+
+	sourceDir := t.TempDir()
+	writeTestFile(t, filepath.Join(sourceDir, "README.md"), "hello\n")
+	seedWorkspaceFromDirectory(t, newAFSStore(rdb), "repo", "initial", sourceDir)
+
+	cfg := defaultConfig()
+	cfg.RedisAddr = mr.Addr()
+	cfg.Mode = modeMount
+	cfg.MountBackend = mountBackendNFS
+	cfg.NFSBin = "/bin/true"
+	saveTempConfig(t, cfg)
+
+	origStartMount := startMountServicesForWorkspaceMount
+	origStartSync := startSyncMountForWorkspaceMount
+	t.Cleanup(func() {
+		startMountServicesForWorkspaceMount = origStartMount
+		startSyncMountForWorkspaceMount = origStartSync
+	})
+
+	var captured config
+	var capturedSession string
+	startMountServicesForWorkspaceMount = func(cfg config, sessionName string) (state, error) {
+		captured = cfg
+		capturedSession = sessionName
+		return state{
+			StartedAt:        time.Now().UTC(),
+			ProductMode:      cfg.ProductMode,
+			RedisAddr:        cfg.RedisAddr,
+			RedisDB:          cfg.RedisDB,
+			CurrentWorkspace: cfg.CurrentWorkspace,
+			MountPID:         4242,
+			MountBackend:     cfg.MountBackend,
+			LocalPath:        cfg.LocalPath,
+			Mode:             modeMount,
+			RedisKey:         "ws_repo",
+			ReadOnly:         cfg.ReadOnly,
+		}, nil
+	}
+	startSyncMountForWorkspaceMount = func(ctx context.Context, cfg config, selection workspaceSelection, opts mountOptions) error {
+		t.Fatalf("startSyncMount called for mode=mount config: cfg=%+v selection=%+v opts=%+v", cfg, selection, opts)
+		return nil
+	}
+
+	localPath := filepath.Join(t.TempDir(), "repo")
+	if err := mountWorkspace(mountOptions{
+		workspace:   "repo",
+		directory:   localPath,
+		sessionName: "live edit",
+		readonly:    true,
+	}); err != nil {
+		t.Fatalf("mountWorkspace() returned error: %v", err)
+	}
+
+	if captured.Mode != modeMount {
+		t.Fatalf("captured Mode = %q, want %q", captured.Mode, modeMount)
+	}
+	if captured.MountBackend != mountBackendNFS {
+		t.Fatalf("captured MountBackend = %q, want %q", captured.MountBackend, mountBackendNFS)
+	}
+	if captured.LocalPath != localPath {
+		t.Fatalf("captured LocalPath = %q, want %q", captured.LocalPath, localPath)
+	}
+	if !captured.ReadOnly {
+		t.Fatal("captured ReadOnly = false, want true")
+	}
+	if capturedSession != "live edit" {
+		t.Fatalf("captured sessionName = %q, want live edit", capturedSession)
+	}
+
+	reg, err := loadMountRegistry()
+	if err != nil {
+		t.Fatalf("loadMountRegistry() returned error: %v", err)
+	}
+	rec, ok := mountByPath(reg, localPath)
+	if !ok {
+		t.Fatalf("expected live mount registry record at %s; got %#v", localPath, reg.Mounts)
+	}
+	if rec.Mode != modeMount || rec.MountBackend != mountBackendNFS {
+		t.Fatalf("mount registry mode/backend = %q/%q, want %q/%q", rec.Mode, rec.MountBackend, modeMount, mountBackendNFS)
+	}
+}
+
 func TestParseMountOptionsAllowsOptionalDirectory(t *testing.T) {
 	t.Helper()
 

cmd/afs/mount_state.go

@@ -25,6 +25,7 @@ type mountRecord struct {
 	WorkspaceID          string    `json:"workspace_id,omitempty"`
 	LocalPath            string    `json:"local_path"`
 	Mode                 string    `json:"mode"`
+	MountBackend         string    `json:"mount_backend,omitempty"`
 	ProductMode          string    `json:"product_mode,omitempty"`
 	ControlPlaneURL      string    `json:"control_plane_url,omitempty"`
 	ControlPlaneDatabase string    `json:"control_plane_database,omitempty"`