A virtual jailed shell environment for Go apps backed by an io/fs#FS.
feat(command): port readlink from just-bash
Assisted-by: Claude Opus 4.7 via Claude Code
Signed-off-by: Xe Iaso <me@xeiaso.net>
+377
+143
command/internal/readlink/readlink.go
+143
command/internal/readlink/readlink.go
···
1
+
package readlink
2
+
3
+
import (
4
+
"context"
5
+
"errors"
6
+
"fmt"
7
+
"io"
8
+
"path"
9
+
"strings"
10
+
11
+
"github.com/go-git/go-billy/v5"
12
+
"github.com/pborman/getopt/v2"
13
+
"mvdan.cc/sh/v3/interp"
14
+
"tangled.org/xeiaso.net/kefka/command"
15
+
)
16
+
17
+
type Impl struct{}
18
+
19
+
func (Impl) Exec(ctx context.Context, ec *command.ExecContext, args []string) error {
20
+
if ec == nil {
21
+
return errors.New("readlink: nil ExecContext")
22
+
}
23
+
if ec.FS == nil {
24
+
return errors.New("readlink: ExecContext has no filesystem")
25
+
}
26
+
27
+
stdout := ec.Stdout
28
+
if stdout == nil {
29
+
stdout = io.Discard
30
+
}
31
+
stderr := ec.Stderr
32
+
if stderr == nil {
33
+
stderr = io.Discard
34
+
}
35
+
36
+
set := getopt.New()
37
+
set.SetProgram("readlink")
38
+
set.SetParameters("FILE...")
39
+
40
+
usage := func() {
41
+
fmt.Fprint(stderr, "Usage: readlink [OPTIONS] FILE...\n")
42
+
fmt.Fprint(stderr, "Print resolved symbolic links or canonical file names.\n\n")
43
+
fmt.Fprint(stderr, " -f, --canonicalize canonicalize by following every symlink in every component of the given name recursively\n")
44
+
fmt.Fprint(stderr, " --help display this help and exit\n")
45
+
}
46
+
set.SetUsage(usage)
47
+
48
+
canonicalize := set.BoolLong("canonicalize", 'f', "canonicalize by following every symlink in every component of the given name recursively")
49
+
help := set.BoolLong("help", 0, "display this help and exit")
50
+
51
+
if err := set.Getopt(append([]string{"readlink"}, args...), nil); err != nil {
52
+
fmt.Fprintf(stderr, "readlink: %s\n", err)
53
+
usage()
54
+
return interp.ExitStatus(1)
55
+
}
56
+
57
+
if *help {
58
+
usage()
59
+
return nil
60
+
}
61
+
62
+
files := set.Args()
63
+
if len(files) == 0 {
64
+
fmt.Fprint(stderr, "readlink: missing operand\n")
65
+
return interp.ExitStatus(1)
66
+
}
67
+
68
+
sym, hasSymlink := ec.FS.(billy.Symlink)
69
+
70
+
anyError := false
71
+
for _, file := range files {
72
+
filePath := resolvePath(ec, file)
73
+
74
+
if *canonicalize {
75
+
current := filePath
76
+
seen := make(map[string]struct{})
77
+
for {
78
+
if _, ok := seen[current]; ok {
79
+
break
80
+
}
81
+
seen[current] = struct{}{}
82
+
83
+
if !hasSymlink {
84
+
break
85
+
}
86
+
target, err := sym.Readlink(current)
87
+
if err != nil {
88
+
break
89
+
}
90
+
if path.IsAbs(target) {
91
+
trimmed := strings.TrimPrefix(target, "/")
92
+
if trimmed == "" {
93
+
current = "."
94
+
} else {
95
+
current = path.Clean(trimmed)
96
+
}
97
+
} else {
98
+
dir := path.Dir(current)
99
+
current = path.Join(dir, target)
100
+
}
101
+
}
102
+
io.WriteString(stdout, current)
103
+
io.WriteString(stdout, "\n")
104
+
continue
105
+
}
106
+
107
+
if !hasSymlink {
108
+
anyError = true
109
+
continue
110
+
}
111
+
target, err := sym.Readlink(filePath)
112
+
if err != nil {
113
+
anyError = true
114
+
continue
115
+
}
116
+
io.WriteString(stdout, target)
117
+
io.WriteString(stdout, "\n")
118
+
}
119
+
120
+
if anyError {
121
+
return interp.ExitStatus(1)
122
+
}
123
+
return nil
124
+
}
125
+
126
+
func resolvePath(ec *command.ExecContext, p string) string {
127
+
dir := ec.Dir
128
+
if dir == "" {
129
+
dir = "."
130
+
}
131
+
if path.IsAbs(p) {
132
+
p = strings.TrimPrefix(p, "/")
133
+
if p == "" {
134
+
return "."
135
+
}
136
+
return path.Clean(p)
137
+
}
138
+
joined := path.Join(dir, p)
139
+
if joined == "" {
140
+
return "."
141
+
}
142
+
return joined
143
+
}
+234
command/internal/readlink/readlink_test.go
+234
command/internal/readlink/readlink_test.go
···
1
+
package readlink
2
+
3
+
import (
4
+
"bytes"
5
+
"context"
6
+
"os"
7
+
"strings"
8
+
"testing"
9
+
10
+
"github.com/go-git/go-billy/v5"
11
+
"github.com/go-git/go-billy/v5/memfs"
12
+
"tangled.org/xeiaso.net/kefka/command"
13
+
)
14
+
15
+
func newTestFS(t *testing.T) billy.Filesystem {
16
+
t.Helper()
17
+
fs := memfs.New()
18
+
write := func(name string, data []byte) {
19
+
f, err := fs.OpenFile(name, os.O_CREATE|os.O_WRONLY, 0o644)
20
+
if err != nil {
21
+
t.Fatalf("write %s: %v", name, err)
22
+
}
23
+
f.Write(data)
24
+
f.Close()
25
+
}
26
+
write("target.txt", []byte("hello"))
27
+
write("sub/inner.txt", []byte("inner"))
28
+
29
+
sym, ok := fs.(billy.Symlink)
30
+
if !ok {
31
+
t.Fatalf("memfs does not implement billy.Symlink")
32
+
}
33
+
if err := sym.Symlink("target.txt", "link.txt"); err != nil {
34
+
t.Fatalf("symlink link.txt: %v", err)
35
+
}
36
+
if err := sym.Symlink("/target.txt", "abs-link.txt"); err != nil {
37
+
t.Fatalf("symlink abs-link.txt: %v", err)
38
+
}
39
+
if err := sym.Symlink("link.txt", "chain.txt"); err != nil {
40
+
t.Fatalf("symlink chain.txt: %v", err)
41
+
}
42
+
if err := sym.Symlink("../target.txt", "sub/up.txt"); err != nil {
43
+
t.Fatalf("symlink sub/up.txt: %v", err)
44
+
}
45
+
if err := sym.Symlink("loop-b", "loop-a"); err != nil {
46
+
t.Fatalf("symlink loop-a: %v", err)
47
+
}
48
+
if err := sym.Symlink("loop-a", "loop-b"); err != nil {
49
+
t.Fatalf("symlink loop-b: %v", err)
50
+
}
51
+
return fs
52
+
}
53
+
54
+
func run(t *testing.T, args []string) (string, string, error) {
55
+
t.Helper()
56
+
var stdout, stderr bytes.Buffer
57
+
ec := &command.ExecContext{
58
+
Stdout: &stdout,
59
+
Stderr: &stderr,
60
+
Dir: ".",
61
+
FS: newTestFS(t),
62
+
}
63
+
err := Impl{}.Exec(context.Background(), ec, args)
64
+
return stdout.String(), stderr.String(), err
65
+
}
66
+
67
+
func TestReadlink(t *testing.T) {
68
+
tests := []struct {
69
+
name string
70
+
dir string
71
+
args []string
72
+
wantStdout string
73
+
wantStderr string
74
+
wantErr bool
75
+
}{
76
+
{
77
+
name: "plain symlink prints target",
78
+
args: []string{"link.txt"},
79
+
wantStdout: "target.txt\n",
80
+
},
81
+
{
82
+
name: "absolute target prints as stored",
83
+
args: []string{"abs-link.txt"},
84
+
wantStdout: "/target.txt\n",
85
+
},
86
+
{
87
+
name: "non-symlink without -f errors",
88
+
args: []string{"target.txt"},
89
+
wantErr: true,
90
+
},
91
+
{
92
+
name: "missing file without -f errors silently",
93
+
args: []string{"nope"},
94
+
wantErr: true,
95
+
},
96
+
{
97
+
name: "canonicalize follows single symlink",
98
+
args: []string{"-f", "link.txt"},
99
+
wantStdout: "target.txt\n",
100
+
},
101
+
{
102
+
name: "canonicalize follows chain",
103
+
args: []string{"-f", "chain.txt"},
104
+
wantStdout: "target.txt\n",
105
+
},
106
+
{
107
+
name: "canonicalize on non-symlink prints resolved path",
108
+
args: []string{"-f", "target.txt"},
109
+
wantStdout: "target.txt\n",
110
+
},
111
+
{
112
+
name: "canonicalize on missing file prints resolved path",
113
+
args: []string{"-f", "nope"},
114
+
wantStdout: "nope\n",
115
+
},
116
+
{
117
+
name: "canonicalize handles circular symlinks",
118
+
args: []string{"-f", "loop-a"},
119
+
wantStdout: "loop-a\n",
120
+
},
121
+
{
122
+
name: "canonicalize resolves relative target against link parent",
123
+
args: []string{"-f", "sub/up.txt"},
124
+
wantStdout: "target.txt\n",
125
+
},
126
+
{
127
+
name: "long form --canonicalize",
128
+
args: []string{"--canonicalize", "link.txt"},
129
+
wantStdout: "target.txt\n",
130
+
},
131
+
{
132
+
name: "multiple files prints each on its own line",
133
+
args: []string{"link.txt", "abs-link.txt"},
134
+
wantStdout: "target.txt\n/target.txt\n",
135
+
},
136
+
{
137
+
name: "partial failure still prints successes and errors",
138
+
args: []string{"link.txt", "nope"},
139
+
wantStdout: "target.txt\n",
140
+
wantErr: true,
141
+
},
142
+
{
143
+
name: "ec.Dir scopes relative paths",
144
+
dir: "sub",
145
+
args: []string{"-f", "up.txt"},
146
+
wantStdout: "target.txt\n",
147
+
},
148
+
{
149
+
name: "absolute input path",
150
+
args: []string{"/link.txt"},
151
+
wantStdout: "target.txt\n",
152
+
},
153
+
{
154
+
name: "missing operand",
155
+
args: []string{},
156
+
wantStderr: "readlink: missing operand\n",
157
+
wantErr: true,
158
+
},
159
+
{
160
+
name: "unknown flag",
161
+
args: []string{"--no-such-flag"},
162
+
wantErr: true,
163
+
},
164
+
{
165
+
name: "double dash terminator",
166
+
args: []string{"--", "link.txt"},
167
+
wantStdout: "target.txt\n",
168
+
},
169
+
}
170
+
171
+
for _, tt := range tests {
172
+
t.Run(tt.name, func(t *testing.T) {
173
+
var stdout, stderr bytes.Buffer
174
+
dir := tt.dir
175
+
if dir == "" {
176
+
dir = "."
177
+
}
178
+
ec := &command.ExecContext{
179
+
Stdout: &stdout,
180
+
Stderr: &stderr,
181
+
Dir: dir,
182
+
FS: newTestFS(t),
183
+
}
184
+
err := Impl{}.Exec(context.Background(), ec, tt.args)
185
+
if tt.wantErr && err == nil {
186
+
t.Fatalf("expected error, got nil; stdout=%q stderr=%q", stdout.String(), stderr.String())
187
+
}
188
+
if !tt.wantErr && err != nil {
189
+
t.Fatalf("unexpected error: %v; stderr=%q", err, stderr.String())
190
+
}
191
+
if got := stdout.String(); got != tt.wantStdout {
192
+
t.Errorf("stdout = %q, want %q", got, tt.wantStdout)
193
+
}
194
+
if tt.wantStderr != "" && stderr.String() != tt.wantStderr {
195
+
t.Errorf("stderr = %q, want %q", stderr.String(), tt.wantStderr)
196
+
}
197
+
})
198
+
}
199
+
}
200
+
201
+
func TestHelp(t *testing.T) {
202
+
stdout, stderr, err := run(t, []string{"--help"})
203
+
if err != nil {
204
+
t.Fatalf("unexpected error: %v", err)
205
+
}
206
+
if stdout != "" {
207
+
t.Errorf("expected empty stdout, got %q", stdout)
208
+
}
209
+
if !strings.Contains(stderr, "Usage: readlink [OPTIONS] FILE...") {
210
+
t.Errorf("usage line missing from stderr: %q", stderr)
211
+
}
212
+
if !strings.Contains(stderr, "--help") {
213
+
t.Errorf("help flag missing from help output: %q", stderr)
214
+
}
215
+
if !strings.Contains(stderr, "-f, --canonicalize") {
216
+
t.Errorf("canonicalize flag missing from help output: %q", stderr)
217
+
}
218
+
}
219
+
220
+
func TestExec_NilContext(t *testing.T) {
221
+
if err := (Impl{}).Exec(context.Background(), nil, nil); err == nil {
222
+
t.Fatal("expected error for nil ExecContext")
223
+
}
224
+
}
225
+
226
+
func TestExec_NoFS(t *testing.T) {
227
+
ec := &command.ExecContext{
228
+
Stdout: &bytes.Buffer{},
229
+
Stderr: &bytes.Buffer{},
230
+
}
231
+
if err := (Impl{}).Exec(context.Background(), ec, []string{"link.txt"}); err == nil {
232
+
t.Fatal("expected error for missing filesystem")
233
+
}
234
+
}