braidfs 0.0.22 → 0.0.24

package/index.js

@@ -56,6 +56,9 @@ braid_text.db_folder = config.braid_text_db
 require('fs').mkdirSync(config.proxy_base, { recursive: true })
 require('fs').mkdirSync(config.proxy_base_last_versions, { recursive: true })
 
+let host_to_protocol = {}
+let path_to_func = {}
+
 console.log({ sync_urls: config.sync_urls, sync_index_urls: config.sync_index_urls })
 for (let url of config.sync_urls) proxy_url(url)
 config.sync_index_urls.forEach(async url => {
@@ -71,6 +74,27 @@ braid_text.list().then(x => {
     for (let xx of x) proxy_url(xx)
 })
 
+require('chokidar').watch(config.proxy_base).
+    on('change', (path) => {
+        path = require('path').relative(config.proxy_base, path)
+        console.log(`path changed: ${path}`)
+
+        path = normalize_url(path)
+        // console.log(`normalized path: ${path}`)
+
+        path_to_func[path]()
+    }).
+    on('add', async (path) => {
+        path = require('path').relative(config.proxy_base, path)
+        console.log(`path added: ${path}`)
+
+        let url = null
+        if (path.startsWith('localhost/')) url = path.replace(/^localhost\//, '')
+        else url = host_to_protocol[path.split('/')[0]] + '//' + path
+
+        proxy_url(url)
+    })
+
 const server = http.createServer(async (req, res) => {
     console.log(`${req.method} ${req.url}`);
 
@@ -113,7 +137,15 @@ const server = http.createServer(async (req, res) => {
     // we don't want to let remote people access external links for now
     if (config.allow_remote_access && is_external_link) only_allow_local_host()
 
-    proxy_url(url)
+    let p = await proxy_url(url)
+
+    res.setHeader('Editable', !p.file_read_only)
+    if (req.method == "PUT" || req.method == "POST" || req.method == "PATCH") {
+        if (p.file_read_only) {
+            res.statusCode = 403 // Forbidden status code
+            return res.end('access denied')
+        }
+    }
 
     // Now serve the collaborative text!
     braid_text.serve(req, res, { key: normalize_url(url) })
@@ -124,12 +156,6 @@ server.listen(config.port, () => {
     if (!config.allow_remote_access) console.log('!! only accessible from localhost !!');
 });
 
-////////////////////////////////
-
-function normalize_url(url) {
-    return url.replace(/(\/index|\/)+$/, '')
-}
-
 async function proxy_url(url) {
     let chain = proxy_url.chain || (proxy_url.chain = Promise.resolve())
 
@@ -166,8 +192,9 @@ async function proxy_url(url) {
     url = normalized_url
 
     if (!proxy_url.cache) proxy_url.cache = {}
-    if (proxy_url.cache[url]) return
-    proxy_url.cache[url] = true
+    if (proxy_url.cache[url]) return proxy_url.cache[url]
+    let self = {}
+    proxy_url.cache[url] = self
 
     console.log(`proxy_url: ${url}`)
 
@@ -175,6 +202,11 @@ async function proxy_url(url) {
     let path = is_external_link ? url.replace(/^https?:\/\//, '') : `localhost/${url}`
     let fullpath = require("path").join(config.proxy_base, path)
 
+    if (is_external_link) {
+        let u = new URL(url)
+        host_to_protocol[u.host] = u.protocol
+    }
+
     // if we're accessing /blah/index, it will be normalized to /blah,
     // but we still want to create a directory out of blah in this case
     if (wasnt_normal && !(await is_dir(fullpath))) await ensure_path(fullpath)
@@ -191,6 +223,7 @@ async function proxy_url(url) {
     var char_counter = -1
     let file_last_version = null
     let file_last_text = null
+    self.file_read_only = null
     let file_needs_reading = true
     let file_needs_writing = null
     let file_loop_pump_lock = 0
@@ -229,7 +262,6 @@ async function proxy_url(url) {
                 file_last_text = (await braid_text.get(url, { version: file_last_version })).body
                 file_needs_writing = !v_eq(file_last_version, (await braid_text.get(url, {})).version)
             } catch (e) {
-                file_last_version = []
                 file_last_text = ''
                 file_needs_writing = true
             }
@@ -239,6 +271,8 @@ async function proxy_url(url) {
             if (file_needs_reading) {
                 file_needs_reading = false
 
+                if (self.file_read_only === null) try { self.file_read_only = await is_read_only(await get_fullpath()) } catch (e) { }
+
                 let text = ''
                 try { text = await require('fs').promises.readFile(await get_fullpath(), { encoding: 'utf8' }) } catch (e) { }
 
@@ -267,11 +301,15 @@ async function proxy_url(url) {
 
                     console.log(`writing file ${await get_fullpath()}`)
 
+                    try { if (await is_read_only(await get_fullpath())) await set_read_only(await get_fullpath(), false) } catch (e) { }
+
                     file_last_version = version
                     file_last_text = body
                     await require('fs').promises.writeFile(await get_fullpath(), file_last_text)
                     await require('fs').promises.writeFile(require('path').join(config.proxy_base_last_versions, braid_text.encode_filename(url)), JSON.stringify(file_last_version))
                 }
+
+                if (await is_read_only(await get_fullpath()) !== self.file_read_only) await set_read_only(await get_fullpath(), self.file_read_only)
             }
         }
         file_loop_pump_lock--
@@ -280,7 +318,8 @@ async function proxy_url(url) {
     if (is_external_link) braid_fetch_wrapper(url, {
         headers: {
             "Merge-Type": "dt",
-            Accept: 'text/plain'
+            Accept: 'text/plain',
+            ...config?.domains?.[(new URL(url)).hostname]?.auth_headers,
         },
         subscribe: true,
         retry: true,
@@ -289,6 +328,9 @@ async function proxy_url(url) {
             if (cur.version.length) return cur.version
         },
         peer
+    }, (res) => {
+        self.file_read_only = res.headers.get('editable') === 'false'
+        signal_file_needs_writing()
     }).then(x => {
         x.subscribe(async update => {
             // console.log(`update: ${JSON.stringify(update, null, 4)}`)
@@ -300,21 +342,7 @@ async function proxy_url(url) {
         })
     })
 
-    if (!proxy_url.path_to_func) proxy_url.path_to_func = {}
-    proxy_url.path_to_func[path] = signal_file_needs_reading
-
-    if (!proxy_url.chokidar) {
-        proxy_url.chokidar = true
-        require('chokidar').watch(config.proxy_base).on('change', (path) => {
-            path = require('path').relative(config.proxy_base, path)
-            console.log(`path changed: ${path}`)
-
-            path = normalize_url(path)
-            // console.log(`normalized path: ${path}`)
-
-            proxy_url.path_to_func[path]()
-        });
-    }
+    path_to_func[path] = signal_file_needs_reading
 
     // try a HEAD without subscribe to get the version
     let parents = null
@@ -322,12 +350,17 @@ async function proxy_url(url) {
         try {
             let head_res = await braid_fetch_wrapper(url, {
                 method: 'HEAD',
-                headers: { Accept: 'text/plain' },
+                headers: {
+                    Accept: 'text/plain',
+                    ...config?.domains?.[(new URL(url)).hostname]?.auth_headers,
+                },
                 retry: true,
             })
             parents = head_res.headers.get('version') ?
                 JSON.parse(`[${head_res.headers.get('version')}]`) :
                 null
+            self.file_read_only = head_res.headers.get('editable') === 'false'
+            signal_file_needs_writing()
         } catch (e) {
             console.log('HEAD failed: ', e)
         }
@@ -348,6 +381,14 @@ async function proxy_url(url) {
             send_out({ version, parents, body, patches, peer })
         },
     })
+
+    return self
+}
+
+////////////////////////////////
+
+function normalize_url(url) {
+    return url.replace(/(\/index|\/)+$/, '')
 }
 
 async function is_dir(p) {
@@ -431,7 +472,7 @@ function count_code_points(str) {
     return code_points
 }
 
-async function braid_fetch_wrapper(url, params) {
+async function braid_fetch_wrapper(url, params, connection_cb) {
     if (!params.retry) throw "wtf"
     var waitTime = 10
     if (params.subscribe) {
@@ -441,6 +482,7 @@ async function braid_fetch_wrapper(url, params) {
             if (params.signal?.aborted) return
             try {
                 var c = await braid_fetch(url, { ...params, parents: await params.parents?.() })
+                connection_cb(c)
                 c.subscribe((...args) => subscribe_handler?.(...args), on_error)
                 waitTime = 10
             } catch (e) {
@@ -471,5 +513,25 @@ async function braid_fetch_wrapper(url, params) {
 }
 
 function v_eq(v1, v2) {
-    return v1.length == v2.length && v1.every((x, i) => x == v2[i])
+    return v1.length === v2?.length && v1.every((x, i) => x == v2[i])
+}
+
+async function is_read_only(fullpath) {
+    const stats = await require('fs').promises.stat(fullpath)
+    return require('os').platform() === "win32" ?
+        !!(stats.mode & 0x1) :
+        !(stats.mode & 0o200)
+}
+
+async function set_read_only(fullpath, read_only) {
+    if (require('os').platform() === "win32") {
+        await new Promise((resolve, reject) => {
+            require("child_process").exec(`fsutil file setattr readonly "${fullpath}" ${!!read_only}`, (error) => error ? reject(error) : resolve())
+        })
+    } else {
+        let mode = (await require('fs').promises.stat(fullpath)).mode
+        if (read_only) mode &= ~0o222
+        else mode |= 0o200
+        await require('fs').promises.chmod(fullpath, mode)
+    }
 }

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "braidfs",
-  "version": "0.0.22",
+  "version": "0.0.24",
   "description": "braid technology synchronizing files and webpages",
   "author": "Braid Working Group",
   "repository": "braid-org/braidfs",
   "homepage": "https://braid.org",
   "dependencies": {
     "braid-http": "^0.3.20",
-    "braid-text": "^0.0.26",
+    "braid-text": "^0.0.27",
     "chokidar": "^3.6.0"
   },
   "bin": {