Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
refactor: move manual file reading/writing/parsing to go.getarcane.app/acfs (#3552)
Kyle Mendellbcdbe817ca51
diff --git a/backend/go.mod b/backend/go.modindex 6deeaa862..368987d4c 100644--- a/backend/go.mod+++ b/backend/go.mod@@ -56,6 +56,7 @@ require (github.com/stretchr/testify v1.11.1github.com/subosito/gotenv v1.6.0github.com/wneessen/go-mail v0.8.1+ go.getarcane.app/acfs v0.2.0go.getarcane.app/builds v0.3.0go.getarcane.app/docker/convert v0.1.0go.getarcane.app/streams v0.3.1diff --git a/backend/go.sum b/backend/go.sumindex 13a57478e..b6a5171e1 100644--- a/backend/go.sum+++ b/backend/go.sum@@ -756,6 +756,8 @@ github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUoNXj+IQ=github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0=github.com/zeebo/xxh3 v1.0.2 h1:xZmwmqxHZA8AI603jOQ0tMqmBr9lPeFwGg6d+xy9DC0=github.com/zeebo/xxh3 v1.0.2/go.mod h1:5NWz9Sef7zIDm2JHfFlcQvNekmcEl9ekUZQQKCYaDcA=+go.getarcane.app/acfs v0.2.0 h1:m7yXsLIB4MfsAE/AFP54RgtMXUr+AFEVCNiF5784XYI=+go.getarcane.app/acfs v0.2.0/go.mod h1:sU3t21KctTsQM3OW10+RNB0Z6lR+YfaSr5Nxubq3cpI=go.getarcane.app/builds v0.3.0 h1:6fCgHy6PaEr3LpCtiF1iCdT4nuV3D3xvUHnV+E/0cqk=go.getarcane.app/builds v0.3.0/go.mod h1:yZJDSh9XX/sgZlwx7lghHEucgZeQ74Gr/Fx+XdR2bdk=go.getarcane.app/docker/convert v0.1.0 h1:prlIOs6dMx6CdnetsJFZ6ak0vcistM3DcH5lrZiFHBU=diff --git a/backend/internal/build/workspace_handler.go b/backend/internal/build/workspace_handler.goindex e838e7dc6..1f6c3a9c1 100644--- a/backend/internal/build/workspace_handler.go+++ b/backend/internal/build/workspace_handler.go@@ -192,7 +192,7 @@ func (h *BuildWorkspaceHandler) UploadFile(ctx context.Context, input *UploadBui}defer func() { _ = file.Close() }()- if err := h.service.UploadFile(ctx, input.Path, file, fileHeader.Filename); err != nil {+ if err := h.service.UploadFile(ctx, input.Path, file, fileHeader.Filename, fileHeader.Size); err != nil {return nil, huma.Error500InternalServerError(err.Error())}return &base.ApiResponse[base.MessageResponse]{diff --git a/backend/internal/build/workspace_service.go b/backend/internal/build/workspace_service.goindex 34c557be6..4bf0a30d9 100644--- a/backend/internal/build/workspace_service.go+++ b/backend/internal/build/workspace_service.go@@ -15,7 +15,9 @@ import ("github.com/getarcaneapp/arcane/backend/v2/internal/settings""github.com/getarcaneapp/arcane/backend/v2/pkg/utils"+ acfsutils "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/acfs"workspacetypes "github.com/getarcaneapp/arcane/types/v2/workspace"+ "go.getarcane.app/acfs")const defaultBuildsDirectory = "/builds"@@ -41,49 +43,14 @@ func (s *BuildWorkspaceService) ListDirectory(ctx context.Context, dirPath strinreturn nil, errors.WrapIf(err, "invalid path")}- targetPath, err := joinBuildRoot(root, cleaned)- if err != nil {- return nil, err- }-- entries, err := os.ReadDir(targetPath)+ entries, err := acfs.List(ctx, root, cleaned)if err != nil {return nil, errors.WrapIf(err, "failed to list directory")}results := make([]workspacetypes.FileEntry, 0, len(entries))for _, entry := range entries {- info, err := entry.Info()- if err != nil {- continue- }-- entryPath := path.Join(cleaned, entry.Name())- if entryPath == "" {- entryPath = "/"- }-- isSymlink := entry.Type()&os.ModeSymlink != 0- mode := info.Mode().String()-- fileEntry := workspacetypes.FileEntry{- Name: entry.Name(),- Path: entryPath,- IsDirectory: info.IsDir(),- Size: info.Size(),- ModTime: info.ModTime(),- Mode: mode,- IsSymlink: isSymlink,- }-- if isSymlink {- target, err := os.Readlink(filepath.Join(targetPath, entry.Name()))- if err == nil && target != "" {- fileEntry.LinkTarget = resolveLinkTarget(root, target)- }- }-- results = append(results, fileEntry)+ results = append(results, acfsutils.FileEntry(entry))}return results, nil@@ -101,30 +68,17 @@ func (s *BuildWorkspaceService) GetFileContent(ctx context.Context, filePath strreturn nil, "", errors.WrapIf(err, "invalid path")}- fullPath, err := joinBuildRoot(root, cleaned)- if err != nil {- return nil, "", err- }-- info, err := os.Stat(fullPath)- if err != nil {- return nil, "", errors.WrapIf(err, "failed to stat file")- }- if info.IsDir() {- return nil, "", errors.New("path is a directory")- }-if maxBytes <= 0 {maxBytes = 1048576}- file, err := os.Open(fullPath)+ file, _, err := acfs.OpenRead(ctx, root, cleaned, maxBytes)if err != nil {return nil, "", errors.WrapIf(err, "failed to open file")}defer func() { _ = file.Close() }()- content, err := io.ReadAll(io.LimitReader(file, maxBytes))+ content, err := io.ReadAll(file)if err != nil {return nil, "", errors.WrapIf(err, "failed to read file")}@@ -145,35 +99,22 @@ func (s *BuildWorkspaceService) DownloadFile(ctx context.Context, filePath strinreturn nil, 0, errors.WrapIf(err, "invalid path")}- fullPath, err := joinBuildRoot(root, cleaned)- if err != nil {- return nil, 0, err- }-- info, err := os.Stat(fullPath)- if err != nil {- return nil, 0, errors.WrapIf(err, "failed to stat file")- }- if info.IsDir() {- return nil, 0, errors.New("path is a directory")- }-- file, err := os.Open(fullPath)+ file, size, err := acfs.OpenRead(ctx, root, cleaned, 0)if err != nil {return nil, 0, errors.WrapIf(err, "failed to open file")}- return file, info.Size(), nil+ return file, size, nil}-func (s *BuildWorkspaceService) UploadFile(ctx context.Context, destPath string, content io.Reader, filename string) error {+func (s *BuildWorkspaceService) UploadFile(ctx context.Context, destPath string, content io.Reader, filename string, size int64) error {slog.DebugContext(ctx, "build workspace: upload file", "dest_path", destPath, "filename", filename)root, err := s.resolveRoot()if err != nil {return err}- safeFilename, err := sanitizeUploadFilename(filename)+ safeFilename, err := sanitizeUploadFilenameInternal(filename)if err != nil {return err}@@ -183,23 +124,12 @@ func (s *BuildWorkspaceService) UploadFile(ctx context.Context, destPath string,return errors.WrapIf(err, "invalid path")}- dirPath, err := joinBuildRoot(root, cleaned)- if err != nil {- return err- }-- if err := os.MkdirAll(dirPath, 0o755); err != nil {+ if err := acfs.MkdirAll(ctx, root, cleaned, 0o755); err != nil {return errors.WrapIf(err, "failed to create directory")}- targetFile := filepath.Join(dirPath, safeFilename)- file, err := os.Create(targetFile)- if err != nil {- return errors.WrapIf(err, "failed to create file")- }- defer func() { _ = file.Close() }()-- if _, err := io.Copy(file, content); err != nil {+ targetFile := path.Join(cleaned, safeFilename)+ if _, err := acfs.WriteFrom(ctx, root, targetFile, content, size, 0o644); err != nil {return errors.WrapIf(err, "failed to write file")}@@ -218,16 +148,11 @@ func (s *BuildWorkspaceService) CreateDirectory(ctx context.Context, dirPath strreturn errors.WrapIf(err, "invalid path")}- fullPath, err := joinBuildRoot(root, cleaned)- if err != nil {- return err- }-if cleaned == "/" {return nil}- if err := os.MkdirAll(fullPath, 0o755); err != nil {+ if err := acfs.MkdirAll(ctx, root, cleaned, 0o755); err != nil {return errors.WrapIf(err, "failed to create directory")}@@ -250,12 +175,7 @@ func (s *BuildWorkspaceService) DeleteFile(ctx context.Context, filePath string)return errors.New("cannot delete root directory")}- fullPath, err := joinBuildRoot(root, cleaned)- if err != nil {- return err- }-- if err := os.RemoveAll(fullPath); err != nil {+ if err := acfs.RemoveAll(ctx, root, cleaned); err != nil {return errors.WrapIf(err, "failed to delete path")}@@ -284,7 +204,7 @@ func (s *BuildWorkspaceService) resolveRoot() (string, error) {return cleaned, nil}-func sanitizeUploadFilename(filename string) (string, error) {+func sanitizeUploadFilenameInternal(filename string) (string, error) {name := strings.TrimSpace(filename)if name == "" {return "", errors.New("invalid filename")@@ -310,38 +230,3 @@ func sanitizeUploadFilename(filename string) (string, error) {return base, nil}--func joinBuildRoot(root, cleaned string) (string, error) {- rel := strings.TrimPrefix(cleaned, "/")- fullPath := filepath.Join(root, filepath.FromSlash(rel))- if !utils.IsWithinRoot(root, fullPath) {- return "", errors.New("invalid path: outside builds directory")- }- if _, err := utils.ResolveWithinRoot(root, fullPath); err != nil {- return "", errors.WrapIf(err, "invalid path: outside builds directory")- }- return fullPath, nil-}--func resolveLinkTarget(root, target string) string {- if target == "" {- return ""- }- if filepath.IsAbs(target) {- targetClean := filepath.Clean(target)- if utils.IsWithinRoot(root, targetClean) {- rel, err := filepath.Rel(root, targetClean)- if err != nil {- return "(external)"- }- rel = filepath.ToSlash(rel)- if rel == "." || rel == "" {- return "/"- }- return "/" + rel- }- return "(external)"- }-- return filepath.ToSlash(target)-}diff --git a/backend/internal/project/workspace.go b/backend/internal/project/workspace.goindex 8db864f54..9b4dadf0f 100644--- a/backend/internal/project/workspace.go+++ b/backend/internal/project/workspace.go@@ -14,9 +14,12 @@ import ("github.com/getarcaneapp/arcane/backend/v2/internal/models""github.com/getarcaneapp/arcane/backend/v2/pkg/projects""github.com/getarcaneapp/arcane/backend/v2/pkg/utils"+ acfsutils "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/acfs"workspacepkg "github.com/getarcaneapp/arcane/backend/v2/pkg/workspace"projecttypes "github.com/getarcaneapp/arcane/types/v2/project"workspacetypes "github.com/getarcaneapp/arcane/types/v2/workspace"+ "go.getarcane.app/acfs"+ acfstypes "go.getarcane.app/acfs/types")func (s *ProjectService) GetProjectWorkspace(ctx context.Context, projectID string) (*workspacetypes.Workspace, error) {@@ -46,7 +49,7 @@ func (s *ProjectService) GetProjectWorkspace(ctx context.Context, projectID stri}func (s *ProjectService) GetProjectWorkspaceFile(ctx context.Context, projectID, relativePath string) (*workspacetypes.FileContent, error) {- proj, rel, fullPath, info, err := s.resolveProjectWorkspacePathInternal(ctx, projectID, relativePath)+ proj, rel, fullPath, entry, err := s.resolveProjectWorkspacePathInternal(ctx, projectID, relativePath)if err != nil {return nil, err}@@ -54,26 +57,31 @@ func (s *ProjectService) GetProjectWorkspaceFile(ctx context.Context, projectID,response := &workspacetypes.FileContent{Path: fullPath,RelativePath: rel,- Name: filepath.Base(fullPath),- Size: info.Size(),+ Name: entry.Name,+ Size: entry.Size,}- if info.IsDir() {+ if entry.IsDirectory {return nil, common.Classify(common.ErrProjectWorkspaceBadRequest, errors.New("workspace path is a directory"))}- if info.Mode()&os.ModeSymlink != 0 {+ if entry.IsSymlink {response.ReadOnlyReason = workspacetypes.FileReadOnlySymlinkreturn response, nil}- if !info.Mode().IsRegular() {+ if !acfsutils.IsRegular(entry) {response.ReadOnlyReason = workspacetypes.FileReadOnlySpecialreturn response, nil}maxBytes := workspacepkg.MaxFileSizeBytes(s.config.ProjectWorkspaceMaxFileSizeMB)- if info.Size() > maxBytes {+ if entry.Size > maxBytes {response.ReadOnlyReason = workspacetypes.FileReadOnlyTooLargereturn response, nil}- content, err := os.ReadFile(fullPath)+ reader, _, err := acfs.OpenRead(ctx, proj.Path, "/"+rel, maxBytes)+ if err != nil {+ return nil, classifyProjectWorkspaceACFSErrorInternal(err, "read project workspace file")+ }+ defer func() { _ = reader.Close() }()+ content, err := io.ReadAll(reader)if err != nil {return nil, errors.WrapIf(err, "read project workspace file")}@@ -88,35 +96,18 @@ func (s *ProjectService) GetProjectWorkspaceFile(ctx context.Context, projectID,}func (s *ProjectService) DownloadProjectWorkspaceFile(ctx context.Context, projectID, relativePath string) (io.ReadCloser, int64, string, error) {- proj, rel, _, info, err := s.resolveProjectWorkspacePathInternal(ctx, projectID, relativePath)+ proj, rel, _, entry, err := s.resolveProjectWorkspacePathInternal(ctx, projectID, relativePath)if err != nil {return nil, 0, "", err}- if info.IsDir() {+ if entry.IsDirectory {return nil, 0, "", common.Classify(common.ErrProjectWorkspaceBadRequest, errors.New("workspace path is a directory"))}- root, err := os.OpenRoot(proj.Path)- if err != nil {- return nil, 0, "", errors.WrapIf(err, "open project workspace")- }- file, err := root.Open(filepath.ToSlash(rel))+ file, size, err := acfs.OpenRead(ctx, proj.Path, "/"+rel, 0)if err != nil {- _ = root.Close()- return nil, 0, "", errors.WrapIf(err, "open project workspace file")+ return nil, 0, "", classifyProjectWorkspaceACFSErrorInternal(err, "open project workspace file")}- return &projectWorkspaceDownloadInternal{ReadCloser: file, root: root}, info.Size(), filepath.Base(rel), nil-}--type projectWorkspaceDownloadInternal struct {- io.ReadCloser-- root *os.Root-}--func (d *projectWorkspaceDownloadInternal) Close() error {- fileErr := d.ReadCloser.Close()- rootErr := d.root.Close()- return errors.Combine(fileErr, rootErr)+ return file, size, filepath.Base(rel), nil}func (s *ProjectService) UpdateProjectWorkspace(ctx context.Context, projectID string, manifest projecttypes.WorkspaceUpdateManifest, uploads map[int][]byte, user models.User) (*workspacetypes.Workspace, error) {@@ -163,14 +154,14 @@ func (s *ProjectService) UpdateProjectWorkspace(ctx context.Context, projectID sreturn s.GetProjectWorkspace(ctx, projectID)}-func (s *ProjectService) resolveProjectWorkspacePathInternal(ctx context.Context, projectID, relativePath string) (*models.Project, string, string, os.FileInfo, error) {+func (s *ProjectService) resolveProjectWorkspacePathInternal(ctx context.Context, projectID, relativePath string) (*models.Project, string, string, acfstypes.Entry, error) {proj, err := s.GetProjectFromDatabaseByID(ctx, projectID)if err != nil {- return nil, "", "", nil, err+ return nil, "", "", acfstypes.Entry{}, err}rel, err := utils.NormalizeRelativePath(relativePath)if err != nil {- return nil, "", "", nil, common.Classify(common.ErrProjectWorkspaceForbidden, errors.WrapIf(err, "invalid project workspace path"))+ return nil, "", "", acfstypes.Entry{}, common.Classify(common.ErrProjectWorkspaceForbidden, errors.WrapIf(err, "invalid project workspace path"))}composeFileName := projects.DefaultComposeFileNameif composeFile, resolveErr := s.ResolveProjectComposeFile(ctx, proj); resolveErr == nil {@@ -179,17 +170,30 @@ func (s *ProjectService) resolveProjectWorkspacePathInternal(ctx context.ContextrootName, _, _ := strings.Cut(rel, "/")protected := projects.ProtectedProjectFilePaths(composeFileName)if protected[rel] || protected[rootName] {- return nil, "", "", nil, common.Classify(common.ErrProjectWorkspaceForbidden, errors.New("project configuration is not part of the workspace"))+ return nil, "", "", acfstypes.Entry{}, common.Classify(common.ErrProjectWorkspaceForbidden, errors.New("project configuration is not part of the workspace"))}fullPath := filepath.Join(proj.Path, filepath.FromSlash(rel))- info, err := os.Lstat(fullPath)+ entry, err := acfs.Stat(ctx, proj.Path, "/"+rel)if err != nil {if os.IsNotExist(err) {- return nil, "", "", nil, common.Classify(common.ErrProjectWorkspaceNotFound, errors.New("project workspace file not found"))+ return nil, "", "", acfstypes.Entry{}, common.Classify(common.ErrProjectWorkspaceNotFound, errors.New("project workspace file not found"))}- return nil, "", "", nil, errors.WrapIf(err, "inspect project workspace file")+ return nil, "", "", acfstypes.Entry{}, classifyProjectWorkspaceACFSErrorInternal(err, "inspect project workspace file")+ }+ return proj, rel, fullPath, entry, nil+}++func classifyProjectWorkspaceACFSErrorInternal(err error, operation string) error {+ switch {+ case errors.Is(err, acfs.ErrInvalidPath),+ errors.Is(err, acfs.ErrOutsideRoot),+ errors.Is(err, acfs.ErrSymlinkLoop):+ return common.Classify(common.ErrProjectWorkspaceForbidden, errors.WrapIf(err, operation))+ case os.IsNotExist(err):+ return common.Classify(common.ErrProjectWorkspaceNotFound, errors.New("project workspace file not found"))+ default:+ return errors.WrapIf(err, operation)}- return proj, rel, fullPath, info, nil}func (s *ProjectService) projectWorkspaceApplyOptionsInternal(ctx context.Context, proj *models.Project, expectedRevision string) projects.ProjectWorkspaceApplyOptions {diff --git a/backend/internal/volume/helper_container.go b/backend/internal/volume/helper_container.goindex 8bb46ecb6..7d8373c8d 100644--- a/backend/internal/volume/helper_container.go+++ b/backend/internal/volume/helper_container.go@@ -3,6 +3,7 @@ package volumeimport ("bytes""context"+ "encoding/json""io""log/slog""strings"@@ -21,6 +22,7 @@ import ("github.com/moby/moby/api/types/container""github.com/moby/moby/client""github.com/samber/mo"+ acfstypes "go.getarcane.app/acfs/types")// volumeHelper tracks a reused helper container and the last@@ -31,6 +33,36 @@ type volumeHelper struct {id stringlastUsedAt time.TimeinUse int+ protocol int+}++func (s *VolumeService) requireVolumeHelperACFSInternal(ctx context.Context, volumeName, containerID string) error {+ s.helperMu.Lock()+ helper := s.helperByVolume[volumeName]+ if helper != nil && helper.id == containerID && helper.protocol >= acfstypes.ProtocolVersion {+ s.helperMu.Unlock()+ return nil+ }+ s.helperMu.Unlock()++ stdout, stderr, err := s.execInContainerInternal(ctx, containerID, []string{"acfs", "version"})+ if err != nil {+ return errors.WrapIf(err, "volume workspace requires an ACFS-capable tools image: "+strings.TrimSpace(stderr))+ }+ var response acfstypes.VersionResponse+ if err := json.Unmarshal([]byte(stdout), &response); err != nil {+ return errors.WrapIf(err, "parse ACFS tools-image capability")+ }+ if response.Protocol < acfstypes.ProtocolVersion {+ return errors.Errorf("volume workspace requires ACFS protocol %d, tools image provides protocol %d", acfstypes.ProtocolVersion, response.Protocol)+ }++ s.helperMu.Lock()+ if helper = s.helperByVolume[volumeName]; helper != nil && helper.id == containerID {+ helper.protocol = response.Protocol+ }+ s.helperMu.Unlock()+ return nil}const volumeHelperImage = volumehelper.DefaultToolsImagediff --git a/backend/internal/volume/workspace.go b/backend/internal/volume/workspace.goindex 04b60469a..d3ddf86c1 100644--- a/backend/internal/volume/workspace.go+++ b/backend/internal/volume/workspace.go@@ -2,19 +2,21 @@ package volumeimport ("archive/tar"+ "bytes""context""crypto/sha256""encoding/hex"+ "encoding/json"stderrors "errors""fmt""io""log/slog""net/http"- "os""path""slices""strconv""strings"+ "sync""time""emperror.dev/errors"@@ -25,61 +27,17 @@ import (dockerutil "github.com/getarcaneapp/arcane/backend/v2/pkg/dockerutil""github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/volumehelper""github.com/getarcaneapp/arcane/backend/v2/pkg/utils"+ acfsutils "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/acfs"workspacepkg "github.com/getarcaneapp/arcane/backend/v2/pkg/workspace"volumetypes "github.com/getarcaneapp/arcane/types/v2/volume"workspacetypes "github.com/getarcaneapp/arcane/types/v2/workspace""github.com/moby/moby/api/types/container""github.com/moby/moby/api/types/mount""github.com/moby/moby/client"+ "go.getarcane.app/acfs"+ acfstypes "go.getarcane.app/acfs/types")-const volumeWorkspaceTreeScriptInternal = `export LC_ALL=C-depth_budget="$1"-entry_budget="$2"-truncated=0-stop=0--walk() {- for full in "$1"/..?* "$1"/.[!.]* "$1"/*; do- case "$stop" in 1) return ;; esac- metadata=$(stat -c '%s|%y|%A' -- "$full" 2>/dev/null) || continue- case "$entry_budget" in '') truncated=1; stop=1; return ;; esac-- name=${full##*/}- case "$2" in '') rel=$name ;; *) rel="$2/$name" ;; esac- size=${metadata%%|*}- metadata=${metadata#*|}- mtime=${metadata%|*}- mode=${metadata##*|}- link=- case "$mode" in- l*) kind=l; link=$(readlink "$full" 2>/dev/null) || link= ;;- d*) kind=d ;;- -*) kind=f ;;- *) kind=s ;;- esac- printf '%s\0%s\0%s\0%s\0%s\0%s\0' "$rel" "$kind" "$size" "$mtime" "$mode" "$link"- entry_budget=${entry_budget#?}-- case "$kind" in- d)- next_depth=${3#?}- case "$next_depth" in- '')- for child in "$full"/..?* "$full"/.[!.]* "$full"/*; do- if stat -c '%A' -- "$child" >/dev/null 2>&1; then truncated=1; break; fi- done- ;;- *) walk "$full" "$rel" "$next_depth" ;;- esac- ;;- esac- done-}--walk /volume '' "$depth_budget"-printf 'ARCANE_TREE_END\0%s\0' "$truncated"`-func (s *VolumeService) GetVolumeWorkspace(ctx context.Context, volumeName string) (*workspacetypes.Workspace, error) {defer s.workspaceLocks.RLock(volumeName)()@@ -100,6 +58,9 @@ func (s *VolumeService) GetVolumeWorkspace(ctx context.Context, volumeName strinreturn nil, err}defer cleanup()+ if err := s.requireVolumeHelperACFSInternal(ctx, volumeName, containerID); err != nil {+ return nil, err+ }slog.DebugContext(ctx, "volume workspace helper acquired", "volume", volumeName, "container_id", containerID, "duration", time.Since(helperStartedAt))scanStartedAt := time.Now()@@ -120,61 +81,99 @@ func (s *VolumeService) readVolumeWorkspaceFromContainerInternal(ctx context.Conif maxEntries <= 0 {maxEntries = 10000}- depthBudget := strings.Repeat("d", maxDepth)- entryBudget := strings.Repeat("e", maxEntries)- stdout, stderr, err := s.execInContainerInternal(ctx, containerID, []string{"sh", "-c", volumeWorkspaceTreeScriptInternal, "sh", depthBudget, entryBudget})++ pipeReader, pipeWriter := io.Pipe()+ dockerClient, err := s.dockerService.GetClient(ctx)if err != nil {- return nil, classifyVolumeWorkspaceExecErrorInternal(err, stderr, "read volume workspace")+ return nil, err}- return parseVolumeWorkspaceTreeInternal(stdout, maxEntries, s.volumeWorkspaceMaxFileSizeBytesInternal())-}+ var stderr bytes.Buffer+ done := make(chan error, 1)+ go func() {+ cmd := []string{+ "acfs", "walk", "--root", "/volume", "--path", "/",+ "--max-depth", strconv.Itoa(maxDepth), "--max-entries", strconv.Itoa(maxEntries),+ }+ exitCode, execErr := dockerutil.ExecInContainer(ctx, dockerClient, containerID, client.ExecCreateOptions{+ AttachStdout: true,+ AttachStderr: true,+ Cmd: cmd,+ }, pipeWriter, &stderr)+ if execErr == nil && exitCode != 0 {+ execErr = errors.Errorf("acfs walk exited with code %d", exitCode)+ }+ _ = pipeWriter.CloseWithError(execErr)+ done <- execErr+ }()-func parseVolumeWorkspaceTreeInternal(stdout string, maxEntries int, configuredMaxFileSizeBytes ...int64) (*workspacetypes.Workspace, error) {- maxFileSizeBytes := workspacepkg.MaxFileSizeBytes(workspacepkg.DefaultMaxFileSizeMB)- if len(configuredMaxFileSizeBytes) == 1 && configuredMaxFileSizeBytes[0] > 0 {- maxFileSizeBytes = configuredMaxFileSizeBytes[0]- }- fields := strings.Split(stdout, "\x00")- if len(fields) > 0 && fields[len(fields)-1] == "" {- fields = fields[:len(fields)-1]+ workspace, parseErr := decodeVolumeWorkspaceWalkInternal(pipeReader, maxEntries, s.volumeWorkspaceMaxFileSizeBytesInternal())+ if parseErr != nil {+ _ = pipeReader.CloseWithError(parseErr)}- if len(fields) < 2 || fields[len(fields)-2] != "ARCANE_TREE_END" || (fields[len(fields)-1] != "0" && fields[len(fields)-1] != "1") {- return nil, errors.New("invalid volume workspace truncation marker")+ execErr := <-done+ _ = pipeReader.Close()+ if execErr != nil {+ return nil, classifyVolumeWorkspaceExecErrorInternal(execErr, stderr.String(), "read volume workspace")}- truncated := fields[len(fields)-1] == "1"- fields = fields[:len(fields)-2]- if len(fields)%6 != 0 {- return nil, errors.New("invalid volume workspace file entry")+ if parseErr != nil {+ return nil, errors.WrapIf(parseErr, "parse volume workspace")}- entries := make([]workspacetypes.FileEntry, 0, min(len(fields)/6, maxEntries+1))- classifications := make(map[string]string, min(len(fields)/6, maxEntries+1))- for i := 0; i+5 < len(fields); i += 6 {- if fields[i] == "" {- continue++ return workspace, nil+}++func decodeVolumeWorkspaceWalkInternal(source io.Reader, maxEntries int, maxFileSizeBytes int64) (*workspacetypes.Workspace, error) {+ decoder := json.NewDecoder(source)+ files := make([]workspacetypes.FileEntry, 0, min(maxEntries, 256))+ classifications := make(map[string]string, min(maxEntries, 256))+ trailerSeen := false+ truncated := false+ for {+ var record acfstypes.WalkRecord+ err := decoder.Decode(&record)+ if stderrors.Is(err, io.EOF) {+ break}- entry, classification, err := parseVolumeWorkspaceEntryInternal(fields[i:i+6], maxFileSizeBytes)if err != nil {return nil, err}- classifications[entry.RelativePath] = classification- entries = append(entries, entry)+ if record.Version != acfstypes.ProtocolVersion {+ return nil, errors.Errorf("unsupported acfs protocol %d", record.Version)+ }+ if trailerSeen {+ return nil, errors.New("acfs walk emitted a record after its trailer")+ }+ if record.End {+ trailerSeen = true+ truncated = record.Truncated+ if record.Count != len(files) {+ return nil, errors.New("acfs walk trailer count does not match emitted entries")+ }+ continue+ }+ if record.Entry == nil {+ return nil, errors.New("acfs walk emitted an empty record")+ }+ if len(files) >= maxEntries {+ return nil, errors.New("acfs walk exceeded the requested entry limit")+ }+ fileEntry, classification := volumeWorkspaceEntryFromACFSInternal(*record.Entry, maxFileSizeBytes)+ classifications[fileEntry.RelativePath] = classification+ files = append(files, fileEntry)+ }+ if !trailerSeen {+ return nil, errors.New("acfs walk ended without a trailer")}- revisionEntries := slices.Clone(entries)+ revisionEntries := slices.Clone(files)slices.SortFunc(revisionEntries, func(a, b workspacetypes.FileEntry) int {return strings.Compare(a.RelativePath, b.RelativePath)})- truncated = truncated || len(entries) > maxEntries- if len(revisionEntries) > maxEntries {- revisionEntries = revisionEntries[:maxEntries]- }- entries = slices.Clone(revisionEntries)-h := sha256.New()for _, entry := range revisionEntries {utils.WriteFileTreeRevisionEntry(h, entry.RelativePath, classifications[entry.RelativePath], entry.Size, entry.ModTime.UnixNano(), entry.Mode, false)}- slices.SortFunc(entries, func(a, b workspacetypes.FileEntry) int {+ slices.SortFunc(files, func(a, b workspacetypes.FileEntry) int {if a.IsDirectory != b.IsDirectory {if a.IsDirectory {return -1@@ -183,75 +182,35 @@ func parseVolumeWorkspaceTreeInternal(stdout string, maxEntries int, configuredM}return strings.Compare(a.RelativePath, b.RelativePath)})-return &workspacetypes.Workspace{- Files: entries,+ Files: files,FileTreeRevision: hex.EncodeToString(h.Sum(nil)),FileTreeTruncated: truncated,}, nil}-func parseVolumeWorkspaceEntryInternal(fields []string, maxFileSizeBytes int64) (workspacetypes.FileEntry, string, error) {- relativePath := fields[0]- size, err := strconv.ParseInt(fields[2], 10, 64)- if err != nil {- return workspacetypes.FileEntry{}, "", errors.WrapIf(err, "parse volume workspace file size")- }- modTime, err := parseVolumeWorkspaceModTimeInternal(fields[3])- if err != nil {- return workspacetypes.FileEntry{}, "", errors.WrapIf(err, "parse volume workspace modification time")- }-- mode := fields[4]- classificationKey := "kind:" + fields[1]- if mode != "" {- classificationKey = "mode:" + mode[:1]- }- classification := "special"- switch classificationKey {- case "kind:d", "mode:d":- classification = "dir"- case "kind:l", "mode:l":- classification = "symlink"- case "kind:f", "mode:-":- classification = "file"- }-- entry := workspacetypes.FileEntry{- ModTime: modTime,- Name: path.Base(relativePath),- Path: "/" + relativePath,- RelativePath: relativePath,- Mode: mode,- LinkTarget: fields[5],- Size: size,- IsDirectory: classification == "dir",- IsSymlink: classification == "symlink",- }- switch classification {- case "dir":- entry.Size = 0- entry.Editable = true- case "symlink":- entry.ReadOnlyReason = workspacetypes.FileReadOnlySymlink- case "special":- entry.ReadOnlyReason = workspacetypes.FileReadOnlySpecial- case "file":- if size > maxFileSizeBytes {- entry.ReadOnlyReason = workspacetypes.FileReadOnlyTooLarge+func volumeWorkspaceEntryFromACFSInternal(entry acfstypes.Entry, maxFileSizeBytes int64) (workspacetypes.FileEntry, string) {+ fileEntry := acfsutils.FileEntry(entry)+ fileEntry.RelativePath = strings.TrimPrefix(entry.Path, "/")+ switch {+ case entry.IsDirectory:+ fileEntry.Size = 0+ fileEntry.Editable = true+ return fileEntry, "dir"+ case entry.IsSymlink:+ fileEntry.ReadOnlyReason = workspacetypes.FileReadOnlySymlink+ return fileEntry, "symlink"+ case acfsutils.IsRegular(entry):+ if entry.Size > maxFileSizeBytes {+ fileEntry.ReadOnlyReason = workspacetypes.FileReadOnlyTooLarge} else {- entry.Editable = true+ fileEntry.Editable = true}+ return fileEntry, "file"+ default:+ fileEntry.ReadOnlyReason = workspacetypes.FileReadOnlySpecial+ return fileEntry, "special"}- return entry, classification, nil-}--func parseVolumeWorkspaceModTimeInternal(value string) (time.Time, error) {- trimmed := strings.TrimSpace(value)- if seconds, err := strconv.ParseFloat(trimmed, 64); err == nil {- return time.Unix(0, int64(seconds*float64(time.Second))), nil- }- return time.Parse("2006-01-02 15:04:05 -0700", trimmed)}func (s *VolumeService) volumeWorkspaceMaxFileSizeBytesInternal() int64 {@@ -276,37 +235,46 @@ func (s *VolumeService) GetVolumeWorkspaceFile(ctx context.Context, volumeName,return nil, err}defer cleanup()- dockerClient, err := s.dockerService.GetClient(ctx)- if err != nil {+ if err := s.requireVolumeHelperACFSInternal(ctx, volumeName, containerID); err != nil {return nil, err}- statResult, err := dockerClient.ContainerStatPath(ctx, containerID, client.ContainerStatPathOptions{Path: path.Join("/volume", rel)})+ stdout, stderr, err := s.execInContainerInternal(ctx, containerID, []string{+ "acfs", "stat", "--root", "/volume", "--path", "/" + rel,+ })if err != nil {- if cerrdefs.IsNotFound(err) {- return nil, common.Classify(common.ErrVolumeWorkspaceNotFound, errors.New("volume workspace file not found"))- }- return nil, errors.WrapIf(err, "inspect volume workspace file")+ return nil, classifyVolumeWorkspaceExecErrorInternal(err, stderr, "inspect volume workspace file")}- stat := statResult.Stat- if stat.Mode&os.ModeSymlink != 0 {- return &workspacetypes.FileContent{Path: "/" + rel, RelativePath: rel, Name: path.Base(rel), Size: stat.Size, ReadOnlyReason: workspacetypes.FileReadOnlySymlink}, nil+ var statResponse acfstypes.StatResponse+ if err := json.Unmarshal([]byte(stdout), &statResponse); err != nil {+ return nil, errors.WrapIf(err, "parse volume workspace stat")}- if stat.Mode.IsDir() {+ if statResponse.Version != acfstypes.ProtocolVersion {+ return nil, errors.Errorf("unsupported acfs protocol %d", statResponse.Version)+ }+ entry := statResponse.Entry+ if entry.IsSymlink {+ return &workspacetypes.FileContent{Path: "/" + rel, RelativePath: rel, Name: path.Base(rel), Size: entry.Size, ReadOnlyReason: workspacetypes.FileReadOnlySymlink}, nil+ }+ if entry.IsDirectory {return nil, common.Classify(common.ErrVolumeWorkspaceBadRequest, errors.New("path is a directory"))}- if !stat.Mode.IsRegular() {- return volumeWorkspaceFileContentResponseInternal(rel, "special", stat.Size, nil, s.volumeWorkspaceMaxFileSizeBytesInternal())+ if !acfsutils.IsRegular(entry) {+ return volumeWorkspaceFileContentResponseInternal(rel, "special", entry.Size, nil, s.volumeWorkspaceMaxFileSizeBytesInternal())}maxFileSizeBytes := s.volumeWorkspaceMaxFileSizeBytesInternal()- if stat.Size > maxFileSizeBytes {- return volumeWorkspaceFileContentResponseInternal(rel, "regular", stat.Size, nil, maxFileSizeBytes)+ if entry.Size > maxFileSizeBytes {+ return volumeWorkspaceFileContentResponseInternal(rel, "regular", entry.Size, nil, maxFileSizeBytes)}- reader, size, err := volumehelper.DownloadFileFromContainer(ctx, dockerClient, containerID, path.Join("/volume", rel), func() {})+ previewLimit := maxFileSizeBytes+ if previewLimit < int64(^uint64(0)>>1) {+ previewLimit+++ }+ reader, size, err := s.startVolumeWorkspaceReadInternal(ctx, containerID, rel, previewLimit, func() {})if err != nil {return nil, errors.WrapIf(err, "read volume workspace file")}- content, readErr := io.ReadAll(io.LimitReader(reader, maxFileSizeBytes+1))+ content, readErr := io.ReadAll(reader)closeErr := reader.Close()if readErr != nil {return nil, errors.WrapIf(readErr, "read volume workspace file content")@@ -314,7 +282,7 @@ func (s *VolumeService) GetVolumeWorkspaceFile(ctx context.Context, volumeName,if closeErr != nil {return nil, errors.WrapIf(closeErr, "close volume workspace file content")}- if int64(len(content)) > maxFileSizeBytes || size > maxFileSizeBytes {+ if size > maxFileSizeBytes {return volumeWorkspaceFileContentResponseInternal(rel, "regular", size, nil, maxFileSizeBytes)}return volumeWorkspaceFileContentResponseInternal(rel, "regular", size, content, maxFileSizeBytes)@@ -340,19 +308,113 @@ func (s *VolumeService) DownloadVolumeWorkspaceFile(ctx context.Context, volumeNcleanup()unlock()}- parent := path.Dir(rel)- if parent != "." {- if err := s.validateVolumeWorkspacePathInternal(ctx, containerID, parent, false); err != nil {- cleanupAndUnlock()- return nil, 0, err+ if err := s.requireVolumeHelperACFSInternal(ctx, volumeName, containerID); err != nil {+ cleanupAndUnlock()+ return nil, 0, err+ }+ return s.startVolumeWorkspaceReadInternal(ctx, containerID, rel, 0, cleanupAndUnlock)+}++type volumeWorkspaceReadStreamInternal struct {+ pipe *io.PipeReader+ done <-chan error+ cleanup func()+ remaining int64+ once sync.Once+ err error+}++func (r *volumeWorkspaceReadStreamInternal) Read(buffer []byte) (int, error) {+ if r.remaining == 0 {+ var extra [1]byte+ read, readErr := r.pipe.Read(extra[:])+ closeErr := r.Close()+ if read != 0 {+ return 0, errors.New("acfs read emitted bytes beyond its framed payload")+ }+ if closeErr != nil {+ return 0, closeErr+ }+ if readErr != nil && !stderrors.Is(readErr, io.EOF) {+ return 0, readErr+ }+ return 0, io.EOF+ }+ if int64(len(buffer)) > r.remaining {+ buffer = buffer[:r.remaining]+ }+ read, err := r.pipe.Read(buffer)+ r.remaining -= int64(read)+ if err != nil && r.remaining > 0 {+ closeErr := r.Close()+ if closeErr != nil {+ return read, stderrors.Join(err, closeErr)}}+ return read, err+}++func (r *volumeWorkspaceReadStreamInternal) Close() error {+ r.once.Do(func() {+ _ = r.pipe.Close()+ r.err = <-r.done+ r.cleanup()+ })+ return r.err+}++func (s *VolumeService) startVolumeWorkspaceReadInternal(ctx context.Context, containerID, relativePath string, limit int64, cleanup func()) (io.ReadCloser, int64, error) {+ pipeReader, pipeWriter := io.Pipe()dockerClient, err := s.dockerService.GetClient(ctx)if err != nil {- cleanupAndUnlock()+ cleanup()return nil, 0, err}- return volumehelper.DownloadFileFromContainer(ctx, dockerClient, containerID, path.Join("/volume", rel), cleanupAndUnlock)+ done := make(chan error, 1)+ cmd := []string{"acfs", "read", "--root", "/volume", "--path", "/" + relativePath}+ if limit > 0 {+ cmd = append(cmd, "--limit", strconv.FormatInt(limit, 10))+ }+ go func() {+ var stderr bytes.Buffer+ exitCode, execErr := dockerutil.ExecInContainer(ctx, dockerClient, containerID, client.ExecCreateOptions{+ AttachStdout: true,+ AttachStderr: true,+ Cmd: cmd,+ }, pipeWriter, &stderr)+ if execErr == nil && exitCode != 0 {+ execErr = errors.Errorf("acfs read exited with code %d", exitCode)+ }+ if execErr != nil {+ execErr = classifyVolumeWorkspaceExecErrorInternal(execErr, stderr.String(), "read volume workspace file")+ }+ _ = pipeWriter.CloseWithError(execErr)+ done <- execErr+ }()++ payloadSize, err := acfs.ReadStreamHeader(pipeReader)+ if err != nil {+ _ = pipeReader.CloseWithError(err)+ execErr := <-done+ cleanup()+ if execErr != nil {+ return nil, 0, execErr+ }+ return nil, 0, errors.WrapIf(err, "parse volume workspace read header")+ }+ if payloadSize > uint64(1<<63-1) {+ _ = pipeReader.Close()+ <-done+ cleanup()+ return nil, 0, errors.New("volume workspace file is too large")+ }+ size := int64(payloadSize)+ return &volumeWorkspaceReadStreamInternal{+ pipe: pipeReader,+ done: done,+ cleanup: cleanup,+ remaining: size,+ }, size, nil}func (s *VolumeService) validateVolumeHelperSupportInternal(ctx context.Context, volumeName string) error {@@ -396,6 +458,30 @@ func volumeWorkspaceFileContentResponseInternal(relativePath, kind string, size}func classifyVolumeWorkspaceExecErrorInternal(err error, stderr, fallbackContext string) error {+ var response acfstypes.ErrorResponse+ if decodeErr := json.Unmarshal([]byte(strings.TrimSpace(stderr)), &response); decodeErr == nil && response.Version == acfstypes.ProtocolVersion {+ switch response.Code {+ case acfstypes.ErrorInvalidPath, acfstypes.ErrorOutsideRoot, acfstypes.ErrorSymlink, acfstypes.ErrorSymlinkLoop:+ return common.Classify(common.ErrVolumeWorkspaceForbidden, errors.New(response.Message))+ case acfstypes.ErrorNotFound:+ return common.Classify(common.ErrVolumeWorkspaceNotFound, errors.New("volume workspace file not found"))+ case acfstypes.ErrorAlreadyExist:+ return common.Classify(common.ErrVolumeWorkspaceBadRequest, errors.New("volume workspace destination already exists"))+ case acfstypes.ErrorNotDirectory:+ return common.Classify(common.ErrVolumeWorkspaceBadRequest, errors.New("volume workspace parent is not a directory"))+ case acfstypes.ErrorNotFile:+ return common.Classify(common.ErrVolumeWorkspaceBadRequest, errors.New("volume workspace path is not a regular file"))+ case acfstypes.ErrorNotEmpty:+ return common.Classify(common.ErrVolumeWorkspaceBadRequest, errors.New("volume directory is not empty; recursive delete is required"))+ case acfstypes.ErrorIsDirectory:+ return common.Classify(common.ErrVolumeWorkspaceBadRequest, errors.New("path is a directory"))+ case acfstypes.ErrorSizeMismatch, acfstypes.ErrorRootRemoval:+ return common.Classify(common.ErrVolumeWorkspaceBadRequest, errors.New(response.Message))+ case acfstypes.ErrorInternal:+ return errors.WrapIf(err, fallbackContext)+ }+ }+message := stderr + " " + err.Error()switch {case strings.Contains(message, "ARCANE_SYMLINK"):@@ -500,6 +586,9 @@ func (s *VolumeService) UpdateVolumeWorkspace(ctx context.Context, volumeName streturn nil, err}defer cleanup()+ if err := s.requireVolumeHelperACFSInternal(ctx, volumeName, containerID); err != nil {+ return nil, err+ }slog.DebugContext(ctx, "volume workspace mutation helper acquired", "volume", volumeName, "container_id", containerID, "dedicated", needsBackups, "duration", time.Since(helperStartedAt))revisionScanStartedAt := time.Now()@@ -540,11 +629,13 @@ func (s *VolumeService) UpdateVolumeWorkspace(ctx context.Context, volumeName stslog.DebugContext(ctx, "volume workspace backup completed", "volume", volumeName, "scope_count", len(scope), "duration", time.Since(backupStartedAt))applyStartedAt := time.Now()- if err := applyVolumeWorkspaceChangesTransactionInternal(+ if err := s.applyVolumeWorkspaceChangesInternal(+ ctx,+ dockerClient,+ containerID,+ volumeName,manifest.FileChanges,- func(index int, change volumetypes.WorkspaceFileChange) error {- return s.applyVolumeWorkspaceChangeInternal(ctx, containerID, change, stagedFiles[index], volumeName)- },+ stagedFiles,func() error { return s.restoreVolumeWorkspaceScopeInternal(ctx, containerID, backup) },); err != nil {return nil, err@@ -591,7 +682,7 @@ func (s *VolumeService) stageVolumeWorkspaceChangesInternal(ctx context.Context,}stagedPath := fmt.Sprintf("/tmp/arcane-workspace/change-%d", index)content := uploads[*change.UploadIndex]- reader := io.NopCloser(strings.NewReader(string(content)))+ reader := io.NopCloser(bytes.NewReader(content))size := int64(len(content))stagedFiles[index] = volumeWorkspaceStagedFileInternal{path: stagedPath, size: size}stagedContents = append(stagedContents, volumeWorkspaceStagedContentInternal{@@ -616,22 +707,138 @@ func validateVolumeWorkspaceRevisionInternal(expected, current string) error {return nil}-func applyVolumeWorkspaceChangesTransactionInternal(+func (s *VolumeService) applyVolumeWorkspaceChangesInternal(+ ctx context.Context,+ dockerClient *client.Client,+ containerID string,+ volumeName string,changes []volumetypes.WorkspaceFileChange,- apply func(int, volumetypes.WorkspaceFileChange) error,+ stagedFiles map[int]volumeWorkspaceStagedFileInternal,rollback func() error,) error {- for index, change := range changes {- if err := apply(index, change); err != nil {- if rollbackErr := rollback(); rollbackErr != nil {- return stderrors.Join(err, errors.WrapIf(rollbackErr, "failed to roll back volume workspace"))+ rollbackFailureInternal := func(applyErr error) error {+ if rollbackErr := rollback(); rollbackErr != nil {+ return stderrors.Join(applyErr, errors.WrapIf(rollbackErr, "failed to roll back volume workspace"))+ }+ return applyErr+ }++ for index := 0; index < len(changes); {+ if changes[index].Operation == volumetypes.FileOpRestoreFile {+ rel, _ := utils.NormalizeRelativePath(changes[index].RelativePath)+ if err := s.restoreVolumeWorkspaceFileInternal(ctx, containerID, volumeName, changes[index].BackupID, rel); err != nil {+ return rollbackFailureInternal(err)}- return err+ index+++ continue+ }++ end := index+ for end < len(changes) && changes[end].Operation != volumetypes.FileOpRestoreFile {+ end++}+ if err := s.executeVolumeWorkspaceACFSBatchInternal(ctx, dockerClient, containerID, changes[index:end], stagedFiles, index); err != nil {+ return rollbackFailureInternal(err)+ }+ index = end}return nil}+func (s *VolumeService) executeVolumeWorkspaceACFSBatchInternal(+ ctx context.Context,+ dockerClient *client.Client,+ containerID string,+ changes []volumetypes.WorkspaceFileChange,+ stagedFiles map[int]volumeWorkspaceStagedFileInternal,+ startIndex int,+) error {+ applyChanges := make([]acfstypes.ApplyChange, 0, len(changes))+ for offset, change := range changes {+ applyChange, err := mapVolumeWorkspaceChangeToACFSInternal(change, stagedFiles[startIndex+offset])+ if err != nil {+ return common.Classify(common.ErrVolumeWorkspaceBadRequest, err)+ }+ applyChanges = append(applyChanges, applyChange)+ }++ manifestContent, err := json.Marshal(acfstypes.ApplyManifest{+ Version: acfstypes.ProtocolVersion,+ Changes: applyChanges,+ })+ if err != nil {+ return errors.WrapIf(err, "encode volume workspace apply manifest")+ }+ manifestName := fmt.Sprintf("manifest-%d.json", startIndex)+ if err := s.copyVolumeWorkspaceFilesToContainerInternal(ctx, dockerClient, containerID, []volumeWorkspaceStagedContentInternal{{+ name: manifestName,+ content: io.NopCloser(bytes.NewReader(manifestContent)),+ size: int64(len(manifestContent)),+ }}); err != nil {+ return err+ }++ stdout, stderr, err := s.execInContainerInternal(ctx, containerID, []string{+ "acfs", "apply", "--root", "/volume", "--staging", "/tmp/arcane-workspace", "--manifest", manifestName,+ })+ if err != nil {+ return classifyVolumeWorkspaceExecErrorInternal(err, stderr, "apply volume workspace changes")+ }+ var response acfstypes.ApplyResponse+ if err := json.Unmarshal([]byte(stdout), &response); err != nil {+ return errors.WrapIf(err, "parse volume workspace apply response")+ }+ if response.Version != acfstypes.ProtocolVersion || response.Applied != len(applyChanges) {+ return errors.New("invalid volume workspace apply response")+ }+ return nil+}++func mapVolumeWorkspaceChangeToACFSInternal(change volumetypes.WorkspaceFileChange, staged volumeWorkspaceStagedFileInternal) (acfstypes.ApplyChange, error) {+ relativePath, err := utils.NormalizeRelativePath(change.RelativePath)+ if err != nil {+ return acfstypes.ApplyChange{}, err+ }+ result := acfstypes.ApplyChange{Path: "/" + relativePath, Recursive: change.Recursive}+ switch change.Operation {+ case volumetypes.FileOpCreateFile:+ result.Operation = acfstypes.ApplyCreateFile+ result.StagedName = path.Base(staged.path)+ result.Size = staged.size+ case volumetypes.FileOpUpdateFile:+ result.Operation = acfstypes.ApplyUpdateFile+ result.StagedName = path.Base(staged.path)+ result.Size = staged.size+ case volumetypes.FileOpCreateFolder:+ result.Operation = acfstypes.ApplyCreateFolder+ result.Recursive = false+ case volumetypes.FileOpRename:+ newName, nameErr := utils.ValidateFileName(change.NewName)+ if nameErr != nil {+ return acfstypes.ApplyChange{}, nameErr+ }+ result.Operation = acfstypes.ApplyRename+ result.TargetPath = "/" + path.Join(path.Dir(relativePath), newName)+ result.Recursive = false+ case volumetypes.FileOpMove:+ parent := ""+ if strings.TrimSpace(change.NewParentPath) != "" {+ parent, err = utils.NormalizeRelativePath(change.NewParentPath)+ if err != nil {+ return acfstypes.ApplyChange{}, err+ }+ }+ result.Operation = acfstypes.ApplyMove+ result.TargetPath = "/" + path.Join(parent, path.Base(relativePath))+ result.Recursive = false+ case volumetypes.FileOpDelete:+ result.Operation = acfstypes.ApplyDelete+ default:+ return acfstypes.ApplyChange{}, errors.Errorf("unsupported volume workspace operation %q", change.Operation)+ }+ return result, nil+}+func validateVolumeWorkspaceFileChangeInternal(change volumetypes.WorkspaceFileChange) error {if _, err := utils.NormalizeRelativePath(change.RelativePath); err != nil {return errors.WrapIf(err, "invalid volume workspace path")@@ -901,169 +1108,6 @@ for rel do rm -rf -- "/volume/$rel"; done`, "sh"}, removePaths...)return nil}-const (- volumeWorkspaceCreateFileScriptInternal = `set -e-target="/volume/$1"-parent=/volume-case "$2" in '') ;; *) parent="/volume/$2" ;; esac-if stat -c '%A' -- "$target" >/dev/null 2>&1; then echo ARCANE_COLLISION >&2; exit 45; fi-if parent_mode=$(stat -c '%A' -- "$parent" 2>/dev/null); then- case "$parent_mode" in- l*) echo ARCANE_SYMLINK >&2; exit 42 ;;- d*) ;;- *) echo ARCANE_NOT_DIRECTORY >&2; exit 47 ;;- esac-fi-mkdir -p -- "$parent"-parent_mode=$(stat -c '%A' -- "$parent" 2>/dev/null) || { echo ARCANE_NOT_DIRECTORY >&2; exit 47; }-case "$parent_mode" in- l*) echo ARCANE_SYMLINK >&2; exit 42 ;;- d*) ;;- *) echo ARCANE_NOT_DIRECTORY >&2; exit 47 ;;-esac-umask 022-set -C-head -c "$4" "$3" > "$target"`- volumeWorkspaceCreateFolderScriptInternal = `set -e-target="/volume/$1"-parent=/volume-case "$2" in '') ;; *) parent="/volume/$2" ;; esac-if stat -c '%A' -- "$target" >/dev/null 2>&1; then echo ARCANE_COLLISION >&2; exit 45; fi-if parent_mode=$(stat -c '%A' -- "$parent" 2>/dev/null); then- case "$parent_mode" in- l*) echo ARCANE_SYMLINK >&2; exit 42 ;;- d*) ;;- *) echo ARCANE_NOT_DIRECTORY >&2; exit 47 ;;- esac-fi-mkdir -p -- "$parent"-parent_mode=$(stat -c '%A' -- "$parent" 2>/dev/null) || { echo ARCANE_NOT_DIRECTORY >&2; exit 47; }-case "$parent_mode" in- l*) echo ARCANE_SYMLINK >&2; exit 42 ;;- d*) ;;- *) echo ARCANE_NOT_DIRECTORY >&2; exit 47 ;;-esac-umask 022-mkdir -m 0755 -- "$target"`- volumeWorkspaceUpdateFileScriptInternal = `set -e-target="/volume/$1"-target_mode=$(stat -c '%A' -- "$target" 2>/dev/null) || { echo ARCANE_NOT_FOUND >&2; exit 44; }-case "$target_mode" in- l*) echo ARCANE_SYMLINK >&2; exit 42 ;;- -*) ;;- *) echo ARCANE_NOT_FILE >&2; exit 46 ;;-esac-head -c "$3" "$2" > "$target"`- volumeWorkspaceRenameScriptInternal = `set -e-source="/volume/$1"-target="/volume/$2"-if stat -c '%A' -- "$target" >/dev/null 2>&1; then echo ARCANE_COLLISION >&2; exit 45; fi-mv -- "$source" "$target"`- volumeWorkspaceMoveScriptInternal = `set -e-source="/volume/$1"-parent="/volume/$2"-target="/volume/$3"-parent_mode=$(stat -c '%A' -- "$parent" 2>/dev/null) || { echo ARCANE_NOT_DIRECTORY >&2; exit 47; }-case "$parent_mode" in d*) ;; *) echo ARCANE_NOT_DIRECTORY >&2; exit 47 ;; esac-if stat -c '%A' -- "$target" >/dev/null 2>&1; then echo ARCANE_COLLISION >&2; exit 45; fi-mv -- "$source" "$target"`- volumeWorkspaceDeleteScriptInternal = `set -e-target="/volume/$1"-case "$2" in- 1) rm -rf -- "$target" ;;- *)- target_mode=$(stat -c '%A' -- "$target" 2>/dev/null) || { echo ARCANE_NOT_FOUND >&2; exit 44; }- case "$target_mode" in- d*) if ! rmdir -- "$target"; then echo ARCANE_NOT_EMPTY >&2; exit 48; fi ;;- *) rm -- "$target" ;;- esac- ;;-esac`-)--func (s *VolumeService) applyVolumeWorkspaceChangeInternal(ctx context.Context, containerID string, change volumetypes.WorkspaceFileChange, stagedFile volumeWorkspaceStagedFileInternal, volumeName string) error {- rel, _ := utils.NormalizeRelativePath(change.RelativePath)- if change.Operation == volumetypes.FileOpRestoreFile {- return s.restoreVolumeWorkspaceFileInternal(ctx, containerID, volumeName, change.BackupID, rel)- }- cmd, err := s.volumeWorkspaceMutationCommandInternal(ctx, containerID, change, stagedFile, rel)- if err != nil {- return err- }- _, stderr, err := s.execInContainerInternal(ctx, containerID, cmd)- if err != nil {- return classifyVolumeWorkspaceExecErrorInternal(err, stderr, "apply volume workspace change")- }- if strings.TrimSpace(stderr) != "" {- slog.DebugContext(ctx, "volume workspace change stderr", "operation", change.Operation, "path", rel, "stderr", strings.TrimSpace(stderr))- }- return nil-}--func (s *VolumeService) volumeWorkspaceMutationCommandInternal(ctx context.Context, containerID string, change volumetypes.WorkspaceFileChange, stagedFile volumeWorkspaceStagedFileInternal, rel string) ([]string, error) {- var cmd []string- parent := path.Dir(rel)- if parent == "." {- parent = ""- }- switch change.Operation {- case volumetypes.FileOpCreateFile:- if err := s.validateVolumeWorkspacePathInternal(ctx, containerID, rel, true); err != nil {- return nil, err- }- cmd = []string{"sh", "-c", volumeWorkspaceCreateFileScriptInternal, "sh", rel, parent, stagedFile.path, strconv.FormatInt(stagedFile.size, 10)}- case volumetypes.FileOpCreateFolder:- if err := s.validateVolumeWorkspacePathInternal(ctx, containerID, rel, true); err != nil {- return nil, err- }- cmd = []string{"sh", "-c", volumeWorkspaceCreateFolderScriptInternal, "sh", rel, parent}- case volumetypes.FileOpUpdateFile:- if err := s.validateVolumeWorkspacePathInternal(ctx, containerID, rel, false); err != nil {- return nil, err- }- cmd = []string{"sh", "-c", volumeWorkspaceUpdateFileScriptInternal, "sh", rel, stagedFile.path, strconv.FormatInt(stagedFile.size, 10)}- case volumetypes.FileOpRename:- newName, _ := utils.ValidateFileName(change.NewName)- target := path.Join(path.Dir(rel), newName)- if target == rel {- return nil, common.Classify(common.ErrVolumeWorkspaceBadRequest, errors.New("new name must change the file path"))- }- if err := s.validateVolumeWorkspacePathInternal(ctx, containerID, rel, false); err != nil {- return nil, err- }- if err := s.validateVolumeWorkspacePathInternal(ctx, containerID, target, true); err != nil {- return nil, err- }- cmd = []string{"sh", "-c", volumeWorkspaceRenameScriptInternal, "sh", rel, target}- case volumetypes.FileOpMove:- parent = ""- if strings.TrimSpace(change.NewParentPath) != "" {- parent, _ = utils.NormalizeRelativePath(change.NewParentPath)- }- target := path.Join(parent, path.Base(rel))- if target == rel || (parent != "" && utils.FilePathMatches(parent, rel)) {- return nil, common.Classify(common.ErrVolumeWorkspaceBadRequest, errors.New("invalid move destination"))- }- if err := s.validateVolumeWorkspacePathInternal(ctx, containerID, rel, false); err != nil {- return nil, err- }- if err := s.validateVolumeWorkspacePathInternal(ctx, containerID, target, true); err != nil {- return nil, err- }- cmd = []string{"sh", "-c", volumeWorkspaceMoveScriptInternal, "sh", rel, parent, target}- case volumetypes.FileOpDelete:- if err := s.validateVolumeWorkspacePathInternal(ctx, containerID, rel, false); err != nil {- return nil, err- }- recursive := "0"- if change.Recursive {- recursive = "1"- }- cmd = []string{"sh", "-c", volumeWorkspaceDeleteScriptInternal, "sh", rel, recursive}- }- return cmd, nil-}-func (s *VolumeService) restoreVolumeWorkspaceFileInternal(ctx context.Context, containerID, volumeName, backupID, rel string) error {if err := s.validateVolumeWorkspacePathInternal(ctx, containerID, rel, true); err != nil {return errdiff --git a/backend/internal/volume/workspace_test.go b/backend/internal/volume/workspace_test.goindex d19997f2a..87f6f3ec8 100644--- a/backend/internal/volume/workspace_test.go+++ b/backend/internal/volume/workspace_test.go@@ -2,8 +2,8 @@ package volumeimport ("archive/tar"+ "bytes""context"- "encoding/base64""encoding/binary""encoding/json""errors"@@ -14,6 +14,7 @@ import ("net/http/httptest""os""os/exec"+ "slices""strconv""strings""testing"@@ -30,6 +31,8 @@ import ("github.com/moby/moby/api/types/volume""github.com/moby/moby/client""github.com/stretchr/testify/require"+ "go.getarcane.app/acfs"+ acfstypes "go.getarcane.app/acfs/types")func newVolumeWorkspaceTestDockerClientInternal(t *testing.T, server *httptest.Server) *client.Client {@@ -168,27 +171,34 @@ func TestDownloadVolumeWorkspaceFileHoldsReadLockUntilClosed(t *testing.T) {"Id": "helper","State": map[string]any{"Running": true},})- case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/containers/helper/archive"):- w.Header().Set("Content-Type", "application/x-tar")- content := []byte("content")- stat, err := json.Marshal(container.PathStat{Name: "file.txt", Size: int64(len(content)), Mode: 0o600})- if err != nil {- t.Errorf("marshal download path stat: %v", err)- return+ case r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/containers/helper/exec"):+ var request struct {+ Cmd []string `json:"Cmd"`}- w.Header().Set("X-Docker-Container-Path-Stat", base64.StdEncoding.EncodeToString(stat))- tarWriter := tar.NewWriter(w)- if err := tarWriter.WriteHeader(&tar.Header{Name: "file.txt", Mode: 0o600, Size: int64(len(content))}); err != nil {- t.Errorf("write download header: %v", err)+ if err := json.NewDecoder(r.Body).Decode(&request); err != nil {+ t.Errorf("decode exec request: %v", err)return}- if _, err := tarWriter.Write(content); err != nil {- t.Errorf("write download content: %v", err)+ wantCommand := []string{"acfs", "read", "--root", "/volume", "--path", "/file.txt"}+ if !slices.Equal(request.Cmd, wantCommand) {+ t.Errorf("unexpected read command: %v", request.Cmd)return}- if err := tarWriter.Close(); err != nil {- t.Errorf("close download archive: %v", err)+ w.Header().Set("Content-Type", "application/json")+ _ = json.NewEncoder(w).Encode(map[string]string{"Id": "read-exec"})+ case r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/exec/read-exec/start"):+ _, _ = io.Copy(io.Discard, r.Body)+ content := []byte("content")+ var output bytes.Buffer+ if err := acfs.WriteStreamHeader(&output, uint64(len(content))); err != nil {+ t.Errorf("write ACFS stream header: %v", err)+ return}+ _, _ = output.Write(content)+ writeDockerExecAttachResponseInternal(t, w, output.String())+ case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/exec/read-exec/json"):+ w.Header().Set("Content-Type", "application/json")+ _ = json.NewEncoder(w).Encode(map[string]any{"Running": false, "ExitCode": 0})default:http.Error(w, "unexpected Docker request: "+r.Method+" "+r.URL.Path, http.StatusInternalServerError)}@@ -198,7 +208,7 @@ func TestDownloadVolumeWorkspaceFileHoldsReadLockUntilClosed(t *testing.T) {service := &VolumeService{dockerService: docker.NewDockerClientService(t.Context(), nil, nil, nil).WithClient(newVolumeWorkspaceTestDockerClientInternal(t, server)),helperByVolume: map[string]*volumeHelper{- "workspace-volume": {id: "helper", lastUsedAt: time.Now()},+ "workspace-volume": {id: "helper", lastUsedAt: time.Now(), protocol: acfstypes.ProtocolVersion},},}reader, size, err := service.DownloadVolumeWorkspaceFile(context.Background(), "workspace-volume", "file.txt")@@ -217,115 +227,6 @@ func TestDownloadVolumeWorkspaceFileHoldsReadLockUntilClosed(t *testing.T) {unlockMutation()}-func volumeWorkspaceTreeRecordInternal(relativePath, kind, size, modTime, mode, linkTarget string) string {- return strings.Join([]string{relativePath, kind, size, modTime, mode, linkTarget}, "\x00") + "\x00"-}--func volumeWorkspaceTreeOutputInternal(truncated bool, records string) string {- marker := "0"- if truncated {- marker = "1"- }- return records + "ARCANE_TREE_END\x00" + marker + "\x00"-}--func TestParseVolumeWorkspaceTreeInternalSortsAndClassifiesFromMode(t *testing.T) {- stdout := volumeWorkspaceTreeOutputInternal(false,- volumeWorkspaceTreeRecordInternal("z.txt", "d", "4", "1700000000.25", "-rw-r--r--", "")+- volumeWorkspaceTreeRecordInternal("folder/link", "f", "7", "1700000001.5", "lrwxrwxrwx", "../z.txt")+- volumeWorkspaceTreeRecordInternal("folder/child.txt", "d", "5", "1700000001.75", "-rw-r--r--", "")+- volumeWorkspaceTreeRecordInternal("folder", "f", "4096", "1700000002", "drwxr-xr-x", "")+- volumeWorkspaceTreeRecordInternal("empty", "f", "4096", "1700000003", "drwx------", "")+- volumeWorkspaceTreeRecordInternal("special", "f", "0", "1700000004", "prw-------", ""))-- workspace, err := parseVolumeWorkspaceTreeInternal(stdout, 10)- require.NoError(t, err)- require.False(t, workspace.FileTreeTruncated)- require.Equal(t, []string{"empty", "folder", "folder/child.txt", "folder/link", "special", "z.txt"}, []string{- workspace.Files[0].RelativePath,- workspace.Files[1].RelativePath,- workspace.Files[2].RelativePath,- workspace.Files[3].RelativePath,- workspace.Files[4].RelativePath,- workspace.Files[5].RelativePath,- })- require.Zero(t, workspace.Files[0].Size)- require.Zero(t, workspace.Files[1].Size)- require.True(t, workspace.Files[0].IsDirectory)- require.True(t, workspace.Files[1].IsDirectory)- require.False(t, workspace.Files[2].IsDirectory)- require.False(t, workspace.Files[3].IsDirectory)- require.False(t, workspace.Files[4].IsDirectory)- require.False(t, workspace.Files[5].IsDirectory)- require.True(t, workspace.Files[3].IsSymlink)- require.Equal(t, "../z.txt", workspace.Files[3].LinkTarget)- require.NotEmpty(t, workspace.FileTreeRevision)-- reordered, err := parseVolumeWorkspaceTreeInternal(volumeWorkspaceTreeOutputInternal(false,- volumeWorkspaceTreeRecordInternal("empty", "d", "4096", "1700000003", "drwx------", "")+- volumeWorkspaceTreeRecordInternal("folder", "d", "4096", "1700000002", "drwxr-xr-x", "")+- volumeWorkspaceTreeRecordInternal("folder/child.txt", "f", "5", "1700000001.75", "-rw-r--r--", "")+- volumeWorkspaceTreeRecordInternal("z.txt", "f", "4", "1700000000.25", "-rw-r--r--", "")+- volumeWorkspaceTreeRecordInternal("special", "s", "0", "1700000004", "prw-------", "")+- volumeWorkspaceTreeRecordInternal("folder/link", "l", "7", "1700000001.5", "lrwxrwxrwx", "../z.txt")), 10)- require.NoError(t, err)- require.Equal(t, workspace.FileTreeRevision, reordered.FileTreeRevision)-}--func TestParseVolumeWorkspaceTreeInternalFallsBackToKindWithoutMode(t *testing.T) {- workspace, err := parseVolumeWorkspaceTreeInternal(volumeWorkspaceTreeOutputInternal(false,- volumeWorkspaceTreeRecordInternal("folder", "d", "4096", "1", "", "")+- volumeWorkspaceTreeRecordInternal("link", "l", "3", "2", "", "folder")+- volumeWorkspaceTreeRecordInternal("regular", "f", "4", "3", "", "")), 10)- require.NoError(t, err)- require.True(t, workspace.Files[0].IsDirectory)- require.Zero(t, workspace.Files[0].Size)- require.True(t, workspace.Files[1].IsSymlink)-- special, err := parseVolumeWorkspaceTreeInternal(volumeWorkspaceTreeOutputInternal(false,- volumeWorkspaceTreeRecordInternal("folder", "d", "4096", "1", "", "")+- volumeWorkspaceTreeRecordInternal("link", "l", "3", "2", "", "folder")+- volumeWorkspaceTreeRecordInternal("regular", "s", "4", "3", "", "")), 10)- require.NoError(t, err)- require.NotEqual(t, workspace.FileTreeRevision, special.FileTreeRevision)-}--func TestParseVolumeWorkspaceTreeInternalReportsBothLimits(t *testing.T) {- entries := volumeWorkspaceTreeRecordInternal("b", "f", "1", "1", "-rw-r--r--", "") +- volumeWorkspaceTreeRecordInternal("a", "f", "1", "1", "-rw-r--r--", "")-- depthLimited, err := parseVolumeWorkspaceTreeInternal(volumeWorkspaceTreeOutputInternal(true, entries), 10)- require.NoError(t, err)- require.True(t, depthLimited.FileTreeTruncated)-- entryLimited, err := parseVolumeWorkspaceTreeInternal(volumeWorkspaceTreeOutputInternal(false, entries), 1)- require.NoError(t, err)- require.True(t, entryLimited.FileTreeTruncated)- require.Len(t, entryLimited.Files, 1)- require.Equal(t, "a", entryLimited.Files[0].RelativePath)-- _, err = parseVolumeWorkspaceTreeInternal(entries+"invalid\x000\x00", 10)- require.Error(t, err)-}--func TestParseVolumeWorkspaceModTimeInternalPreservesNanoseconds(t *testing.T) {- modTime, err := parseVolumeWorkspaceModTimeInternal("2026-08-02 16:09:00.123456789 +0000")- require.NoError(t, err)- require.Equal(t, 123456789, modTime.Nanosecond())-}--func TestParseVolumeWorkspaceTreeInternalPreservesUnusualNamesAndSpecialFiles(t *testing.T) {- workspace, err := parseVolumeWorkspaceTreeInternal(volumeWorkspaceTreeOutputInternal(false,- volumeWorkspaceTreeRecordInternal(".hidden", "f", "1", "1", "-rw-r--r--", "")+- volumeWorkspaceTreeRecordInternal("line\nbreak", "s", "0", "2", "prw-------", "")), 10)- require.NoError(t, err)- require.Equal(t, []string{".hidden", "line\nbreak"}, []string{- workspace.Files[0].RelativePath,- workspace.Files[1].RelativePath,- })- require.NotEmpty(t, workspace.FileTreeRevision)-}-func TestVolumeWorkspaceFileContentResponseInternal(t *testing.T) {const maxFileSizeBytes int64 = 10 * 1024 * 1024text := []byte("hello")@@ -418,15 +319,8 @@ func TestVolumeWorkspaceRollbackPathsInternalRemovesDeepestFirst(t *testing.T) {func TestVolumeWorkspaceHelperScriptsUseSupportedTooling(t *testing.T) {helperScripts := []string{- volumeWorkspaceTreeScriptInternal,volumeWorkspaceValidatePathScriptInternal,volumeWorkspaceBackupCreateScriptInternal,- volumeWorkspaceCreateFileScriptInternal,- volumeWorkspaceCreateFolderScriptInternal,- volumeWorkspaceUpdateFileScriptInternal,- volumeWorkspaceRenameScriptInternal,- volumeWorkspaceMoveScriptInternal,- volumeWorkspaceDeleteScriptInternal,restoreBackupFilesScriptInternal,}scripts := strings.Join(helperScripts, "\n")@@ -449,9 +343,6 @@ func TestVolumeWorkspaceHelperScriptsUseSupportedTooling(t *testing.T) {} {require.NotContains(t, scripts, unsupported)}- require.Contains(t, volumeWorkspaceCreateFileScriptInternal, "head -c")- require.Contains(t, volumeWorkspaceCreateFolderScriptInternal, "mkdir -m 0755")- require.Contains(t, volumeWorkspaceUpdateFileScriptInternal, "head -c")require.Contains(t, volumeWorkspaceBackupCreateScriptInternal, `printf 'absent\0%s\0'`)require.Contains(t, volumeWorkspaceBackupCreateScriptInternal, `cd "$parent"`)require.NotContains(t, volumeWorkspaceBackupCreateScriptInternal, " -C ")@@ -594,11 +485,15 @@ func TestUpdateVolumeWorkspaceRejectsStaleRevisionBeforeStaging(t *testing.T) {}execCommands = append(execCommands, request.Cmd)w.Header().Set("Content-Type", "application/json")- _ = json.NewEncoder(w).Encode(map[string]string{"Id": "tree-exec"})- case r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/exec/tree-exec/start"):+ _ = json.NewEncoder(w).Encode(map[string]string{"Id": fmt.Sprintf("workspace-exec-%d", len(execCommands)-1)})+ case r.Method == http.MethodPost && strings.Contains(r.URL.Path, "/exec/workspace-exec-") && strings.HasSuffix(r.URL.Path, "/start"):_, _ = io.Copy(io.Discard, r.Body)- writeDockerExecAttachResponseInternal(t, w, volumeWorkspaceTreeOutputInternal(false, ""))- case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/exec/tree-exec/json"):+ output := "{\"version\":\"0.2.0\",\"revision\":\"test\",\"buildTime\":\"test\",\"protocol\":2}\n"+ if strings.Contains(r.URL.Path, "workspace-exec-1") {+ output = "{\"end\":true,\"version\":2}\n"+ }+ writeDockerExecAttachResponseInternal(t, w, output)+ case r.Method == http.MethodGet && strings.Contains(r.URL.Path, "/exec/workspace-exec-") && strings.HasSuffix(r.URL.Path, "/json"):w.Header().Set("Content-Type", "application/json")_ = json.NewEncoder(w).Encode(map[string]any{"Running": false, "ExitCode": 0})case r.Method == http.MethodPut && strings.HasSuffix(r.URL.Path, "/containers/helper/archive"):@@ -627,8 +522,9 @@ func TestUpdateVolumeWorkspaceRejectsStaleRevisionBeforeStaging(t *testing.T) {require.Nil(t, workspace)require.ErrorIs(t, err, common.ErrVolumeWorkspaceConflict)- require.Len(t, execCommands, 1)- require.Contains(t, execCommands[0], volumeWorkspaceTreeScriptInternal)+ require.Len(t, execCommands, 2)+ require.Equal(t, []string{"acfs", "version"}, execCommands[0])+ require.Equal(t, []string{"acfs", "walk", "--root", "/volume", "--path", "/", "--max-depth", "50", "--max-entries", "10000"}, execCommands[1])require.Zero(t, archiveCopies)}@@ -695,43 +591,6 @@ func TestCreateVolumeWorkspaceMutationContainerUsesDedicatedBackupHelper(t *testrequire.Equal(t, 1, removeCalls)}-func TestApplyVolumeWorkspaceChangesTransactionInternalRollsBackEveryMutationStage(t *testing.T) {- changes := []volumetypes.WorkspaceFileChange{- {Operation: volumetypes.FileOpCreateFolder, RelativePath: "one"},- {Operation: volumetypes.FileOpRename, RelativePath: "one", NewName: "two"},- {Operation: volumetypes.FileOpDelete, RelativePath: "two", Recursive: true},- }- applyFailure := errors.New("apply failed")- for failureIndex := range changes {- t.Run(changes[failureIndex].Operation, func(t *testing.T) {- applied := make([]int, 0, failureIndex+1)- rollbackCalls := 0- err := applyVolumeWorkspaceChangesTransactionInternal(changes, func(index int, _ volumetypes.WorkspaceFileChange) error {- applied = append(applied, index)- if index == failureIndex {- return applyFailure- }- return nil- }, func() error {- rollbackCalls++- return nil- })- require.ErrorIs(t, err, applyFailure)- require.Equal(t, failureIndex+1, len(applied))- require.Equal(t, 1, rollbackCalls)- })- }-- rollbackFailure := errors.New("rollback failed")- err := applyVolumeWorkspaceChangesTransactionInternal(changes, func(_ int, _ volumetypes.WorkspaceFileChange) error {- return applyFailure- }, func() error {- return rollbackFailure- })- require.ErrorIs(t, err, applyFailure)- require.ErrorIs(t, err, rollbackFailure)-}-func TestVolumeWorkspaceScriptsAgainstToolsImage(t *testing.T) {if os.Getenv("ARCANE_VOLUME_WORKSPACE_DOCKER_TEST") != "1" {t.Skip("set ARCANE_VOLUME_WORKSPACE_DOCKER_TEST=1 to run the helper image integration test")@@ -766,41 +625,29 @@ func TestVolumeWorkspaceScriptsAgainstToolsImage(t *testing.T) {printf child > /volume/folder/nested/child.txtprintf hidden > /volume/.hiddenprintf alpha > /volume/z.txt`)- treeOutput := runInVolume(volumeName, `sh -c "$1" sh "$2" "$3"`, volumeWorkspaceTreeScriptInternal, strings.Repeat("d", 5), strings.Repeat("e", 100))- workspace, err := parseVolumeWorkspaceTreeInternal(treeOutput, 100)- require.NoError(t, err)- require.Equal(t, []string{"folder", "folder/nested", ".hidden", "folder/nested/child.txt", "z.txt"}, []string{- workspace.Files[0].RelativePath,- workspace.Files[1].RelativePath,- workspace.Files[2].RelativePath,- workspace.Files[3].RelativePath,- workspace.Files[4].RelativePath,- })- require.True(t, workspace.Files[0].IsDirectory)- require.True(t, workspace.Files[1].IsDirectory)- require.False(t, workspace.Files[2].IsDirectory)- require.False(t, workspace.Files[3].IsDirectory)- require.False(t, workspace.Files[4].IsDirectory)-- runInVolume(volumeName, `sh -c "$1" sh folder/nested/child.txt 0`, volumeWorkspaceValidatePathScriptInternal)- runInVolume(volumeName, `sh -c "$1" sh missing/path 1`, volumeWorkspaceValidatePathScriptInternal)- runInVolume(volumeName, `sh -c "$1" sh nested ''`, volumeWorkspaceCreateFolderScriptInternal)- runInVolume(volumeName, `printf one > /tmp/staged-sh -c "$1" sh nested/a.txt nested /tmp/staged 3`, volumeWorkspaceCreateFileScriptInternal)+ treeOutput := runInVolume(volumeName, `acfs walk --root /volume --path / --max-depth 5 --max-entries 100`)+ require.Contains(t, treeOutput, `"path":"/folder/nested/child.txt"`)+ require.Contains(t, treeOutput, `"path":"/.hidden"`)+ require.Contains(t, treeOutput, `"end":true`)++ runInVolume(volumeName, `set -e+mkdir -p /tmp/staging+printf one > /tmp/staging/change-0+printf '%s' '{"changes":[{"operation":"create_folder","path":"/nested"},{"operation":"create_file","path":"/nested/a.txt","stagedName":"change-0","size":3}],"version":2}' > /tmp/staging/manifest.json+acfs apply --root /volume --staging /tmp/staging --manifest manifest.json >/dev/null`)require.Equal(t, "644 3\n", runInVolume(volumeName, `stat -c '%a %s' /volume/nested/a.txt`))- runInVolume(volumeName, `printf updated > /tmp/staged-sh -c "$1" sh nested/a.txt /tmp/staged 7`, volumeWorkspaceUpdateFileScriptInternal)- require.Equal(t, "updated", runInVolume(volumeName, `head -c 7 /volume/nested/a.txt`))-- runInVolume(volumeName, `sh -c "$1" sh nested/a.txt nested/b.txt`, volumeWorkspaceRenameScriptInternal)- runInVolume(volumeName, `sh -c "$1" sh dest ''`, volumeWorkspaceCreateFolderScriptInternal)- runInVolume(volumeName, `sh -c "$1" sh nested/b.txt dest dest/b.txt`, volumeWorkspaceMoveScriptInternal)+ runInVolume(volumeName, `set -e+mkdir -p /tmp/staging+printf updated > /tmp/staging/change-0+printf '%s' '{"changes":[{"operation":"update_file","path":"/nested/a.txt","stagedName":"change-0","size":7},{"operation":"rename","path":"/nested/a.txt","targetPath":"/nested/b.txt"},{"operation":"create_folder","path":"/dest"},{"operation":"move","path":"/nested/b.txt","targetPath":"/dest/b.txt"}],"version":2}' > /tmp/staging/manifest.json+acfs apply --root /volume --staging /tmp/staging --manifest manifest.json >/dev/null`)+ require.Equal(t, "updated", runInVolume(volumeName, `head -c 7 /volume/dest/b.txt`))restored := runInVolume(volumeName, `set -esh -c "$1" sh dest/b.txt /tmp/backup.tar >/dev/null-sh -c "$2" sh dest/b.txt 0+acfs remove --root /volume --path /dest/b.txttar -xf /tmp/backup.tar -C /volume/dest-head -c 7 /volume/dest/b.txt`, volumeWorkspaceBackupCreateScriptInternal, volumeWorkspaceDeleteScriptInternal)+head -c 7 /volume/dest/b.txt`, volumeWorkspaceBackupCreateScriptInternal)require.Equal(t, "updated", restored)runInVolume(volumeName, `mkdir -p "/volume/Test Folder"diff --git a/backend/pkg/libarcane/volumehelper/container_files.go b/backend/pkg/libarcane/volumehelper/container_files.goindex 9e6cc1780..82050fe5d 100644--- a/backend/pkg/libarcane/volumehelper/container_files.go+++ b/backend/pkg/libarcane/volumehelper/container_files.go@@ -4,13 +4,9 @@ import ("archive/tar""context""io"- "strings""emperror.dev/errors"- "github.com/moby/moby/api/types/container""github.com/moby/moby/client"-- "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane")type cleanupReadCloserInternal struct {@@ -20,36 +16,6 @@ type cleanupReadCloserInternal struct {cleanup func()}-func IsLegacyHelperContainer(c container.Summary) bool {- if !libarcane.IsInternalContainer(c.Labels) {- return false- }-- command := strings.ToLower(c.Command)- if !strings.Contains(command, "sleep") || !strings.Contains(command, "infinity") {- return false- }-- for _, m := range c.Mounts {- if m.Destination == "/volume" {- return true- }- }-- return false-}--func IsHelperContainer(c container.Summary) bool {- if IsLegacyHelperContainer(c) {- return true- }- if !libarcane.IsInternalContainer(c.Labels) {- return false- }-- return strings.EqualFold(c.Labels[ContainerLabel], "true")-}-func (c *cleanupReadCloserInternal) Close() error {err := c.Closer.Close()c.cleanup()diff --git a/backend/pkg/libarcane/volumehelper/container_files_test.go b/backend/pkg/libarcane/volumehelper/container_files_test.goindex e28932a61..e693fb7c5 100644--- a/backend/pkg/libarcane/volumehelper/container_files_test.go+++ b/backend/pkg/libarcane/volumehelper/container_files_test.go@@ -4,10 +4,7 @@ import ("archive/tar""testing"- "github.com/moby/moby/api/types/container""github.com/stretchr/testify/require"-- "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane")func TestValidateDownloadHeaderInternalRejectsDirectories(t *testing.T) {@@ -16,94 +13,3 @@ func TestValidateDownloadHeaderInternalRejectsDirectories(t *testing.T) {require.NoError(t, validateDownloadHeaderInternal(&tar.Header{Typeflag: tar.TypeSymlink, Mode: 0o777}))require.NoError(t, validateDownloadHeaderInternal(&tar.Header{Typeflag: tar.TypeFifo, Mode: 0o644}))}--func TestIsLegacyVolumeHelperContainerInternal(t *testing.T) {- tests := []struct {- name string- summary container.Summary- want bool- }{- {- name: "legacy helper signature matches",- summary: container.Summary{- Labels: map[string]string{- libarcane.InternalResourceLabel: "true",- },- Command: "sleep infinity",- Mounts: []container.MountPoint{- {Destination: "/volume"},- },- },- want: true,- },- {- name: "internal trivy-like helper is not treated as legacy volume helper",- summary: container.Summary{- Labels: map[string]string{- libarcane.InternalResourceLabel: "true",- },- Command: "trivy image --quiet alpine:latest",- Mounts: []container.MountPoint{- {Destination: "/var/run/docker.sock"},- },- },- want: false,- },- }-- for _, tt := range tests {- t.Run(tt.name, func(t *testing.T) {- require.Equal(t, tt.want, IsLegacyHelperContainer(tt.summary))- })- }-}--func TestIsVolumeHelperContainerInternal_UsesExplicitHelperLabel(t *testing.T) {- tests := []struct {- name string- summary container.Summary- want bool- }{- {- name: "new helper label matches",- summary: container.Summary{- Labels: map[string]string{- libarcane.InternalResourceLabel: "true",- ContainerLabel: "true",- },- },- want: true,- },- {- name: "generic internal volume mount does not match",- summary: container.Summary{- Labels: map[string]string{- libarcane.InternalResourceLabel: "true",- },- Mounts: []container.MountPoint{- {Destination: "/volume"},- },- },- want: false,- },- {- name: "legacy helper still matches",- summary: container.Summary{- Labels: map[string]string{- libarcane.InternalResourceLabel: "true",- },- Command: "sleep infinity",- Mounts: []container.MountPoint{- {Destination: "/volume"},- },- },- want: true,- },- }-- for _, tt := range tests {- t.Run(tt.name, func(t *testing.T) {- require.Equal(t, tt.want, IsHelperContainer(tt.summary))- })- }-}diff --git a/backend/pkg/projects/includes.go b/backend/pkg/projects/includes.goindex 04a28c303..81abdbafa 100644--- a/backend/pkg/projects/includes.go+++ b/backend/pkg/projects/includes.go@@ -8,7 +8,6 @@ import ("emperror.dev/errors"- pkgutils "github.com/getarcaneapp/arcane/backend/v2/pkg/utils""github.com/samber/mo""go.yaml.in/yaml/v4")@@ -29,7 +28,7 @@ func expandEnvVarsInternal(s string, envMap EnvMap) string {// the compose file points at. Callers must validate containment and symlinks before// reading include content or returning inc.Content to users.// - WRITE/DELETE: Restricted to files within the project directory only for security.-// Always go through ValidateIncludePathForWrite or WriteIncludeFile.+// Always go through ValidateIncludePathForWrite.type IncludeFile struct {Path string `json:"path"`@@ -338,30 +337,3 @@ func ValidateIncludePathForWrite(projectDir, includePath string) (string, error)return absFullPath, nil}--// WriteIncludeFile writes content to an include file path-func WriteIncludeFile(projectDir, includePath, content string) error {- // Get validated absolute path - only allows writes within project- validatedPath, err := ValidateIncludePathForWrite(projectDir, includePath)- if err != nil {- return err- }-- dir := filepath.Dir(validatedPath)- if dir == "" || dir == "." {- return errors.Errorf("invalid include path: cannot create directory '%s'", dir)- }-- // Only create directory if it doesn't exist- if _, err := os.Stat(dir); errors.Is(err, os.ErrNotExist) {- if err := os.MkdirAll(dir, pkgutils.DirPerm); err != nil {- return errors.WrapIf(err, "failed to create directory")- }- }-- if err := os.WriteFile(validatedPath, []byte(content), pkgutils.FilePerm); err != nil {- return errors.WrapIf(err, "failed to write include file")- }-- return nil-}diff --git a/backend/pkg/projects/includes_test.go b/backend/pkg/projects/includes_test.goindex 026853355..2a52d497b 100644--- a/backend/pkg/projects/includes_test.go+++ b/backend/pkg/projects/includes_test.go@@ -6,8 +6,6 @@ import ("runtime""testing"- pkgutils "github.com/getarcaneapp/arcane/backend/v2/pkg/utils"- "github.com/stretchr/testify/assert""github.com/stretchr/testify/require")@@ -68,78 +66,7 @@ func TestParseIncludes_ExpandsArrayPathForm(t *testing.T) {}-func TestWriteIncludeFilePermissions(t *testing.T) {- // Save original perms- origFilePerm := pkgutils.FilePerm- origDirPerm := pkgutils.DirPerm- defer func() {- pkgutils.FilePerm = origFilePerm- pkgutils.DirPerm = origDirPerm- }()-- projectDir := t.TempDir()- includePath := filepath.Join("includes", "config.yaml")- content := "services: {}\n"-- t.Run("Uses custom permissions", func(t *testing.T) {- pkgutils.FilePerm = 0o600- pkgutils.DirPerm = 0o700- {-- err := WriteIncludeFile(projectDir, includePath, content)- require.NoError(t, err,- "WriteIncludeFile() returned error: %v", err)- }-- targetPath := filepath.Join(projectDir, includePath)- info, err := os.Stat(targetPath)-- require.NoError(t, err,- "failed to stat include file: %v", err)-- // On Linux/macOS, we can check permissions. On Windows, it's more limited.- if runtime.GOOS != "windows" {-- assert.Equal(t, os.FileMode(0o600), info.Mode().Perm(),- "unexpected file permissions: got %o, want %o", info.Mode().Perm(), 0o600)-- dirInfo, err := os.Stat(filepath.Dir(targetPath))-- require.NoError(t, err,- "failed to stat include directory: %v", err)-- assert.Equal(t, os.FileMode(0o700), dirInfo.Mode().Perm(),- "unexpected directory permissions: got %o, want %o", dirInfo.Mode().Perm(), 0o700)-- }- })-}--func TestWriteIncludeFileCreatesSafeDirectory(t *testing.T) {- t.Parallel()-- projectDir := t.TempDir()- includePath := filepath.Join("includes", "config.yaml")- content := "services: {}\n"- {-- err := WriteIncludeFile(projectDir, includePath, content)- require.NoError(t, err,- "WriteIncludeFile() returned error: %v", err)- }-- targetPath := filepath.Join(projectDir, includePath)- data, err := os.ReadFile(targetPath)-- require.NoError(t, err,- "failed to read include file: %v", err)-- require.Equal(t, content, string(data),- "unexpected file content: got %q, want %q", string(data), content)--}--func TestWriteIncludeFileRejectsSymlinkEscape(t *testing.T) {+func TestValidateIncludePathForWriteRejectsSymlinkEscape(t *testing.T) {if runtime.GOOS == "windows" {t.Skip("symlink creation requires elevated privileges on Windows")}@@ -149,16 +76,9 @@ func TestWriteIncludeFileRejectsSymlinkEscape(t *testing.T) {outsideDir := t.TempDir()linkPath := filepath.Join(projectDir, "link")- {- err := os.Symlink(outsideDir, linkPath)- require.NoError(t, err,- "failed to create symlink: %v", err)- }+ require.NoError(t, os.Symlink(outsideDir, linkPath), "failed to create symlink")includePath := filepath.Join("link", "escape.yaml")- err := WriteIncludeFile(projectDir, includePath, "malicious: true\n")-- require.Error(t, err,- "WriteIncludeFile() succeeded but expected rejection for symlink escape")-+ _, err := ValidateIncludePathForWrite(projectDir, includePath)+ require.Error(t, err, "ValidateIncludePathForWrite() succeeded but expected rejection for symlink escape")}diff --git a/backend/pkg/utils/acfs/entry.go b/backend/pkg/utils/acfs/entry.gonew file mode 100644index 000000000..dc92907d7--- /dev/null+++ b/backend/pkg/utils/acfs/entry.go@@ -0,0 +1,35 @@+// Package acfs maps ACFS protocol types to Arcane workspace contracts.+package acfs++import (+ "strings"+ "time"++ "github.com/getarcaneapp/arcane/types/v2/workspace"+ acfstypes "go.getarcane.app/acfs/types"+)++// FileEntry converts ACFS metadata to Arcane's shared workspace entry type.+func FileEntry(entry acfstypes.Entry) workspace.FileEntry {+ modTime := entry.ModTime+ if entry.ModTimeUnixNano != 0 {+ modTime = time.Unix(0, entry.ModTimeUnixNano)+ }++ return workspace.FileEntry{+ ModTime: modTime,+ Name: entry.Name,+ Path: entry.Path,+ RelativePath: entry.Path,+ Mode: entry.Mode,+ LinkTarget: entry.LinkTarget,+ Size: entry.Size,+ IsDirectory: entry.IsDirectory,+ IsSymlink: entry.IsSymlink,+ }+}++// IsRegular reports whether an ACFS entry describes a regular file.+func IsRegular(entry acfstypes.Entry) bool {+ return !entry.IsDirectory && !entry.IsSymlink && strings.HasPrefix(entry.Mode, "-")+}diff --git a/backend/pkg/utils/path_util.go b/backend/pkg/utils/path_util.goindex 9794911c6..e2aba30cf 100644--- a/backend/pkg/utils/path_util.go+++ b/backend/pkg/utils/path_util.go@@ -1,15 +1,12 @@package utilsimport (- "bytes""hash""io"- "os""path""path/filepath""strconv""strings"- "unicode/utf8""emperror.dev/errors")@@ -69,10 +66,6 @@ func FilePathMatches(relativePath, rootPath string) bool {return relativePath == rootPath || strings.HasPrefix(relativePath, rootPath+"/")}-func IsBinaryFileContent(content []byte) bool {- return !utf8.Valid(content) || bytes.IndexByte(content, 0) >= 0-}-func WriteFileTreeRevisionEntry(h hash.Hash, relativePath, kind string, size, modTimeUnixNano int64, mode string, protected bool) {protectedFlag := ""if protected {@@ -90,50 +83,6 @@ func WriteFileTreeRevisionEntry(h hash.Hash, relativePath, kind string, size, mo_, _ = h.Write([]byte{'\n'})}-// IsWithinRoot reports whether target is root or lies beneath it. Both paths are-// cleaned first; neither is resolved, so this only proves the *spelling* of the-// path stays inside root. Use ResolveWithinRoot when a symlink could redirect it.-func IsWithinRoot(root, target string) bool {- rootClean := filepath.Clean(root)- targetClean := filepath.Clean(target)- if targetClean == rootClean {- return true- }- return strings.HasPrefix(targetClean, rootClean+string(os.PathSeparator))-}--// ResolveWithinRoot resolves symlinks in both root and target and returns the-// resolved target, verifying it stays inside root. A target that does not exist-// yet is allowed: its parent is resolved instead, so create/write paths work.-//-// This is the check that makes containment real. A lexical test alone accepts a-// symlink that sits inside root but points at /etc, which is then read, written-// or removed through as if it were an in-root file.-func ResolveWithinRoot(root, target string) (string, error) {- resolvedRoot, err := filepath.EvalSymlinks(filepath.Clean(root))- if err != nil {- return "", errors.WrapIff(err, "failed to resolve root directory %q", root)- }-- cleanTarget := filepath.Clean(target)- resolved, err := filepath.EvalSymlinks(cleanTarget)- if err != nil {- if !os.IsNotExist(err) {- return "", errors.WrapIff(err, "failed to resolve path %q", target)- }- resolvedParent, parentErr := filepath.EvalSymlinks(filepath.Dir(cleanTarget))- if parentErr != nil {- return "", errors.WrapIff(parentErr, "failed to resolve parent directory of %q", target)- }- resolved = filepath.Join(resolvedParent, filepath.Base(cleanTarget))- }-- if !IsWithinRoot(resolvedRoot, resolved) {- return "", errors.Errorf("path %q resolves outside %q", target, root)- }- return resolved, nil-}-// SanitizeBrowsePath normalizes a path within a rooted file browser.func SanitizeBrowsePath(input string) (string, error) {trimmed := strings.TrimSpace(input)diff --git a/backend/pkg/utils/path_util_test.go b/backend/pkg/utils/path_util_test.goindex ae35aec8c..68ca74a37 100644--- a/backend/pkg/utils/path_util_test.go+++ b/backend/pkg/utils/path_util_test.go@@ -3,7 +3,6 @@ package utilsimport ("crypto/sha256""encoding/hex"- "strings""testing""github.com/stretchr/testify/require"@@ -33,8 +32,6 @@ func TestFileTreeRevisionEntryIsStable(t *testing.T) {h := sha256.New()WriteFileTreeRevisionEntry(h, "folder/file.txt", "file", 12, 1234, "-rw-r--r--", false)require.Equal(t, "95f6a8dc033860a753fee2a04a21580d43087967d732a717d3e7a18f88ea4f65", hex.EncodeToString(h.Sum(nil)))- require.False(t, IsBinaryFileContent([]byte(strings.Repeat("a", 8))))- require.True(t, IsBinaryFileContent([]byte{'a', 0, 'b'}))}func TestSanitizeBrowsePath(t *testing.T) {diff --git a/go.work.sum b/go.work.sumindex adf0542da..76a383d33 100644--- a/go.work.sum+++ b/go.work.sum@@ -2015,6 +2015,8 @@ go.etcd.io/gofail v0.2.0 h1:p19drv16FKK345a09a1iubchlw/vmRuksmRzgBIGjcA=go.etcd.io/gofail v0.2.0/go.mod h1:nL3ILMGfkXTekKI3clMBNazKnjUZjYLKmBHzsVAnC1o=go.etcd.io/raft/v3 v3.6.0 h1:5NtvbDVYpnfZWcIHgGRk9DyzkBIXOi8j+DDp1IcnUWQ=go.etcd.io/raft/v3 v3.6.0/go.mod h1:nLvLevg6+xrVtHUmVaTcTz603gQPHfh7kUAwV6YpfGo=+go.getarcane.app/acfs v0.2.0 h1:m7yXsLIB4MfsAE/AFP54RgtMXUr+AFEVCNiF5784XYI=+go.getarcane.app/acfs v0.2.0/go.mod h1:sU3t21KctTsQM3OW10+RNB0Z6lR+YfaSr5Nxubq3cpI=go.getarcane.app/updater v0.3.6 h1:+BqoycaRsHj+cLVSzcYQuqbHxUKbtmaozMNblz5bVSw=go.getarcane.app/updater v0.3.6/go.mod h1:2ENitZR/lA5MuBn60OZYR5wvU3ZCE+pAgfrebfOlRDA=go.getarcane.app/updater v0.3.7 h1:WqHsxudvt8gvCR7iSHdxdzwH0+hM0FAh64bSypBX9Mo=