braidfs 0.0.26 → 0.0.28

package/index.js

@@ -19,7 +19,7 @@ if (!require('fs').existsSync(braidfs_config_file)) {
         sync_urls: [],
         sync_index_urls: [],
         proxy_base: require('path').join(require('os').homedir(), 'http'),
-        proxy_base_last_versions: require('path').join(braidfs_config_dir, 'proxy_base_last_versions'),
+        proxy_base_meta: require('path').join(braidfs_config_dir, 'proxy_base_meta'),
         braid_text_db: require('path').join(braidfs_config_dir, 'braid-text-db'),
         domains: { 'example.com': { auth_headers: { Cookie: "secret_pass" } } }
     }, null, 4))
@@ -28,33 +28,52 @@ if (!require('fs').existsSync(braidfs_config_file)) {
 let config = JSON.parse(require('fs').readFileSync(braidfs_config_file, 'utf8'))
 
 // process command line args (override config)
+console.log(`braidfs version: ${require('./package.json').version}`)
 let argv = process.argv.slice(2)
 let save_config = false
 while (argv.length) {
     let a = argv.shift()
     if (a.match(/^\d+$/)) {
         config.port = parseInt(a)
+        console.log(`setting port to ${config.port}`)
     } else if (a === 'sync') {
         let b = argv.shift()
         if (b === 'index') {
             config.sync_index_urls.push(argv.shift())
+            console.log(`syncing index url: ${config.sync_index_urls.slice(-1)[0]}`)
         } else {
             config.sync_urls.push(b)
+            console.log(`syncing url: ${config.sync_urls.slice(-1)[0]}`)
         }
     } else if (a === 'save') {
         save_config = true
+        console.log(`will save new config file`)
     } else if (a === 'expose') {
         config.allow_remote_access = true
+        console.log(`exposing server to the outside world`)
     } else if (a === 'unexpose') {
         config.allow_remote_access = false
+        console.log(`unexpose server from the outside world`)
     }
 }
-if (save_config) require('fs').writeFileSync(braidfs_config_file, JSON.stringify(config, null, 4))
+if (config.proxy_base_last_versions && !config.proxy_base_meta) {
+    config.proxy_base_meta = config.proxy_base_last_versions
+    delete config.proxy_base_last_versions
+    console.log((save_config ?
+        `updating config file "proxy_base_last_versions" to "proxy_base_meta": ` :
+        `config file "proxy_base_last_versions" being interpreted as "proxy_base_meta": `) +
+        config.proxy_base_meta)
+}
+
+if (save_config) {
+    require('fs').writeFileSync(braidfs_config_file, JSON.stringify(config, null, 4))
+    console.log(`saved config file`)
+}
 
 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 })
+require('fs').mkdirSync(config.proxy_base_meta, { recursive: true })
 
 let host_to_protocol = {}
 let path_to_func = {}
@@ -77,6 +96,10 @@ braid_text.list().then(x => {
 require('chokidar').watch(config.proxy_base).
     on('change', (path) => {
         path = require('path').relative(config.proxy_base, path)
+
+        // Skip any temp files with a # in the name
+        if (path.includes('#')) return
+
         console.log(`path changed: ${path}`)
 
         path = normalize_url(path)
@@ -86,6 +109,10 @@ require('chokidar').watch(config.proxy_base).
     }).
     on('add', async (path) => {
         path = require('path').relative(config.proxy_base, path)
+
+        // Skip any temp files with a # in the name
+        if (path.includes('#')) return
+
         console.log(`path added: ${path}`)
 
         let url = null
@@ -217,6 +244,7 @@ async function proxy_url(url) {
         let peer = Math.random().toString(36).slice(2)
         var char_counter = -1
         let file_last_version = null
+        let file_last_digest = null
         let file_last_text = null
         self.file_read_only = null
         let file_needs_reading = true
@@ -255,13 +283,16 @@ async function proxy_url(url) {
 
             if (file_last_version === null) {
                 try {
-                    file_last_version = JSON.parse(await require('fs').promises.readFile(require('path').join(config.proxy_base_last_versions, braid_text.encode_filename(url)), { encoding: 'utf8' }))
+                    ({version: file_last_version, digest: file_last_digest} = JSON.parse(await require('fs').promises.readFile(require('path').join(config.proxy_base_meta, braid_text.encode_filename(url)), { encoding: 'utf8' })))
                     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_text = ''
                     file_needs_writing = true
                 }
+
+                // sanity check
+                if (file_last_version && require('crypto').createHash('sha256').update(file_last_text).digest('base64') != file_last_digest) throw new Error('file_last_text does not match file_last_digest')
             }
 
             while (file_needs_reading || file_needs_writing) {
@@ -288,7 +319,7 @@ async function proxy_url(url) {
 
                         await braid_text.put(url, { version, parents, patches, peer })
 
-                        await require('fs').promises.writeFile(require('path').join(config.proxy_base_last_versions, braid_text.encode_filename(url)), JSON.stringify(file_last_version))
+                        await require('fs').promises.writeFile(require('path').join(config.proxy_base_meta, braid_text.encode_filename(url)), JSON.stringify({version: file_last_version, digest: require('crypto').createHash('sha256').update(file_last_text).digest('base64')}))
                     }
                 }
                 if (file_needs_writing) {
@@ -303,7 +334,7 @@ async function proxy_url(url) {
                         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))
+                        await require('fs').promises.writeFile(require('path').join(config.proxy_base_meta, braid_text.encode_filename(url)), JSON.stringify({version: file_last_version, digest: require('crypto').createHash('sha256').update(file_last_text).digest('base64')}))
                     }
 
                     if (await is_read_only(await get_fullpath()) !== self.file_read_only) await set_read_only(await get_fullpath(), self.file_read_only)

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "braidfs",
-  "version": "0.0.26",
+  "version": "0.0.28",
   "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.30",
+    "braid-text": "^0.0.31",
     "chokidar": "^3.6.0"
   },
   "bin": {