trying to get this thing to build again on github.

.github/workflows/release-cli.yml

@@ -25,7 +25,7 @@ jobs:
     strategy:
       matrix:
         goos: [linux, freebsd, darwin, windows]
-        goarch: [arm, amd64, arm64, riscv64]
+        goarch: [amd64, arm64, riscv64]
         exclude:
           - goarch: arm64
             goos: windows
@@ -33,11 +33,7 @@ jobs:
             goos: windows
           - goarch: riscv64
             goos: darwin
-          - goarch: arm
-            goos: windows
-          - goarch: arm
-            goos: darwin
-          - goarch: arm
+          - goarch: arm64
             goos: freebsd
     steps:
       - uses: actions/checkout@v3

.gitignore

@@ -1 +1,2 @@
 nak
+mnt

fs.go

@@ -0,0 +1,89 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"github.com/fatih/color"
+	"github.com/fiatjaf/nak/nostrfs"
+	"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/keyer"
+	"github.com/urfave/cli/v3"
+)
+
+var fsCmd = &cli.Command{
+	Name:        "fs",
+	Usage:       "mount a FUSE filesystem that exposes Nostr events as files.",
+	Description: `(experimental)`,
+	ArgsUsage:   "<mountpoint>",
+	Flags: []cli.Flag{
+		&cli.StringFlag{
+			Name:  "pubkey",
+			Usage: "public key from where to to prepopulate directories",
+			Validator: func(pk string) error {
+				if nostr.IsValidPublicKey(pk) {
+					return nil
+				}
+				return fmt.Errorf("invalid public key '%s'", pk)
+			},
+		},
+	},
+	DisableSliceFlagSeparator: true,
+	Action: func(ctx context.Context, c *cli.Command) error {
+		mountpoint := c.Args().First()
+		if mountpoint == "" {
+			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")),
+			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,
+				Name:   "nak",
+				FsName: "nak",
+			},
+			AttrTimeout:  &timeout,
+			EntryTimeout: &timeout,
+			Logger:       nostr.DebugLogger,
+		})
+		if err != nil {
+			return fmt.Errorf("mount failed: %w", err)
+		}
+		log("ok\n")
+
+		// setup signal handling for clean unmount
+		ch := make(chan os.Signal, 1)
+		chErr := make(chan error)
+		signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
+		go func() {
+			<-ch
+			log("- unmounting... ")
+			err := server.Unmount()
+			if err != nil {
+				chErr <- fmt.Errorf("unmount failed: %w", err)
+			} else {
+				log("ok\n")
+				chErr <- nil
+			}
+		}()
+
+		// serve the filesystem until unmounted
+		server.Wait()
+		return <-chErr
+	},
+}

go.mod

@@ -1,8 +1,6 @@
 module github.com/fiatjaf/nak
 
-go 1.23.3
-
-toolchain go1.23.4
+go 1.24.1
 
 require (
 	github.com/bep/debounce v1.2.1
@@ -12,11 +10,13 @@ require (
 	github.com/fatih/color v1.16.0
 	github.com/fiatjaf/eventstore v0.15.0
 	github.com/fiatjaf/khatru v0.16.0
+	github.com/hanwen/go-fuse/v2 v2.7.2
 	github.com/json-iterator/go v1.1.12
+	github.com/liamg/magic v0.0.1
 	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.3
+	github.com/nbd-wtf/go-nostr v0.51.2
 	github.com/urfave/cli/v3 v3.0.0-beta1
 	golang.org/x/exp v0.0.0-20250210185358-939b2ce775ac
 )
@@ -28,8 +28,8 @@ require (
 	github.com/btcsuite/btcd v0.24.2 // indirect
 	github.com/btcsuite/btcd/btcutil v1.1.5 // indirect
 	github.com/btcsuite/btcd/chaincfg/chainhash v1.1.0 // indirect
-	github.com/bytedance/sonic v1.12.10 // indirect
-	github.com/bytedance/sonic/loader v0.2.3 // indirect
+	github.com/bytedance/sonic v1.13.1 // indirect
+	github.com/bytedance/sonic/loader v0.2.4 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/chzyer/logex v1.1.10 // indirect
 	github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1 // indirect
@@ -50,10 +50,10 @@ require (
 	github.com/josharian/intern v1.0.0 // indirect
 	github.com/klauspost/compress v1.18.0 // indirect
 	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
+	github.com/kylelemons/godebug v1.1.0 // indirect
 	github.com/magefile/mage v1.14.0 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/minio/simdjson-go v0.4.5 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/pkg/errors v0.9.1 // indirect

go.sum

@@ -33,11 +33,11 @@ github.com/btcsuite/snappy-go v0.0.0-20151229074030-0bdef8d06723/go.mod h1:8woku
 github.com/btcsuite/snappy-go v1.0.0/go.mod h1:8woku9dyThutzjeg+3xrA5iCpBRH8XEEg3lh6TiUghc=
 github.com/btcsuite/websocket v0.0.0-20150119174127-31079b680792/go.mod h1:ghJtEyQwv5/p4Mg4C0fgbePVuGr935/5ddU9Z3TmDRY=
 github.com/btcsuite/winsvc v1.0.0/go.mod h1:jsenWakMcC0zFBFurPLEAyrnc/teJEM1O46fmI40EZs=
-github.com/bytedance/sonic v1.12.10 h1:uVCQr6oS5669E9ZVW0HyksTLfNS7Q/9hV6IVS4nEMsI=
-github.com/bytedance/sonic v1.12.10/go.mod h1:uVvFidNmlt9+wa31S1urfwwthTWteBgG0hWuoKAXTx8=
+github.com/bytedance/sonic v1.13.1 h1:Jyd5CIvdFnkOWuKXr+wm4Nyk2h0yAFsr8ucJgEasO3g=
+github.com/bytedance/sonic v1.13.1/go.mod h1:o68xyaF9u2gvVBuGHPlUVCy+ZfmNNO5ETf1+KgkJhz4=
 github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
-github.com/bytedance/sonic/loader v0.2.3 h1:yctD0Q3v2NOGfSWPLPvG2ggA2kV6TS6s4wioyEqssH0=
-github.com/bytedance/sonic/loader v0.2.3/go.mod h1:N8A3vUdtUebEY2/VQC0MyhYeKUFosQU6FxH2JmUe6VI=
+github.com/bytedance/sonic/loader v0.2.4 h1:ZWCw4stuXUsn1/+zQDqeE7JKP+QO47tz7QCNan80NzY=
+github.com/bytedance/sonic/loader v0.2.4/go.mod h1:N8A3vUdtUebEY2/VQC0MyhYeKUFosQU6FxH2JmUe6VI=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/chzyer/logex v1.1.10 h1:Swpa1K6QvQznwJRcfTfQJmTE72DqScAa40E+fbHEXEE=
@@ -96,6 +96,8 @@ github.com/golang/snappy v0.0.4/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEW
 github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
 github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
@@ -106,6 +108,8 @@ github.com/hablullah/go-hijri v1.0.2 h1:drT/MZpSZJQXo7jftf5fthArShcaMtsal0Zf/dnm
 github.com/hablullah/go-hijri v1.0.2/go.mod h1:OS5qyYLDjORXzK4O1adFw9Q5WfhOcMdAKglDkcTxgWQ=
 github.com/hablullah/go-juliandays v1.0.0 h1:A8YM7wIj16SzlKT0SRJc9CD29iiaUzpBLzh5hr0/5p0=
 github.com/hablullah/go-juliandays v1.0.0/go.mod h1:0JOYq4oFOuDja+oospuc61YoX+uNEn7Z6uHYTbBzdGc=
+github.com/hanwen/go-fuse/v2 v2.7.2 h1:SbJP1sUP+n1UF8NXBA14BuojmTez+mDgOk0bC057HQw=
+github.com/hanwen/go-fuse/v2 v2.7.2/go.mod h1:ugNaD/iv5JYyS1Rcvi57Wz7/vrLQJo10mmketmoef48=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/jalaali/go-jalaali v0.0.0-20210801064154-80525e88d958 h1:qxLoi6CAcXVzjfvu+KXIXJOAsQB62LXjsfbOaErsVzE=
 github.com/jalaali/go-jalaali v0.0.0-20210801064154-80525e88d958/go.mod h1:Wqfu7mjUHj9WDzSSPI5KfBclTTEnLveRUFr/ujWnTgE=
@@ -123,6 +127,10 @@ github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa02
 github.com/klauspost/cpuid/v2 v2.2.10 h1:tBs3QSyvjDyFTq3uoc/9xFpCuOsJQFNPiAhYdw2skhE=
 github.com/klauspost/cpuid/v2 v2.2.10/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
 github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
+github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
+github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
+github.com/liamg/magic v0.0.1 h1:Ru22ElY+sCh6RvRTWjQzKKCxsEco8hE0co8n1qe7TBM=
+github.com/liamg/magic v0.0.1/go.mod h1:yQkOmZZI52EA+SQ2xyHpVw8fNvTBruF873Y+Vt6S+fk=
 github.com/magefile/mage v1.14.0 h1:6QDX3g6z1YvJ4olPhT1wksUcSa/V0a1B+pJb73fBjyo=
 github.com/magefile/mage v1.14.0/go.mod h1:z5UZb/iS3GoOSn0JgWuiw7dxlurVYTu+/jHXqQg881A=
 github.com/mailru/easyjson v0.9.0 h1:PrnmzHw7262yW8sTBwxi1PdJA3Iw/EKBa8psRf7d9a4=
@@ -136,15 +144,15 @@ github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovk
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/minio/simdjson-go v0.4.5 h1:r4IQwjRGmWCQ2VeMc7fGiilu1z5du0gJ/I/FsKwgo5A=
-github.com/minio/simdjson-go v0.4.5/go.mod h1:eoNz0DcLQRyEDeaPr4Ru6JpjlZPzbA0IodxVJk8lO8E=
+github.com/moby/sys/mountinfo v0.6.2 h1:BzJjoreD5BMFNmD9Rus6gdd1pLuecOFPt8wC+Vygl78=
+github.com/moby/sys/mountinfo v0.6.2/go.mod h1:IJb6JQeOklcdMU9F5xQ8ZALD+CUr5VlGpwtX+VE0rpI=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
 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.50.3 h1:mRUJLOkCqnNTAwvjtSRogJyN3SUv1lze1UgnmqUBN0Q=
-github.com/nbd-wtf/go-nostr v0.50.3/go.mod h1:XJyV09CfSZCtuf1ApdQFc+3RuEYzt4E/pbXn+doA8tQ=
+github.com/nbd-wtf/go-nostr v0.51.2 h1:wQysG8omkF4LO7kcU6yoeCBBxD92SwUNab4TMeSuZZM=
+github.com/nbd-wtf/go-nostr v0.51.2/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=
@@ -254,4 +262,6 @@ gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gotest.tools v2.2.0+incompatible h1:VsBPFP1AI068pPrMxtb/S8Zkgf9xEmTLJjfM+P5UIEo=
+gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw=
 nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=

helpers.go

@@ -15,10 +15,10 @@ import (
 	"time"
 
 	"github.com/fatih/color"
-	"github.com/urfave/cli/v3"
 	jsoniter "github.com/json-iterator/go"
 	"github.com/nbd-wtf/go-nostr"
 	"github.com/nbd-wtf/go-nostr/sdk"
+	"github.com/urfave/cli/v3"
 )
 
 var sys *sdk.System

main.go

@@ -13,7 +13,10 @@ import (
 	"github.com/urfave/cli/v3"
 )
 
-var version string = "debug"
+var (
+	version   string = "debug"
+	isVerbose bool   = false
+)
 
 var app = &cli.Command{
 	Name:                      "nak",
@@ -41,6 +44,7 @@ var app = &cli.Command{
 		mcpServer,
 		curl,
 		dvm,
+		fsCmd,
 	},
 	Version: version,
 	Flags: []cli.Flag{
@@ -71,6 +75,7 @@ var app = &cli.Command{
 				v := c.Count("verbose")
 				if v >= 1 {
 					logverbose = log
+					isVerbose = true
 				}
 				return nil
 			},

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/entitydir.go

@@ -0,0 +1,214 @@
+package nostrfs
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"path/filepath"
+	"strconv"
+	"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/nip19"
+	"github.com/nbd-wtf/go-nostr/nip27"
+	"github.com/nbd-wtf/go-nostr/nip92"
+	sdk "github.com/nbd-wtf/go-nostr/sdk"
+)
+
+type EntityDir struct {
+	fs.Inode
+	ctx context.Context
+	wd  string
+	evt *nostr.Event
+}
+
+var _ = (fs.NodeGetattrer)((*EntityDir)(nil))
+
+func (e *EntityDir) Getattr(ctx context.Context, f fs.FileHandle, out *fuse.AttrOut) syscall.Errno {
+	publishedAt := uint64(e.evt.CreatedAt)
+	out.Ctime = publishedAt
+
+	if tag := e.evt.Tags.Find("published_at"); tag != nil {
+		publishedAt, _ = strconv.ParseUint(tag[1], 10, 64)
+	}
+	out.Mtime = publishedAt
+
+	return fs.OK
+}
+
+func FetchAndCreateEntityDir(
+	ctx context.Context,
+	parent fs.InodeEmbedder,
+	wd string,
+	extension string,
+	sys *sdk.System,
+	pointer nostr.EntityPointer,
+) (*fs.Inode, error) {
+	event, _, err := sys.FetchSpecificEvent(ctx, pointer, sdk.FetchSpecificEventParameters{
+		WithRelays: false,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch: %w", err)
+	}
+
+	return CreateEntityDir(ctx, parent, wd, extension, event), nil
+}
+
+func CreateEntityDir(
+	ctx context.Context,
+	parent fs.InodeEmbedder,
+	wd string,
+	extension string,
+	event *nostr.Event,
+) *fs.Inode {
+	h := parent.EmbeddedInode().NewPersistentInode(
+		ctx,
+		&EntityDir{ctx: ctx, wd: wd, evt: event},
+		fs.StableAttr{Mode: syscall.S_IFDIR, Ino: hexToUint64(event.ID)},
+	)
+
+	var publishedAt uint64
+	if tag := event.Tags.Find("published_at"); tag != nil {
+		publishedAt, _ = strconv.ParseUint(tag[1], 10, 64)
+	}
+
+	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, _ := json.MarshalIndent(event, "", "  ")
+	h.AddChild("event.json", h.NewPersistentInode(
+		ctx,
+		&fs.MemRegularFile{
+			Data: eventj,
+			Attr: fuse.Attr{
+				Mode:  0444,
+				Ctime: uint64(event.CreatedAt),
+				Mtime: uint64(publishedAt),
+				Size:  uint64(len(event.Content)),
+			},
+		},
+		fs.StableAttr{},
+	), true)
+
+	h.AddChild("identifier", h.NewPersistentInode(
+		ctx,
+		&fs.MemRegularFile{
+			Data: []byte(event.Tags.GetD()),
+			Attr: fuse.Attr{
+				Mode:  0444,
+				Ctime: uint64(event.CreatedAt),
+				Mtime: uint64(publishedAt),
+				Size:  uint64(len(event.Tags.GetD())),
+			},
+		},
+		fs.StableAttr{},
+	), true)
+
+	if tag := event.Tags.Find("title"); tag != nil {
+		h.AddChild("title", h.NewPersistentInode(
+			ctx,
+			&fs.MemRegularFile{
+				Data: []byte(tag[1]),
+				Attr: fuse.Attr{
+					Mode:  0444,
+					Ctime: uint64(event.CreatedAt),
+					Mtime: uint64(publishedAt),
+					Size:  uint64(len(tag[1])),
+				},
+			},
+			fs.StableAttr{},
+		), true)
+	}
+
+	h.AddChild("content"+extension, h.NewPersistentInode(
+		ctx,
+		&fs.MemRegularFile{
+			Data: []byte(event.Content),
+			Attr: fuse.Attr{
+				Mode:  0444,
+				Ctime: uint64(event.CreatedAt),
+				Mtime: uint64(publishedAt),
+				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
+	addImage := func(url string) {
+		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(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", 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)
+	}
+
+	images := nip92.ParseTags(event.Tags)
+	for _, imeta := range images {
+		if imeta.URL == "" {
+			continue
+		}
+		addImage(imeta.URL)
+	}
+
+	if tag := event.Tags.Find("image"); tag != nil {
+		addImage(tag[1])
+	}
+
+	return h
+}

nostrfs/eventdir.go

@@ -0,0 +1,241 @@
+package nostrfs
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"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/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) {
+	event, _, err := sys.FetchSpecificEvent(ctx, pointer, sdk.FetchSpecificEventParameters{
+		WithRelays: false,
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch: %w", err)
+	}
+
+	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, 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, _ := json.MarshalIndent(event, "", "  ")
+	h.AddChild("event.json", h.NewPersistentInode(
+		ctx,
+		&fs.MemRegularFile{
+			Data: eventj,
+			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(64),
+			},
+		},
+		fs.StableAttr{},
+	), true)
+
+	h.AddChild("content.txt", h.NewPersistentInode(
+		ctx,
+		&fs.MemRegularFile{
+			Data: []byte(event.Content),
+			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/helpers.go

@@ -0,0 +1,8 @@
+package nostrfs
+
+import "strconv"
+
+func hexToUint64(hexStr string) uint64 {
+	v, _ := strconv.ParseUint(hexStr[16:32], 16, 64)
+	return v
+}

nostrfs/npubdir.go

@@ -0,0 +1,275 @@
+package nostrfs
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"io"
+	"net/http"
+	"sync/atomic"
+	"syscall"
+	"time"
+
+	"github.com/hanwen/go-fuse/v2/fs"
+	"github.com/hanwen/go-fuse/v2/fuse"
+	"github.com/liamg/magic"
+	"github.com/nbd-wtf/go-nostr"
+	sdk "github.com/nbd-wtf/go-nostr/sdk"
+)
+
+type NpubDir struct {
+	sys *sdk.System
+	fs.Inode
+	pointer nostr.ProfilePointer
+	ctx     context.Context
+	fetched atomic.Bool
+}
+
+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}
+	h := parent.EmbeddedInode().NewPersistentInode(
+		ctx,
+		npubdir,
+		fs.StableAttr{Mode: syscall.S_IFDIR, Ino: hexToUint64(pointer.PublicKey)},
+	)
+
+	relays := sys.FetchOutboxRelays(ctx, pointer.PublicKey, 2)
+
+	h.AddChild("pubkey", h.NewPersistentInode(
+		ctx,
+		&fs.MemRegularFile{Data: []byte(pointer.PublicKey + "\n"), Attr: fuse.Attr{Mode: 0444}},
+		fs.StableAttr{},
+	), true)
+
+	go func() {
+		pm := sys.FetchProfileMetadata(ctx, pointer.PublicKey)
+		if pm.Event == nil {
+			return
+		}
+
+		metadataj, _ := json.MarshalIndent(pm, "", "  ")
+		h.AddChild(
+			"metadata.json",
+			h.NewPersistentInode(
+				ctx,
+				&fs.MemRegularFile{
+					Data: metadataj,
+					Attr: fuse.Attr{
+						Mtime: uint64(pm.Event.CreatedAt),
+						Mode:  0444,
+					},
+				},
+				fs.StableAttr{},
+			),
+			true,
+		)
+
+		ctx, cancel := context.WithTimeout(ctx, time.Second*20)
+		defer cancel()
+		r, err := http.NewRequestWithContext(ctx, "GET", pm.Picture, nil)
+		if err == nil {
+			resp, err := http.DefaultClient.Do(r)
+			if err == nil {
+				defer resp.Body.Close()
+				if resp.StatusCode < 300 {
+					b := &bytes.Buffer{}
+					io.Copy(b, resp.Body)
+
+					ext := "png"
+					if ft, err := magic.Lookup(b.Bytes()); err == nil {
+						ext = ft.Extension
+					}
+
+					h.AddChild("picture."+ext, h.NewPersistentInode(
+						ctx,
+						&fs.MemRegularFile{
+							Data: b.Bytes(),
+							Attr: fuse.Attr{
+								Mtime: uint64(pm.Event.CreatedAt),
+								Mode:  0444,
+							},
+						},
+						fs.StableAttr{},
+					), true)
+				}
+			}
+		}
+	}()
+
+	h.AddChild(
+		"notes",
+		h.NewPersistentInode(
+			ctx,
+			&ViewDir{
+				ctx: ctx,
+				sys: sys,
+				wd:  wd,
+				filter: nostr.Filter{
+					Kinds:   []int{1},
+					Authors: []string{pointer.PublicKey},
+				},
+				paginate: true,
+				relays:   relays,
+				create: func(ctx context.Context, n *ViewDir, event *nostr.Event) (string, *fs.Inode) {
+					return event.ID, CreateEventDir(ctx, n, n.wd, event)
+				},
+			},
+			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},
+				},
+				paginate: true,
+				relays:   relays,
+				create: func(ctx context.Context, n *ViewDir, event *nostr.Event) (string, *fs.Inode) {
+					return event.ID, CreateEventDir(ctx, n, n.wd, event)
+				},
+			},
+			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},
+				},
+				paginate: true,
+				relays:   relays,
+				create: func(ctx context.Context, n *ViewDir, event *nostr.Event) (string, *fs.Inode) {
+					return event.ID, CreateEventDir(ctx, n, n.wd, event)
+				},
+			},
+			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},
+				},
+				paginate: true,
+				relays:   relays,
+				create: func(ctx context.Context, n *ViewDir, event *nostr.Event) (string, *fs.Inode) {
+					return event.ID, CreateEventDir(ctx, n, n.wd, event)
+				},
+			},
+			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},
+				},
+				paginate: true,
+				relays:   relays,
+				create: func(ctx context.Context, n *ViewDir, event *nostr.Event) (string, *fs.Inode) {
+					return event.ID, CreateEventDir(ctx, n, n.wd, event)
+				},
+			},
+			fs.StableAttr{Mode: syscall.S_IFDIR},
+		),
+		true,
+	)
+
+	h.AddChild(
+		"articles",
+		h.NewPersistentInode(
+			ctx,
+			&ViewDir{
+				ctx: ctx,
+				sys: sys,
+				wd:  wd,
+				filter: nostr.Filter{
+					Kinds:   []int{30023},
+					Authors: []string{pointer.PublicKey},
+				},
+				paginate: false,
+				relays:   relays,
+				create: func(ctx context.Context, n *ViewDir, event *nostr.Event) (string, *fs.Inode) {
+					d := event.Tags.GetD()
+					if d == "" {
+						d = "_"
+					}
+					return d, CreateEntityDir(ctx, n, n.wd, ".md", event)
+				},
+			},
+			fs.StableAttr{Mode: syscall.S_IFDIR},
+		),
+		true,
+	)
+
+	h.AddChild(
+		"wiki",
+		h.NewPersistentInode(
+			ctx,
+			&ViewDir{
+				ctx: ctx,
+				sys: sys,
+				wd:  wd,
+				filter: nostr.Filter{
+					Kinds:   []int{30818},
+					Authors: []string{pointer.PublicKey},
+				},
+				paginate: false,
+				relays:   relays,
+				create: func(ctx context.Context, n *ViewDir, event *nostr.Event) (string, *fs.Inode) {
+					d := event.Tags.GetD()
+					if d == "" {
+						d = "_"
+					}
+					return d, CreateEntityDir(ctx, n, n.wd, ".adoc", event)
+				},
+			},
+			fs.StableAttr{Mode: syscall.S_IFDIR},
+		),
+		true,
+	)
+
+	return h
+}

nostrfs/root.go

@@ -0,0 +1,110 @@
+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 {
+	fs.Inode
+
+	ctx        context.Context
+	wd         string
+	sys        *sdk.System
+	rootPubKey string
+	signer     nostr.Signer
+}
+
+var _ = (fs.NodeOnAdder)((*NostrRoot)(nil))
+
+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{
+		ctx:        ctx,
+		sys:        sys,
+		rootPubKey: pubkey,
+		signer:     signer,
+		wd:         abs,
+	}
+}
+
+func (r *NostrRoot) OnAdd(context.Context) {
+	if r.rootPubKey == "" {
+		return
+	}
+
+	// add our contacts
+	fl := r.sys.FetchFollowList(r.ctx, r.rootPubKey)
+	for _, f := range fl.Items {
+		pointer := nostr.ProfilePointer{PublicKey: f.Pubkey, Relays: []string{f.Relay}}
+		npub, _ := nip19.EncodePublicKey(f.Pubkey)
+		r.AddChild(
+			npub,
+			CreateNpubDir(r.ctx, r.sys, r, r.wd, pointer),
+			true,
+		)
+	}
+
+	// add ourselves
+	npub, _ := nip19.EncodePublicKey(r.rootPubKey)
+	if r.GetChild(npub) == nil {
+		pointer := nostr.ProfilePointer{PublicKey: r.rootPubKey}
+		r.AddChild(
+			npub,
+			CreateNpubDir(r.ctx, r.sys, r, r.wd, pointer),
+			true,
+		)
+	}
+
+	// add a link to ourselves
+	r.AddChild("@me", r.NewPersistentInode(
+		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) {
+	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
+	}
+
+	switch p := pointer.(type) {
+	case nostr.ProfilePointer:
+		npubdir := CreateNpubDir(ctx, r.sys, r, r.wd, p)
+		return npubdir, fs.OK
+	case nostr.EventPointer:
+		eventdir, err := FetchAndCreateEventDir(ctx, r, r.wd, r.sys, p)
+		if err != nil {
+			return nil, syscall.ENOENT
+		}
+		return eventdir, fs.OK
+	default:
+		return nil, syscall.ENOENT
+	}
+}

nostrfs/viewdir.go

@@ -0,0 +1,82 @@
+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
+	paginate bool
+	relays   []string
+	create   func(context.Context, *ViewDir, *nostr.Event) (string, *fs.Inode)
+}
+
+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
+	}
+
+	if n.paginate {
+		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")) {
+			basename, inode := n.create(ctx, n, ie.Event)
+			n.AddChild(basename, inode, 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)
+	} else {
+		for ie := range n.sys.Pool.FetchMany(ctx, n.relays, n.filter, nostr.WithLabel("nakfs")) {
+			basename, inode := n.create(ctx, n, ie.Event)
+			n.AddChild(basename, inode, true)
+		}
+	}
+
+	return fs.OK
+}