@synopackageland/cli 0.8.0 → 0.9.0

package/templates/native-go/backend/internal/app/routes.go

@@ -1,137 +0,0 @@
-// Package app holds this package's business operations. Add a route here and
-// register its handler here. App permissions live in internal/api/permissions.json; SDK capability routes
-// use the immutable SDK policy.
-// unlisted methods require membership in DSM's administrators group.
-//
-//line dsmapp/internal/app/routes.go:1
-package app
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"errors"
-	"io/fs"
-	"os"
-	"path/filepath"
-	"runtime"
-	"time"
-	"unicode/utf8"
-
-	"dsmapp/internal/api"
-	"dsmapp/internal/filestation"
-)
-
-// Config is fixed at build time and startup, never taken from a request.
-type Config struct {
-	DelegateScope                                                      string
-	DelegateOperationsJSON, DelegateDestinationsJSON, DelegateLifetime string
-	ExecutorDigest, PolicyDigest                                       string
-
-	// SessionFiles is the interactive File Station adapter; nil keeps legacy refusal.
-	SessionFiles *filestation.Service
-	PackageID    string
-	Version      string
-	// DataDir is the package's persistent, package-owned directory
-	// (/var/packages/<package>/var). It survives upgrades.
-	DataDir string
-	// VolumeRoot is where /volumeN lives; empty means "/". Tests set it.
-	VolumeRoot string
-	// Portal serves portal.status; PortalConfig overrides DSM's saved
-	// AppPortal.json path in tests.
-	Portal       bool
-	PortalConfig string
-}
-
-func Routes(cfg Config) []api.Route {
-	routes := cfg.delegateRoutes()
-	routes = append(routes, []api.Route{
-		api.Handle("app.status", cfg.status),
-		api.Handle("greeting.get", cfg.getGreeting),
-		api.Handle("greeting.set", cfg.setGreeting),
-	}...)
-	routes = append(routes, cfg.SessionFiles.Routes()...)
-	routes = append(routes, cfg.backgroundRoutes()...)
-	routes = append(routes, cfg.portalRoutes()...)
-	return append(routes, cfg.rootRoutes()...)
-}
-
-func (cfg Config) status(_ context.Context, caller api.Caller, _ json.RawMessage) (any, error) {
-	return cfg.withSharedFolders(map[string]any{
-		"package":    cfg.PackageID,
-		"version":    cfg.Version,
-		"user":       caller.User(),
-		"admin":      caller.Admin(),
-		"process":    map[string]int{"uid": os.Getuid(), "gid": os.Getgid()},
-		"go_version": runtime.Version(),
-		"platform":   runtime.GOOS + "/" + runtime.GOARCH,
-		"time":       time.Now().UTC().Format(time.RFC3339),
-	}), nil
-}
-
-type greeting struct {
-	Text      string `json:"text"`
-	UpdatedBy string `json:"updated_by,omitempty"`
-}
-
-func (cfg Config) greetingPath() string { return filepath.Join(cfg.DataDir, "greeting.json") }
-
-func (cfg Config) getGreeting(context.Context, api.Caller, json.RawMessage) (any, error) {
-	data, err := os.ReadFile(cfg.greetingPath())
-	if errors.Is(err, fs.ErrNotExist) {
-		return greeting{Text: "Hello"}, nil
-	}
-	if err != nil {
-		return nil, err
-	}
-	var g greeting
-	return g, json.Unmarshal(data, &g)
-}
-
-func (cfg Config) setGreeting(_ context.Context, caller api.Caller, params json.RawMessage) (any, error) {
-	var in struct {
-		Text string `json:"text"`
-	}
-	if err := decodeParams(params, &in); err != nil {
-		return nil, err
-	}
-	if n := utf8.RuneCountInString(in.Text); n < 1 || n > 200 {
-		return nil, api.BadRequest("text must be 1 to 200 characters")
-	}
-	g := greeting{Text: in.Text, UpdatedBy: caller.User()}
-	data, err := json.Marshal(g)
-	if err != nil {
-		return nil, err
-	}
-	return g, writeFileAtomic(cfg.greetingPath(), data)
-}
-
-// decodeParams decodes params strictly: unknown fields are an error.
-func decodeParams(params json.RawMessage, into any) error {
-	if len(params) == 0 {
-		params = json.RawMessage(`{}`)
-	}
-	dec := json.NewDecoder(bytes.NewReader(params))
-	dec.DisallowUnknownFields()
-	if err := dec.Decode(into); err != nil {
-		return api.BadRequest("invalid params: " + err.Error())
-	}
-	return nil
-}
-
-// writeFileAtomic replaces path in one rename, so readers never see half a file.
-func writeFileAtomic(path string, data []byte) error {
-	tmp, err := os.CreateTemp(filepath.Dir(path), ".tmp-*")
-	if err != nil {
-		return err
-	}
-	defer os.Remove(tmp.Name())
-	if _, err := tmp.Write(data); err != nil {
-		tmp.Close()
-		return err
-	}
-	if err := tmp.Close(); err != nil {
-		return err
-	}
-	return os.Rename(tmp.Name(), path)
-}

package/templates/native-go/backend/internal/app/routes_test.go

@@ -1,165 +0,0 @@
-package app
-
-import (
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"strings"
-	"testing"
-
-	"dsmapp/internal/api"
-)
-
-type stubAuth struct {
-	identity api.Identity
-	err      error
-}
-
-func (s stubAuth) Authenticate(*http.Request) (api.Identity, error) { return s.identity, s.err }
-
-func testConfig(t *testing.T) Config {
-	return Config{PackageID: "HelloGo", Version: "0.1.0-0001", DataDir: t.TempDir()}
-}
-
-// call returns the envelope's error code ("" on success) and the envelope.
-func call(t *testing.T, cfg Config, auth api.Authenticator, method, params string, permissionJSON ...[]byte) (string, map[string]any) {
-	t.Helper()
-	previous := lookupSubmitterUID
-	lookupSubmitterUID = func(string) string { return "1024" }
-	defer func() { lookupSubmitterUID = previous }()
-	srv, err := api.NewServer(auth, Routes(cfg)...)
-	if len(permissionJSON) != 0 {
-		srv, err = api.NewServerWithPermissions(auth, permissionJSON[0], Routes(cfg)...)
-	}
-	if err != nil {
-		t.Fatal(err)
-	}
-	body := `{"method":"` + method + `","params":` + params + `}`
-	req := httptest.NewRequest(http.MethodPost, "/api.cgi", strings.NewReader(body))
-	req.Header.Set("Content-Type", "application/json")
-	rec := httptest.NewRecorder()
-	srv.ServeHTTP(rec, req)
-	var out map[string]any
-	if err := json.Unmarshal(rec.Body.Bytes(), &out); err != nil {
-		t.Fatalf("not JSON: %s", rec.Body.String())
-	}
-	if rec.Code != http.StatusOK {
-		t.Fatalf("HTTP %d: DSM replaces non-200 CGI bodies", rec.Code)
-	}
-	code := ""
-	if e, ok := out["error"].(map[string]any); ok {
-		code, _ = e["code"].(string)
-	}
-	return code, out
-}
-
-var (
-	alice  = stubAuth{identity: api.Identity{User: "alice", Admin: true}}
-	bob    = stubAuth{identity: api.Identity{User: "bob"}}
-	nobody = stubAuth{err: api.ErrNoSession}
-)
-
-// sampleParams holds valid params for every route, so the denial test below
-// proves the refusal came from the policy and not from bad input.
-var sampleParams = map[string]string{
-	"app.status":   `{}`,
-	"greeting.get": `{}`,
-	"greeting.set": `{"text":"Hi"}`,
-}
-
-func TestEveryRouteHasSampleParamsAndNoneIsPublic(t *testing.T) {
-	routes := Routes(testConfig(t))
-	if len(routes) != len(sampleParams) {
-		t.Fatalf("%d routes but %d sample params: add the new route to sampleParams", len(routes), len(sampleParams))
-	}
-	for _, r := range routes {
-		if _, ok := sampleParams[r.Method()]; !ok {
-			t.Errorf("route %s has no sample params", r.Method())
-		}
-		if r.Public() {
-			t.Errorf("route %s is public; this template ships none", r.Method())
-		}
-	}
-}
-
-func TestEveryRouteRefusesCallersWithoutASessionAndChangesNothing(t *testing.T) {
-	for _, r := range Routes(testConfig(t)) {
-		cfg := testConfig(t)
-		code, _ := call(t, cfg, nobody, r.Method(), sampleParams[r.Method()])
-		if code != "session_required" {
-			t.Errorf("%s: %q, want session_required", r.Method(), code)
-		}
-		assertDataDirEmpty(t, cfg)
-	}
-}
-
-func TestAdministratorRoutesRefuseOrdinaryUsersAndChangeNothing(t *testing.T) {
-	for _, r := range Routes(testConfig(t)) {
-		if !r.AdminOnly() {
-			continue
-		}
-		cfg := testConfig(t)
-		code, _ := call(t, cfg, bob, r.Method(), sampleParams[r.Method()])
-		if code != "admin_required" {
-			t.Errorf("%s: %q, want admin_required", r.Method(), code)
-		}
-		assertDataDirEmpty(t, cfg)
-	}
-}
-
-func TestEveryRouteSucceedsForAnAdmin(t *testing.T) {
-	for _, r := range Routes(testConfig(t)) {
-		code, out := call(t, testConfig(t), alice, r.Method(), sampleParams[r.Method()])
-		want := ""
-		if strings.HasPrefix(r.Method(), "jobs.") {
-			want = "unavailable"
-		}
-		if code != want {
-			t.Errorf("%s: %q %v", r.Method(), code, out)
-		}
-	}
-}
-
-func TestStatusReportsPackageAndCaller(t *testing.T) {
-	code, out := call(t, testConfig(t), alice, "app.status", `{}`)
-	data := out["data"].(map[string]any)
-	if code != "" || data["package"] != "HelloGo" || data["version"] != "0.1.0-0001" || data["user"] != "alice" || data["admin"] != true {
-		t.Fatalf("got %q %v", code, out)
-	}
-}
-
-func TestGreetingDefaultsAndAdminCanChangeIt(t *testing.T) {
-	cfg := testConfig(t)
-	_, out := call(t, cfg, alice, "greeting.get", `{}`)
-	if got := out["data"].(map[string]any)["text"]; got != "Hello" {
-		t.Fatalf("default greeting = %v", got)
-	}
-	if code, out := call(t, cfg, alice, "greeting.set", `{"text":"Hi from DSM"}`); code != "" {
-		t.Fatalf("set: %q %v", code, out)
-	}
-	_, out = call(t, cfg, alice, "greeting.get", `{}`)
-	data := out["data"].(map[string]any)
-	if data["text"] != "Hi from DSM" || data["updated_by"] != "alice" {
-		t.Fatalf("after set: %v", data)
-	}
-}
-
-func TestGreetingSetValidatesText(t *testing.T) {
-	for _, params := range []string{`{}`, `{"text":""}`, `{"text":"` + strings.Repeat("x", 201) + `"}`, `{"text":7}`, `{"text":"ok","extra":1}`} {
-		cfg := testConfig(t)
-		code, _ := call(t, cfg, alice, "greeting.set", params)
-		if code != "bad_request" {
-			t.Errorf("%s: %q, want bad_request", params, code)
-		}
-		assertDataDirEmpty(t, cfg)
-	}
-}
-
-func assertDataDirEmpty(t *testing.T, cfg Config) {
-	t.Helper()
-	entries, err := os.ReadDir(cfg.DataDir)
-	if err != nil || len(entries) != 0 {
-		t.Fatalf("data dir changed: %v %v", entries, err)
-	}
-}

package/templates/native-go/backend/internal/app/session_files.go

@@ -1,9 +0,0 @@
-package app
-
-// FileStationSession selects the interactive File Station adapter using the caller’s DSM session.
-const FileStationSession = "session"
-
-// SessionFilesEnabled accepts only the fixed build-time session setting.
-func SessionFilesEnabled(fileStation string) bool {
-	return fileStation == FileStationSession
-}

package/templates/native-go/backend/internal/app/session_files_test.go

@@ -1,14 +0,0 @@
-package app
-
-import "testing"
-
-func TestSessionFilesEnabledByTrustedBuildSetting(t *testing.T) {
-	for _, tc := range []struct {
-		value string
-		want  bool
-	}{{"", false}, {"session", true}, {"yes", false}} {
-		if got := SessionFilesEnabled(tc.value); got != tc.want {
-			t.Errorf("%q: got %v, want %v", tc.value, got, tc.want)
-		}
-	}
-}

package/templates/native-go/backend/internal/app/shared_folder.go

@@ -1,144 +0,0 @@
-package app
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io/fs"
-	"os"
-	"path/filepath"
-	"sort"
-	"strings"
-	"syscall"
-)
-
-// The install wizard stores the chosen Shared Folder's *name* in
-// <DataDir>/config.json (see dsm-package.yaml install.sharedFolder). The path
-// is resolved on every call, so a Shared Folder moved to another volume keeps
-// working. config.json is written by the package's postinst/postupgrade, not
-// by the app.
-
-var (
-	ErrSharedFolderNotFound  = errors.New("shared folder not found on any volume")
-	ErrSharedFolderAmbiguous = errors.New("shared folder name matches more than one volume")
-)
-
-// SharedFolder says where one configured Shared Folder is right now and what
-// the package account may do there.
-type SharedFolder struct {
-	Key      string `json:"key"`
-	Name     string `json:"name"`
-	Path     string `json:"path,omitempty"`
-	Exists   bool   `json:"exists"`
-	Readable bool   `json:"readable"`
-	Writable bool   `json:"writable"`
-	Error    string `json:"error,omitempty"`
-}
-
-func validShareName(name string) bool {
-	return name != "" && !strings.ContainsAny(name, "/\\\x00") && !strings.Contains(name, "..") &&
-		!strings.HasPrefix(name, "@") && !strings.HasPrefix(name, ".")
-}
-
-// ReadSharedFolders returns the Shared Folder names the installer stored, by
-// key. A package without config.json has none.
-func ReadSharedFolders(dataDir string) (map[string]string, error) {
-	data, err := os.ReadFile(filepath.Join(dataDir, "config.json"))
-	if errors.Is(err, fs.ErrNotExist) {
-		return nil, nil
-	}
-	if err != nil {
-		return nil, err
-	}
-	var cfg struct {
-		Schema        int               `json:"schema"`
-		SharedFolders map[string]string `json:"shared_folders"`
-	}
-	if err := json.Unmarshal(data, &cfg); err != nil {
-		return nil, fmt.Errorf("config.json: %w", err)
-	}
-	if cfg.Schema != 1 {
-		return nil, fmt.Errorf("config.json: unsupported schema %d", cfg.Schema)
-	}
-	for key, name := range cfg.SharedFolders {
-		if !validShareName(name) {
-			return nil, fmt.Errorf("config.json: invalid shared folder name for %q", key)
-		}
-	}
-	return cfg.SharedFolders, nil
-}
-
-// ResolveSharedFolder finds /volumeN/<name> under root ("/" on a NAS).
-func ResolveSharedFolder(root, name string) (string, error) {
-	if !validShareName(name) {
-		return "", fmt.Errorf("invalid shared folder name %q", name)
-	}
-	volumes, err := filepath.Glob(filepath.Join(root, "volume[0-9]*"))
-	if err != nil {
-		return "", err
-	}
-	var found []string
-	for _, volume := range volumes {
-		path := filepath.Join(volume, name)
-		if info, err := os.Stat(path); err == nil && info.IsDir() {
-			found = append(found, path)
-		}
-	}
-	switch len(found) {
-	case 0:
-		return "", ErrSharedFolderNotFound
-	case 1:
-		return found[0], nil
-	}
-	return "", ErrSharedFolderAmbiguous
-}
-
-const (
-	accessRead  = 0x4 // R_OK
-	accessWrite = 0x2 // W_OK
-	accessExec  = 0x1 // X_OK
-)
-
-// SharedFolders reports every configured Shared Folder, sorted by key. The
-// error is a corrupt config.json.
-func (cfg Config) SharedFolders() ([]SharedFolder, error) {
-	names, err := ReadSharedFolders(cfg.DataDir)
-	if err != nil {
-		return nil, err
-	}
-	root := cfg.VolumeRoot
-	if root == "" {
-		root = "/"
-	}
-	keys := make([]string, 0, len(names))
-	for key := range names {
-		keys = append(keys, key)
-	}
-	sort.Strings(keys)
-	folders := make([]SharedFolder, 0, len(keys))
-	for _, key := range keys {
-		folder := SharedFolder{Key: key, Name: names[key]}
-		path, err := ResolveSharedFolder(root, folder.Name)
-		if err != nil {
-			folder.Error = err.Error()
-		} else {
-			folder.Path, folder.Exists = path, true
-			folder.Readable = syscall.Access(path, accessRead|accessExec) == nil
-			folder.Writable = syscall.Access(path, accessWrite|accessExec) == nil
-		}
-		folders = append(folders, folder)
-	}
-	return folders, nil
-}
-
-// withSharedFolders adds the configured Shared Folders to an app.status
-// answer; a package that configures none is answered exactly as before.
-func (cfg Config) withSharedFolders(status map[string]any) map[string]any {
-	folders, err := cfg.SharedFolders()
-	if err != nil {
-		status["shared_folders_error"] = err.Error()
-	} else if len(folders) > 0 {
-		status["shared_folders"] = folders
-	}
-	return status
-}

package/templates/native-go/backend/internal/app/shared_folder_test.go

@@ -1,158 +0,0 @@
-package app
-
-import (
-	"errors"
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func writeConfig(t *testing.T, dir, body string) {
-	t.Helper()
-	if err := os.WriteFile(filepath.Join(dir, "config.json"), []byte(body), 0o600); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestReadSharedFoldersWithoutConfigIsEmpty(t *testing.T) {
-	got, err := ReadSharedFolders(t.TempDir())
-	if err != nil || len(got) != 0 {
-		t.Fatalf("got %v %v", got, err)
-	}
-}
-
-func TestReadSharedFoldersReturnsNamesByKey(t *testing.T) {
-	dir := t.TempDir()
-	writeConfig(t, dir, `{"schema":1,"shared_folders":{"media":"Family Photos"}}`)
-	got, err := ReadSharedFolders(dir)
-	if err != nil || got["media"] != "Family Photos" || len(got) != 1 {
-		t.Fatalf("got %v %v", got, err)
-	}
-}
-
-func TestReadSharedFoldersRefusesUnknownSchemaAndBadNames(t *testing.T) {
-	for _, body := range []string{
-		`{"schema":2,"shared_folders":{"media":"x"}}`,
-		`{"schema":1,"shared_folders":{"media":"a/b"}}`,
-		`{"schema":1,"shared_folders":{"media":".."}}`,
-		`{"schema":1,"shared_folders":{"media":"@appdata"}}`,
-		`{"schema":1,"shared_folders":{"media":""}}`,
-		`not json`,
-	} {
-		dir := t.TempDir()
-		writeConfig(t, dir, body)
-		if _, err := ReadSharedFolders(dir); err == nil {
-			t.Errorf("%s: want an error", body)
-		}
-	}
-}
-
-func TestResolveSharedFolderFindsTheNameOnItsVolume(t *testing.T) {
-	root := t.TempDir()
-	for _, d := range []string{"volume1/other", "volume2/Photos", "volume2/@appdata"} {
-		if err := os.MkdirAll(filepath.Join(root, d), 0o755); err != nil {
-			t.Fatal(err)
-		}
-	}
-	got, err := ResolveSharedFolder(root, "Photos")
-	if err != nil || got != filepath.Join(root, "volume2", "Photos") {
-		t.Fatalf("got %q %v", got, err)
-	}
-}
-
-func TestResolveSharedFolderFollowsAMovedShare(t *testing.T) {
-	root := t.TempDir()
-	os.MkdirAll(filepath.Join(root, "volume1", "Photos"), 0o755)
-	first, _ := ResolveSharedFolder(root, "Photos")
-	os.Rename(filepath.Join(root, "volume1", "Photos"), filepath.Join(root, "Photos.tmp"))
-	os.MkdirAll(filepath.Join(root, "volume2"), 0o755)
-	os.Rename(filepath.Join(root, "Photos.tmp"), filepath.Join(root, "volume2", "Photos"))
-	second, err := ResolveSharedFolder(root, "Photos")
-	if err != nil || first == second || second != filepath.Join(root, "volume2", "Photos") {
-		t.Fatalf("%q -> %q %v", first, second, err)
-	}
-}
-
-func TestResolveSharedFolderErrors(t *testing.T) {
-	root := t.TempDir()
-	if _, err := ResolveSharedFolder(root, "Missing"); !errors.Is(err, ErrSharedFolderNotFound) {
-		t.Fatalf("missing: %v", err)
-	}
-	os.MkdirAll(filepath.Join(root, "volume1", "Dup"), 0o755)
-	os.MkdirAll(filepath.Join(root, "volume2", "Dup"), 0o755)
-	if _, err := ResolveSharedFolder(root, "Dup"); !errors.Is(err, ErrSharedFolderAmbiguous) {
-		t.Fatalf("ambiguous: %v", err)
-	}
-	for _, bad := range []string{"", "..", "a/b", "@appdata", ".x"} {
-		if _, err := ResolveSharedFolder(root, bad); err == nil {
-			t.Errorf("%q: want an error", bad)
-		}
-	}
-}
-
-func TestResolveSharedFolderIgnoresAFileOfThatName(t *testing.T) {
-	root := t.TempDir()
-	os.MkdirAll(filepath.Join(root, "volume1"), 0o755)
-	os.WriteFile(filepath.Join(root, "volume1", "Notes"), nil, 0o644)
-	if _, err := ResolveSharedFolder(root, "Notes"); !errors.Is(err, ErrSharedFolderNotFound) {
-		t.Fatalf("got %v", err)
-	}
-}
-
-func TestStatusOmitsSharedFoldersWhenNoneConfigured(t *testing.T) {
-	_, out := call(t, testConfig(t), alice, "app.status", `{}`)
-	if _, present := out["data"].(map[string]any)["shared_folders"]; present {
-		t.Fatalf("unexpected shared_folders: %v", out)
-	}
-}
-
-func TestStatusReportsEachConfiguredSharedFolder(t *testing.T) {
-	cfg := testConfig(t)
-	cfg.VolumeRoot = t.TempDir()
-	os.MkdirAll(filepath.Join(cfg.VolumeRoot, "volume1", "Photos"), 0o755)
-	writeConfig(t, cfg.DataDir, `{"schema":1,"shared_folders":{"media":"Photos","gone":"Missing"}}`)
-	_, out := call(t, cfg, alice, "app.status", `{}`)
-	rows := out["data"].(map[string]any)["shared_folders"].([]any)
-	if len(rows) != 2 {
-		t.Fatalf("rows: %v", rows)
-	}
-	byKey := map[string]map[string]any{}
-	for _, r := range rows {
-		m := r.(map[string]any)
-		byKey[m["key"].(string)] = m
-	}
-	media, gone := byKey["media"], byKey["gone"]
-	if media["name"] != "Photos" || media["exists"] != true || media["readable"] != true || media["writable"] != true || media["path"] != filepath.Join(cfg.VolumeRoot, "volume1", "Photos") {
-		t.Fatalf("media: %v", media)
-	}
-	if gone["exists"] != false || gone["readable"] != false || gone["writable"] != false || gone["error"] == nil || gone["path"] != nil {
-		t.Fatalf("gone: %v", gone)
-	}
-}
-
-func TestStatusReportsAFolderThePackageAccountCannotWrite(t *testing.T) {
-	if os.Geteuid() == 0 {
-		t.Skip("root ignores directory modes")
-	}
-	cfg := testConfig(t)
-	cfg.VolumeRoot = t.TempDir()
-	dir := filepath.Join(cfg.VolumeRoot, "volume1", "Locked")
-	os.MkdirAll(dir, 0o755)
-	os.Chmod(dir, 0o555)
-	t.Cleanup(func() { os.Chmod(dir, 0o755) })
-	writeConfig(t, cfg.DataDir, `{"schema":1,"shared_folders":{"media":"Locked"}}`)
-	_, out := call(t, cfg, alice, "app.status", `{}`)
-	row := out["data"].(map[string]any)["shared_folders"].([]any)[0].(map[string]any)
-	if row["exists"] != true || row["readable"] != true || row["writable"] != false {
-		t.Fatalf("row: %v", row)
-	}
-}
-
-func TestStatusReportsACorruptConfigWithoutFailing(t *testing.T) {
-	cfg := testConfig(t)
-	writeConfig(t, cfg.DataDir, `not json`)
-	code, out := call(t, cfg, alice, "app.status", `{}`)
-	if code != "" || out["data"].(map[string]any)["shared_folders_error"] == nil {
-		t.Fatalf("%q %v", code, out)
-	}
-}

package/templates/native-go/backend/internal/background/access.go

@@ -1,57 +0,0 @@
-package background
-
-import (
-	"strconv"
-	"time"
-)
-
-// Valid requires a resolved, non-root numeric UID. Unknown legacy owners remain
-// visible only to administrators.
-func (o Submitter) Valid() bool {
-	uid, err := strconv.ParseUint(o.UID, 10, 32)
-	return o.User != "" && err == nil && uid > 0 && strconv.FormatUint(uid, 10) == o.UID
-}
-
-// Access is constructed only by the authenticated backend, never JSON params.
-type Access struct {
-	Owner Submitter
-	Admin bool
-}
-
-func (a Access) sees(job Job) bool {
-	return !job.PurgeRequested && (a.Admin || (a.Owner.Valid() && job.Submitter == a.Owner))
-}
-
-type PurgeAudit struct {
-	Owner    Submitter `json:"owner"`
-	Actor    string    `json:"actor"`
-	At       time.Time `json:"at"`
-	Removed  int       `json:"removed"`
-	Draining int       `json:"draining"`
-}
-
-// ownerUsage centralizes admission accounting for the package-private spool.
-func (j *journal) ownerUsage(owner Submitter) (pending int, bytes int64) {
-	for _, job := range j.Jobs {
-		if job.Submitter != owner {
-			continue
-		}
-		if !job.State.terminal() {
-			pending++
-			bytes += int64(job.InputBytes + resultReserve)
-		} else {
-			if job.CopyRetained {
-				bytes += int64(job.InputBytes)
-			}
-			if job.Result != nil {
-				bytes += resultReserve
-			}
-		}
-	}
-	for _, sc := range j.Schedules {
-		if sc.Owner == owner {
-			bytes += int64(sc.InputBytes)
-		}
-	}
-	return
-}