1 // Replay is a server that allows developers to update code it real-time while maintaing the current state. 2 package main // vimagination.zapto.org/replay 3 4 import ( 5 "flag" 6 "fmt" 7 "io" 8 "io/fs" 9 "net" 10 "net/http" 11 "os" 12 "strconv" 13 "strings" 14 "text/template" 15 16 "vimagination.zapto.org/tsserver" 17 ) 18 19 var injectImport = []byte("import '/___';") 20 21 func main() { 22 if err := run(); err != nil { 23 fmt.Fprintln(os.Stderr, err) 24 25 os.Exit(1) 26 } 27 } 28 29 func run() error { 30 var listen, base, jsx string 31 32 flag.StringVar(&listen, "l", ":8080", "listen address") 33 flag.StringVar(&base, "b", "", "base address to files") 34 flag.StringVar(&jsx, "j", "", "JSX translation template") 35 36 flag.Parse() 37 38 l, err := net.Listen("tcp", listen) 39 if err != nil { 40 return err 41 } 42 43 var opts []tsserver.Option 44 45 if jsx != "" { 46 tmpl, err := template.New("").Parse(jsx) 47 if err != nil { 48 return err 49 } 50 51 opts = append(opts, tsserver.JSX(tmpl)) 52 } 53 54 w, err := NewWatcher(base) 55 if err != nil { 56 return err 57 } 58 59 return http.Serve(l, newMux(os.DirFS(base), w, opts...)) 60 } 61 62 func newMux(base fs.FS, w *watcher, opts ...tsserver.Option) http.Handler { 63 mux := http.NewServeMux() 64 65 mux.Handle("/____", forwardChanges(w)) 66 mux.Handle("/___", http.HandlerFunc(serveInject)) 67 mux.Handle("/", http.FileServer(http.FS(injector{tsserver.WrapFS(base, opts...)}))) 68 69 return mux 70 } 71 72 func forwardChanges(fsw *watcher) http.HandlerFunc { 73 return func(w http.ResponseWriter, r *http.Request) { 74 w.Header().Set("Content-Type", "text/event-stream") 75 w.Header().Set("Cache-Control", "no-cache") 76 w.Header().Set("Connection", "keep-alive") 77 78 ch := fsw.Listen() 79 defer fsw.Cancel(ch) 80 81 ctx := r.Context() 82 flusher := w.(http.Flusher) 83 84 flusher.Flush() 85 86 for { 87 select { 88 case <-ctx.Done(): 89 return 90 case file := <-ch: 91 fmt.Fprintf(w, "data: %s\n\n", file) 92 flusher.Flush() 93 } 94 } 95 } 96 } 97 98 func serveInject(w http.ResponseWriter, r *http.Request) { 99 w.Header().Set("Content-Type", "application/javascript") 100 w.Header().Set("Content-Length", strconv.Itoa(len(injectJS))) 101 io.WriteString(w, injectJS) 102 } 103 104 type injector struct { 105 fs.FS 106 } 107 108 func (i injector) Open(name string) (fs.File, error) { 109 if !strings.HasSuffix(name, ".js") { 110 return i.FS.Open(name) 111 } 112 113 f, err := i.FS.Open(name) 114 if err != nil { 115 return nil, err 116 } 117 118 return &wrapped{f, injectImport}, nil 119 } 120 121 type wrapped struct { 122 fs.File 123 inject []byte 124 } 125 126 func (w *wrapped) Stat() (fs.FileInfo, error) { 127 fi, err := w.File.Stat() 128 if err != nil { 129 return nil, err 130 } 131 132 return &wrappedFI{fi}, nil 133 } 134 135 func (w *wrapped) Read(p []byte) (n int, err error) { 136 if len(w.inject) > 0 { 137 n = copy(p, w.inject) 138 w.inject = w.inject[n:] 139 p = p[n:] 140 141 if len(p) == 0 { 142 return n, nil 143 } 144 } 145 146 m, err := w.File.Read(p) 147 148 return n + m, err 149 } 150 151 type wrappedFI struct { 152 fs.FileInfo 153 } 154 155 func (w *wrappedFI) Size() int64 { 156 return w.FileInfo.Size() + int64(len(injectImport)) 157 } 158