fs: a much more complete directory hierarchy and everything mostly working in read-only mode.

fs.go

@@ -41,15 +41,21 @@ var fsCmd = &cli.Command{
 			return fmt.Errorf("must be called with a directory path to serve as the mountpoint as an argument")
 		}
 
-		root := nostrfs.NewNostrRoot(ctx, sys, keyer.NewReadOnlyUser(c.String("pubkey")))
+		root := nostrfs.NewNostrRoot(
+			ctx,
+			sys,
+			keyer.NewReadOnlyUser(c.String("pubkey")),
+			mountpoint,
+		)
 
 		// create the server
 		log("- mounting at %s... ", color.HiCyanString(mountpoint))
 		timeout := time.Second * 120
 		server, err := fs.Mount(mountpoint, root, &fs.Options{
 			MountOptions: fuse.MountOptions{
-				Debug: isVerbose,
+				Debug:  isVerbose,
-				Name:  "nak",
+				Name:   "nak",
+				FsName: "nak",
 			},
 			AttrTimeout:  &timeout,
 			EntryTimeout: &timeout,

go.mod

@@ -17,7 +17,7 @@ require (
 	github.com/mailru/easyjson v0.9.0
 	github.com/mark3labs/mcp-go v0.8.3
 	github.com/markusmobius/go-dateparser v1.2.3
-	github.com/nbd-wtf/go-nostr v0.50.5
+	github.com/nbd-wtf/go-nostr v0.51.0
 	github.com/urfave/cli/v3 v3.0.0-beta1
 	golang.org/x/exp v0.0.0-20250210185358-939b2ce775ac
 )
@@ -36,7 +36,6 @@ require (
 	github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1 // indirect
 	github.com/cloudwego/base64x v0.1.5 // indirect
 	github.com/coder/websocket v1.8.12 // indirect
-	github.com/colduction/nocopy v0.2.0 // indirect
 	github.com/decred/dcrd/crypto/blake256 v1.1.0 // indirect
 	github.com/dgraph-io/ristretto v1.0.0 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
@@ -77,5 +76,3 @@ require (
 	golang.org/x/sys v0.31.0 // indirect
 	golang.org/x/text v0.21.0 // indirect
 )
-
-replace github.com/nbd-wtf/go-nostr => ../go-nostr

go.sum

@@ -51,8 +51,6 @@ github.com/cloudwego/base64x v0.1.5/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJ
 github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY=
 github.com/coder/websocket v1.8.12 h1:5bUXkEPPIbewrnkU8LTCLVaxi4N4J8ahufH2vlo4NAo=
 github.com/coder/websocket v1.8.12/go.mod h1:LNVeNrXQZfe5qhS9ALED3uA+l5pPqvwXg3CKoDBB2gs=
-github.com/colduction/nocopy v0.2.0 h1:9jMLCmIP/wnAWO0FfSXJ4h5HBRe6cBqIqacWw/5sRXY=
-github.com/colduction/nocopy v0.2.0/go.mod h1:MO+QBkEnsZYE7QukMAcAq4b0rHpSxOTlVqD3fI34YJs=
 github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
@@ -149,6 +147,8 @@ github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
 github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/nbd-wtf/go-nostr v0.51.0 h1:Z6gir3lQmlbQGYkccEPbvHlfCydMWXD6bIqukR4DZqU=
+github.com/nbd-wtf/go-nostr v0.51.0/go.mod h1:9PcGOZ+e1VOaLvcK0peT4dbip+/eS+eTWXR3HuexQrA=
 github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
 github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
 github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=

nostrfs/asyncfile.go

@@ -0,0 +1,56 @@
+package nostrfs
+
+import (
+	"context"
+	"sync/atomic"
+	"syscall"
+
+	"github.com/hanwen/go-fuse/v2/fs"
+	"github.com/hanwen/go-fuse/v2/fuse"
+	"github.com/nbd-wtf/go-nostr"
+)
+
+type AsyncFile struct {
+	fs.Inode
+	ctx     context.Context
+	fetched atomic.Bool
+	data    []byte
+	ts      nostr.Timestamp
+	load    func() ([]byte, nostr.Timestamp)
+}
+
+var (
+	_ = (fs.NodeOpener)((*AsyncFile)(nil))
+	_ = (fs.NodeGetattrer)((*AsyncFile)(nil))
+)
+
+func (af *AsyncFile) Getattr(ctx context.Context, f fs.FileHandle, out *fuse.AttrOut) syscall.Errno {
+	if af.fetched.CompareAndSwap(false, true) {
+		af.data, af.ts = af.load()
+	}
+
+	out.Size = uint64(len(af.data))
+	out.Mtime = uint64(af.ts)
+	return fs.OK
+}
+
+func (af *AsyncFile) Open(ctx context.Context, flags uint32) (fs.FileHandle, uint32, syscall.Errno) {
+	if af.fetched.CompareAndSwap(false, true) {
+		af.data, af.ts = af.load()
+	}
+
+	return nil, fuse.FOPEN_KEEP_CACHE, 0
+}
+
+func (af *AsyncFile) Read(
+	ctx context.Context,
+	f fs.FileHandle,
+	dest []byte,
+	off int64,
+) (fuse.ReadResult, syscall.Errno) {
+	end := int(off) + len(dest)
+	if end > len(af.data) {
+		end = len(af.data)
+	}
+	return fuse.ReadResultData(af.data[off:end]), 0
+}

nostrfs/eventdir.go

@@ -1,26 +1,45 @@
 package nostrfs
 
 import (
+	"bytes"
 	"context"
 	"fmt"
+	"io"
+	"net/http"
+	"path/filepath"
 	"syscall"
+	"time"
 
 	"github.com/hanwen/go-fuse/v2/fs"
 	"github.com/hanwen/go-fuse/v2/fuse"
 	"github.com/mailru/easyjson"
 	"github.com/nbd-wtf/go-nostr"
+	"github.com/nbd-wtf/go-nostr/nip10"
+	"github.com/nbd-wtf/go-nostr/nip19"
+	"github.com/nbd-wtf/go-nostr/nip22"
+	"github.com/nbd-wtf/go-nostr/nip27"
+	"github.com/nbd-wtf/go-nostr/nip92"
 	sdk "github.com/nbd-wtf/go-nostr/sdk"
 )
 
 type EventDir struct {
 	fs.Inode
 	ctx context.Context
+	wd  string
 	evt *nostr.Event
 }
 
+var _ = (fs.NodeGetattrer)((*EventDir)(nil))
+
+func (e *EventDir) Getattr(ctx context.Context, f fs.FileHandle, out *fuse.AttrOut) syscall.Errno {
+	out.Mtime = uint64(e.evt.CreatedAt)
+	return fs.OK
+}
+
 func FetchAndCreateEventDir(
 	ctx context.Context,
 	parent fs.InodeEmbedder,
+	wd string,
 	sys *sdk.System,
 	pointer nostr.EventPointer,
 ) (*fs.Inode, error) {
@@ -31,26 +50,55 @@ func FetchAndCreateEventDir(
 		return nil, fmt.Errorf("failed to fetch: %w", err)
 	}
 
-	return CreateEventDir(ctx, parent, event), nil
+	return CreateEventDir(ctx, parent, wd, event), nil
 }
 
 func CreateEventDir(
 	ctx context.Context,
 	parent fs.InodeEmbedder,
+	wd string,
 	event *nostr.Event,
 ) *fs.Inode {
 	h := parent.EmbeddedInode().NewPersistentInode(
 		ctx,
-		&EventDir{ctx: ctx, evt: event},
+		&EventDir{ctx: ctx, wd: wd, evt: event},
 		fs.StableAttr{Mode: syscall.S_IFDIR, Ino: hexToUint64(event.ID)},
 	)
 
+	npub, _ := nip19.EncodePublicKey(event.PubKey)
+	h.AddChild("@author", h.NewPersistentInode(
+		ctx,
+		&fs.MemSymlink{
+			Data: []byte(wd + "/" + npub),
+		},
+		fs.StableAttr{Mode: syscall.S_IFLNK},
+	), true)
+
 	eventj, _ := easyjson.Marshal(event)
 	h.AddChild("event.json", h.NewPersistentInode(
 		ctx,
 		&fs.MemRegularFile{
 			Data: eventj,
-			Attr: fuse.Attr{Mode: 0444},
+			Attr: fuse.Attr{
+				Mode:  0444,
+				Ctime: uint64(event.CreatedAt),
+				Mtime: uint64(event.CreatedAt),
+				Size:  uint64(len(event.Content)),
+			},
+		},
+		fs.StableAttr{},
+	), true)
+
+	h.AddChild("id", h.NewPersistentInode(
+		ctx,
+		&fs.MemRegularFile{
+			Data: []byte(event.ID),
+			Attr: fuse.Attr{
+				Mode:  0444,
+				Ctime: uint64(event.CreatedAt),
+				Mtime: uint64(event.CreatedAt),
+				Size:  uint64(len(event.Content)),
+			},
 		},
 		fs.StableAttr{},
 	), true)
@@ -59,10 +107,135 @@ func CreateEventDir(
 		ctx,
 		&fs.MemRegularFile{
 			Data: []byte(event.Content),
-			Attr: fuse.Attr{Mode: 0444},
+			Attr: fuse.Attr{
+				Mode:  0444,
+				Ctime: uint64(event.CreatedAt),
+				Mtime: uint64(event.CreatedAt),
+				Size:  uint64(len(event.Content)),
+			},
 		},
 		fs.StableAttr{},
 	), true)
 
+	var refsdir *fs.Inode
+	i := 0
+	for ref := range nip27.ParseReferences(*event) {
+		i++
+		if refsdir == nil {
+			refsdir = h.NewPersistentInode(ctx, &fs.Inode{}, fs.StableAttr{Mode: syscall.S_IFDIR})
+			h.AddChild("references", refsdir, true)
+		}
+		refsdir.AddChild(fmt.Sprintf("ref_%02d", i), refsdir.NewPersistentInode(
+			ctx,
+			&fs.MemSymlink{
+				Data: []byte(wd + "/" + nip19.EncodePointer(ref.Pointer)),
+			},
+			fs.StableAttr{Mode: syscall.S_IFLNK},
+		), true)
+	}
+
+	var imagesdir *fs.Inode
+	images := nip92.ParseTags(event.Tags)
+	for _, imeta := range images {
+		if imeta.URL == "" {
+			continue
+		}
+		if imagesdir == nil {
+			in := &fs.Inode{}
+			imagesdir = h.NewPersistentInode(ctx, in, fs.StableAttr{Mode: syscall.S_IFDIR})
+			h.AddChild("images", imagesdir, true)
+		}
+		imagesdir.AddChild(filepath.Base(imeta.URL), imagesdir.NewPersistentInode(
+			ctx,
+			&AsyncFile{
+				ctx: ctx,
+				load: func() ([]byte, nostr.Timestamp) {
+					ctx, cancel := context.WithTimeout(ctx, time.Second*20)
+					defer cancel()
+					r, err := http.NewRequestWithContext(ctx, "GET", imeta.URL, nil)
+					if err != nil {
+						return nil, 0
+					}
+					resp, err := http.DefaultClient.Do(r)
+					if err != nil {
+						return nil, 0
+					}
+					defer resp.Body.Close()
+					if resp.StatusCode >= 300 {
+						return nil, 0
+					}
+					w := &bytes.Buffer{}
+					io.Copy(w, resp.Body)
+					return w.Bytes(), 0
+				},
+			},
+			fs.StableAttr{},
+		), true)
+	}
+
+	if event.Kind == 1 {
+		if pointer := nip10.GetThreadRoot(event.Tags); pointer != nil {
+			nevent := nip19.EncodePointer(*pointer)
+			h.AddChild("@root", h.NewPersistentInode(
+				ctx,
+				&fs.MemSymlink{
+					Data: []byte(wd + "/" + nevent),
+				},
+				fs.StableAttr{Mode: syscall.S_IFLNK},
+			), true)
+		}
+		if pointer := nip10.GetImmediateParent(event.Tags); pointer != nil {
+			nevent := nip19.EncodePointer(*pointer)
+			h.AddChild("@parent", h.NewPersistentInode(
+				ctx,
+				&fs.MemSymlink{
+					Data: []byte(wd + "/" + nevent),
+				},
+				fs.StableAttr{Mode: syscall.S_IFLNK},
+			), true)
+		}
+	} else if event.Kind == 1111 {
+		if pointer := nip22.GetThreadRoot(event.Tags); pointer != nil {
+			if xp, ok := pointer.(nostr.ExternalPointer); ok {
+				h.AddChild("@root", h.NewPersistentInode(
+					ctx,
+					&fs.MemRegularFile{
+						Data: []byte(`<!doctype html><meta http-equiv="refresh" content="0; url=` + xp.Thing + `" />`),
+					},
+					fs.StableAttr{},
+				), true)
+			} else {
+				nevent := nip19.EncodePointer(pointer)
+				h.AddChild("@parent", h.NewPersistentInode(
+					ctx,
+					&fs.MemSymlink{
+						Data: []byte(wd + "/" + nevent),
+					},
+					fs.StableAttr{Mode: syscall.S_IFLNK},
+				), true)
+			}
+		}
+		if pointer := nip22.GetImmediateParent(event.Tags); pointer != nil {
+			if xp, ok := pointer.(nostr.ExternalPointer); ok {
+				h.AddChild("@parent", h.NewPersistentInode(
+					ctx,
+					&fs.MemRegularFile{
+						Data: []byte(`<!doctype html><meta http-equiv="refresh" content="0; url=` + xp.Thing + `" />`),
+					},
+					fs.StableAttr{},
+				), true)
+			} else {
+				nevent := nip19.EncodePointer(pointer)
+				h.AddChild("@parent", h.NewPersistentInode(
+					ctx,
+					&fs.MemSymlink{
+						Data: []byte(wd + "/" + nevent),
+					},
+					fs.StableAttr{Mode: syscall.S_IFLNK},
+				), true)
+			}
+		}
+	}
+
 	return h
 }

nostrfs/npubdir.go

@@ -2,10 +2,12 @@ package nostrfs
 
 import (
 	"context"
+	"encoding/json"
 	"sync/atomic"
 	"syscall"
 
 	"github.com/hanwen/go-fuse/v2/fs"
+	"github.com/hanwen/go-fuse/v2/fuse"
 	"github.com/nbd-wtf/go-nostr"
 	sdk "github.com/nbd-wtf/go-nostr/sdk"
 )
@@ -18,29 +20,143 @@ type NpubDir struct {
 	fetched atomic.Bool
 }
 
-func CreateNpubDir(ctx context.Context, sys *sdk.System, parent fs.InodeEmbedder, pointer nostr.ProfilePointer) *fs.Inode {
+func CreateNpubDir(
+	ctx context.Context,
+	sys *sdk.System,
+	parent fs.InodeEmbedder,
+	wd string,
+	pointer nostr.ProfilePointer,
+) *fs.Inode {
 	npubdir := &NpubDir{ctx: ctx, sys: sys, pointer: pointer}
-	return parent.EmbeddedInode().NewPersistentInode(
+	h := parent.EmbeddedInode().NewPersistentInode(
 		ctx,
 		npubdir,
 		fs.StableAttr{Mode: syscall.S_IFDIR, Ino: hexToUint64(pointer.PublicKey)},
 	)
-}
+
-
+	relays := sys.FetchOutboxRelays(ctx, pointer.PublicKey, 2)
-var _ = (fs.NodeOpendirer)((*NpubDir)(nil))
+
-
+	h.AddChild("pubkey", h.NewPersistentInode(
-func (n *NpubDir) Opendir(ctx context.Context) syscall.Errno {
+		ctx,
-	if n.fetched.CompareAndSwap(true, true) {
+		&fs.MemRegularFile{Data: []byte(pointer.PublicKey + "\n"), Attr: fuse.Attr{Mode: 0444}},
-		return fs.OK
+		fs.StableAttr{},
-	}
+	), true)
-
+
-	for ie := range n.sys.Pool.FetchMany(ctx, n.sys.FetchOutboxRelays(ctx, n.pointer.PublicKey, 2), nostr.Filter{
+	h.AddChild(
-		Kinds:   []int{1},
+		"notes",
-		Authors: []string{n.pointer.PublicKey},
+		h.NewPersistentInode(
-	}, nostr.WithLabel("nak-fs-feed")) {
+			ctx,
-		e := CreateEventDir(ctx, n, ie.Event)
+			&ViewDir{
-		n.AddChild(ie.Event.ID, e, true)
+				ctx: ctx,
-	}
+				sys: sys,
-
+				wd:  wd,
-	return fs.OK
+				filter: nostr.Filter{
+					Kinds:   []int{1},
+					Authors: []string{pointer.PublicKey},
+				},
+				relays: relays,
+			},
+			fs.StableAttr{Mode: syscall.S_IFDIR},
+		),
+		true,
+	)
+
+	h.AddChild(
+		"comments",
+		h.NewPersistentInode(
+			ctx,
+			&ViewDir{
+				ctx: ctx,
+				sys: sys,
+				wd:  wd,
+				filter: nostr.Filter{
+					Kinds:   []int{1111},
+					Authors: []string{pointer.PublicKey},
+				},
+				relays: relays,
+			},
+			fs.StableAttr{Mode: syscall.S_IFDIR},
+		),
+		true,
+	)
+
+	h.AddChild(
+		"pictures",
+		h.NewPersistentInode(
+			ctx,
+			&ViewDir{
+				ctx: ctx,
+				sys: sys,
+				wd:  wd,
+				filter: nostr.Filter{
+					Kinds:   []int{20},
+					Authors: []string{pointer.PublicKey},
+				},
+				relays: relays,
+			},
+			fs.StableAttr{Mode: syscall.S_IFDIR},
+		),
+		true,
+	)
+
+	h.AddChild(
+		"videos",
+		h.NewPersistentInode(
+			ctx,
+			&ViewDir{
+				ctx: ctx,
+				sys: sys,
+				wd:  wd,
+				filter: nostr.Filter{
+					Kinds:   []int{21, 22},
+					Authors: []string{pointer.PublicKey},
+				},
+				relays: relays,
+			},
+			fs.StableAttr{Mode: syscall.S_IFDIR},
+		),
+		true,
+	)
+
+	h.AddChild(
+		"highlights",
+		h.NewPersistentInode(
+			ctx,
+			&ViewDir{
+				ctx: ctx,
+				sys: sys,
+				wd:  wd,
+				filter: nostr.Filter{
+					Kinds:   []int{9802},
+					Authors: []string{pointer.PublicKey},
+				},
+				relays: relays,
+			},
+			fs.StableAttr{Mode: syscall.S_IFDIR},
+		),
+		true,
+	)
+
+	h.AddChild(
+		"metadata.json",
+		h.NewPersistentInode(
+			ctx,
+			&AsyncFile{
+				ctx: ctx,
+				load: func() ([]byte, nostr.Timestamp) {
+					pm := sys.FetchProfileMetadata(ctx, pointer.PublicKey)
+					jsonb, _ := json.MarshalIndent(pm.Event, "", "  ")
+					var ts nostr.Timestamp
+					if pm.Event != nil {
+						ts = pm.Event.CreatedAt
+					}
+					return jsonb, ts
+				},
+			},
+			fs.StableAttr{},
+		),
+		true,
+	)
+
+	return h
 }

nostrfs/root.go

@@ -2,35 +2,41 @@ package nostrfs
 
 import (
 	"context"
+	"path/filepath"
 	"syscall"
+	"time"
 
 	"github.com/hanwen/go-fuse/v2/fs"
 	"github.com/hanwen/go-fuse/v2/fuse"
 	"github.com/nbd-wtf/go-nostr"
+	"github.com/nbd-wtf/go-nostr/nip05"
 	"github.com/nbd-wtf/go-nostr/nip19"
 	"github.com/nbd-wtf/go-nostr/sdk"
 )
 
 type NostrRoot struct {
-	sys *sdk.System
 	fs.Inode
 
+	ctx        context.Context
+	wd         string
+	sys        *sdk.System
 	rootPubKey string
 	signer     nostr.Signer
-	ctx        context.Context
 }
 
 var _ = (fs.NodeOnAdder)((*NostrRoot)(nil))
 
-func NewNostrRoot(ctx context.Context, sys *sdk.System, user nostr.User) *NostrRoot {
+func NewNostrRoot(ctx context.Context, sys *sdk.System, user nostr.User, mountpoint string) *NostrRoot {
 	pubkey, _ := user.GetPublicKey(ctx)
 	signer, _ := user.(nostr.Signer)
+	abs, _ := filepath.Abs(mountpoint)
 
 	return &NostrRoot{
-		sys:        sys,
 		ctx:        ctx,
+		sys:        sys,
 		rootPubKey: pubkey,
 		signer:     signer,
+		wd:         abs,
 	}
 }
 
@@ -46,7 +52,7 @@ func (r *NostrRoot) OnAdd(context.Context) {
 		npub, _ := nip19.EncodePublicKey(f.Pubkey)
 		r.AddChild(
 			npub,
-			CreateNpubDir(r.ctx, r.sys, r, pointer),
+			CreateNpubDir(r.ctx, r.sys, r, r.wd, pointer),
 			true,
 		)
 	}
@@ -57,23 +63,32 @@ func (r *NostrRoot) OnAdd(context.Context) {
 		pointer := nostr.ProfilePointer{PublicKey: r.rootPubKey}
 		r.AddChild(
 			npub,
-			CreateNpubDir(r.ctx, r.sys, r, pointer),
+			CreateNpubDir(r.ctx, r.sys, r, r.wd, pointer),
 			true,
 		)
 	}
 
 	// add a link to ourselves
-	me := r.NewPersistentInode(r.ctx, &fs.MemSymlink{Data: []byte(npub)}, fs.StableAttr{Mode: syscall.S_IFLNK})
+	r.AddChild("@me", r.NewPersistentInode(
-	r.AddChild("@me", me, true)
+		r.ctx,
+		&fs.MemSymlink{Data: []byte(r.wd + "/" + npub)},
+		fs.StableAttr{Mode: syscall.S_IFLNK},
+	), true)
 }
 
 func (r *NostrRoot) Lookup(ctx context.Context, name string, out *fuse.EntryOut) (*fs.Inode, syscall.Errno) {
-	// check if we already have this npub
+	out.SetEntryTimeout(time.Minute * 5)
+
 	child := r.GetChild(name)
 	if child != nil {
 		return child, fs.OK
 	}
 
+	if pp, err := nip05.QueryIdentifier(ctx, name); err == nil {
+		npubdir := CreateNpubDir(ctx, r.sys, r, r.wd, *pp)
+		return npubdir, fs.OK
+	}
+
 	pointer, err := nip19.ToPointer(name)
 	if err != nil {
 		return nil, syscall.ENOENT
@@ -81,10 +96,10 @@ func (r *NostrRoot) Lookup(ctx context.Context, name string, out *fuse.EntryOut)
 
 	switch p := pointer.(type) {
 	case nostr.ProfilePointer:
-		npubdir := CreateNpubDir(ctx, r.sys, r, p)
+		npubdir := CreateNpubDir(ctx, r.sys, r, r.wd, p)
 		return npubdir, fs.OK
 	case nostr.EventPointer:
-		eventdir, err := FetchAndCreateEventDir(ctx, r, r.sys, p)
+		eventdir, err := FetchAndCreateEventDir(ctx, r, r.wd, r.sys, p)
 		if err != nil {
 			return nil, syscall.ENOENT
 		}

nostrfs/viewdir.go

@@ -0,0 +1,72 @@
+package nostrfs
+
+import (
+	"context"
+	"sync/atomic"
+	"syscall"
+
+	"github.com/hanwen/go-fuse/v2/fs"
+	"github.com/hanwen/go-fuse/v2/fuse"
+	"github.com/nbd-wtf/go-nostr"
+	sdk "github.com/nbd-wtf/go-nostr/sdk"
+)
+
+type ViewDir struct {
+	fs.Inode
+	ctx     context.Context
+	sys     *sdk.System
+	wd      string
+	fetched atomic.Bool
+	filter  nostr.Filter
+	relays  []string
+}
+
+var (
+	_ = (fs.NodeOpendirer)((*ViewDir)(nil))
+	_ = (fs.NodeGetattrer)((*ViewDir)(nil))
+)
+
+func (n *ViewDir) Getattr(ctx context.Context, f fs.FileHandle, out *fuse.AttrOut) syscall.Errno {
+	now := nostr.Now()
+	if n.filter.Until != nil {
+		now = *n.filter.Until
+	}
+	aMonthAgo := now - 30*24*60*60
+	out.Mtime = uint64(aMonthAgo)
+	return fs.OK
+}
+
+func (n *ViewDir) Opendir(ctx context.Context) syscall.Errno {
+	if n.fetched.CompareAndSwap(true, true) {
+		return fs.OK
+	}
+
+	now := nostr.Now()
+	if n.filter.Until != nil {
+		now = *n.filter.Until
+	}
+	aMonthAgo := now - 30*24*60*60
+	n.filter.Since = &aMonthAgo
+
+	for ie := range n.sys.Pool.FetchMany(ctx, n.relays, n.filter, nostr.WithLabel("nakfs")) {
+		e := CreateEventDir(ctx, n, n.wd, ie.Event)
+		n.AddChild(ie.Event.ID, e, true)
+	}
+
+	filter := n.filter
+	filter.Until = &aMonthAgo
+
+	n.AddChild("@previous", n.NewPersistentInode(
+		ctx,
+		&ViewDir{
+			ctx:    n.ctx,
+			sys:    n.sys,
+			filter: filter,
+			wd:     n.wd,
+			relays: n.relays,
+		},
+		fs.StableAttr{Mode: syscall.S_IFDIR},
+	), true)
+
+	return fs.OK
+}