wiki-server 0.26.0-rc.0 → 0.26.0-rc.10

package/index.js

@@ -2,7 +2,11 @@
 // Simple file so that if you require this directory
 // in node it instead requires ./lib/server.coffee
 // with coffee-script already loaded.
-require('coffeescript')
-require('coffeescript/register')
+// import('coffeescript')
+// import('coffeescript/register.js')
 
-module.exports = require('./lib/server')
+// const { default: server } = await import('./lib/server.js')
+// export default server
+
+import { default as server } from './lib/server.js'
+export default server

package/lib/defaultargs.js

@@ -9,13 +9,19 @@
 // **defaultargs.coffee** when called on the argv object this
 // module will create reasonable defaults for options not supplied,
 // based on what information is provided.
-const path = require('node:path')
+import path from 'node:path'
+import { randomBytes } from 'node:crypto'
+import { fileURLToPath } from 'node:url'
+import { dirname } from 'node:path'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
 
 const getUserHome = () => {
   return process.env.HOME || process.env.HOMEPATH || process.env.USERPROFILE
 }
 
-module.exports = argv => {
+export default argv => {
   argv = argv || {}
   argv.root ||= __dirname
   // the directory that contains all the packages that makeup the wiki
@@ -32,7 +38,7 @@ module.exports = argv => {
   argv.url ||= `http://localhost${argv.port === 80 ? '' : ':' + argv.port}`
   argv.id ||= path.join(argv.status, 'owner.json')
   argv.uploadLimit ||= '5mb'
-  argv.cookieSecret ||= require('crypto').randomBytes(64).toString('hex')
+  argv.cookieSecret ||= randomBytes(64).toString('hex')
   argv.secure_cookie ||= false
   argv.session_duration ||= 7
   argv.neighbors ||= ''
@@ -43,9 +49,9 @@ module.exports = argv => {
     argv.database = JSON.parse(argv.database)
   }
   argv.database ||= {}
-  argv.database.type ||= './page'
+  argv.database.type ||= './page.js'
   if (argv.database.type.charAt(0) === '.') {
-    if (argv.database.type != './page') {
+    if (argv.database.type != './page.js') {
       console.log('\n\nWARNING: This storage option is depeciated.')
       console.log('    See ReadMe for details of the changes required.\n\n')
     }
@@ -53,8 +59,8 @@ module.exports = argv => {
     argv.database.type = 'wiki-storage-' + argv.database.type
   }
 
-  argv.security_type ||= './security'
-  if (argv.security_type === './security') {
+  argv.security_type ||= './security.js'
+  if (argv.security_type === './security.js') {
     console.log('\n\nINFORMATION: Using default security module.')
   } else {
     argv.security_type = 'wiki-security-' + argv.security_type

package/lib/forward.js

@@ -1,4 +1,4 @@
-const init = (app, emitter) => {
+export const init = (app, emitter) => {
   let sockets = []
   app.io.on('connection', socket => {
     let listeners = []
@@ -35,4 +35,3 @@ const init = (app, emitter) => {
     })
   })
 }
-module.exports = { init }

package/lib/page.js

@@ -10,15 +10,53 @@
 // Everything is stored using json flat files.
 
 // #### Requires ####
-const fs = require('fs')
-const path = require('path')
-const events = require('events')
-const glob = require('glob')
+// const fs = require('fs')
+// const path = require('path')
+// const events = require('events')
+// const glob = require('glob')
+//
+// const async = require('async')
+//
+// // const random_id = require('./random_id.cjs')
+// const synopsis = require('wiki-client/lib/synopsis')
+
+import fs from 'node:fs'
+import path from 'node:path'
+import url from 'node:url'
+import events from 'node:events'
+
+import { createRequire } from 'node:module'
+const require = createRequire(import.meta.url)
+
+// Use dynamic import to load package.json from the main application's working directory
+const wikiPackageImport = async () => {
+  let done = false
+  return new Promise(resolve => {
+    import('wiki/package.json', { with: { type: 'json' } })
+      .then(imported => {
+        done = true
+        resolve(imported.default)
+      })
+      .catch(e => {
+        return e
+      })
+      .then(async () => {
+        if (done) return
+        const packageJsonPath = path.join(process.cwd(), 'package.json')
+        const packageJsonUrl = url.pathToFileURL(packageJsonPath).href
+        import(packageJsonUrl, { with: { type: 'json' } })
+          .then(imported => {
+            resolve(imported.default)
+          })
+          .catch(e => console.error('problems importing package', e))
+      })
+  })
+}
 
-const async = require('async')
+const packageJson = await wikiPackageImport()
 
-const random_id = require('./random_id')
-const synopsis = require('wiki-client/lib/synopsis')
+// import random_id from './random_id.cjs'; // Uncomment if needed
+import synopsis from 'wiki-client/lib/synopsis.js' // Add correct extension if necessary
 
 const asSlug = name =>
   name
@@ -28,13 +66,30 @@ const asSlug = name =>
 
 // Export a function that generates a page handler
 // when called with options object.
-module.exports = exports = argv => {
+export default argv => {
   const wikiName = new URL(argv.url).hostname
 
   fs.mkdir(argv.db, { recursive: true }, e => {
     if (e) throw e
   })
 
+  // create a list of plugin pages.
+  const pluginPages = new Map()
+
+  Object.keys(packageJson.dependencies)
+    .filter(depend => depend.startsWith('wiki-plugin'))
+    .forEach(plugin => {
+      const pagesPath = path.join(path.dirname(require.resolve(`${plugin}/package`)), 'pages')
+      fs.readdir(pagesPath, { withFileTypes: true }, (err, entries) => {
+        if (err) return
+        entries.forEach(entry => {
+          if (entry.isFile() && !pluginPages.has(entry.name)) {
+            pluginPages.set(entry.name, { pluginName: plugin, pluginPath: entry.parentPath })
+          }
+        })
+      })
+    })
+
   // #### Private utility methods. ####
   const load_parse = (loc, cb, annotations = {}) => {
     let page
@@ -46,14 +101,13 @@ module.exports = exports = argv => {
         const errorPage = path.basename(loc)
         const errorPagePath = path.dirname(loc)
         const recyclePage = path.resolve(errorPagePath, '..', 'recycle', errorPage)
-        // TODO: fs.exists depreciated
-        fs.exists(path.dirname(recyclePage), exists => {
-          if (exists) {
+        fs.access(path.dirname(recyclePage), fs.constants.F_OK, err => {
+          if (!err) {
             fs.rename(loc, recyclePage, err => {
               if (err) {
-                console.log('ERROR: moving problem page #{loc} to recycler', err)
+                console.log(`ERROR: moving problem page ${loc} to recycler`, err)
               } else {
-                console.log('ERROR: problem page #{loc} moved to recycler')
+                console.log(`ERROR: problem page ${loc} moved to recycler`)
               }
             })
           } else {
@@ -63,9 +117,9 @@ module.exports = exports = argv => {
               } else {
                 fs.rename(loc, recyclePage, err => {
                   if (err) {
-                    console.log('ERROR: moving problem page #{loc} to recycler', err)
+                    console.log(`ERROR: moving problem page ${loc} to recycler`, err)
                   } else {
-                    console.log('ERROR: problem page #{loc} moved to recycler')
+                    console.log(`ERROR: problem page ${loc} moved to recycler`)
                   }
                 })
               }
@@ -104,9 +158,8 @@ module.exports = exports = argv => {
   const tryDefaults = (file, cb) => {
     const lastDefault = cb => {
       const defloc = path.join(argv.root, 'default-data', 'pages', file)
-      // TODO: fs.exists depreciated
-      fs.exists(defloc, exists => {
-        if (exists) {
+      fs.access(defloc, fs.constants.F_OK, err => {
+        if (!err) {
           cb(defloc)
         } else {
           cb(null)
@@ -115,10 +168,8 @@ module.exports = exports = argv => {
     }
     if (argv.defaults) {
       const defloc = path.join(argv.data, '..', argv.defaults, 'pages', file)
-      console.log('firstDefault', defloc)
-      // TODO: fs.exists depreciated
-      fs.exists(defloc, exists => {
-        if (exists) {
+      fs.access(defloc, fs.constants.F_OK, err => {
+        if (!err) {
           cb(defloc)
         } else {
           lastDefault(cb)
@@ -138,22 +189,19 @@ module.exports = exports = argv => {
       case 'delete':
         if (file.startsWith('recycler/')) {
           // delete from recycler
-          // TODO: fs.exists depreciated
-          fs.exists(loc, exists => {
-            if (exists)
+          fs.access(loc, fs.constants.F_OK, err => {
+            if (!err)
               fs.unlink(loc, err => {
                 cb(err)
               })
           })
         } else {
           // move page to recycler
-          // TODO: fs.exists depreciated
-          fs.exists(loc, exists => {
-            if (exists) {
+          fs.access(loc, fs.constants.F_OK, err => {
+            if (!err) {
               const recycleLoc = path.join(argv.recycler, file)
-              // TODO: fs.exists depreciated
-              fs.exists(path.dirname(recycleLoc), exists => {
-                if (exists) {
+              fs.access(path.dirname(recycleLoc), fs.constants.F_OK, err => {
+                if (!err) {
                   fs.rename(loc, recycleLoc, err => {
                     cb(err)
                   })
@@ -203,13 +251,11 @@ module.exports = exports = argv => {
           return
         }
 
-        // TODO: fs.exists depreciated
-        fs.exists(loc, exists => {
-          if (exists) {
+        fs.access(loc, fs.constants.F_OK, err => {
+          if (!err) {
             const recycleLoc = path.join(argv.recycler, file)
-            // TODO: fs.exists depreciated
-            fs.exists(path.dirname(recycleLoc), exists => {
-              if (exists) {
+            fs.access(path.dirname(recycleLoc), fs.constants.F_OK, err => {
+              if (!err) {
                 copyFile(loc, recycleLoc, err => {
                   cb(err)
                 })
@@ -229,42 +275,20 @@ module.exports = exports = argv => {
         break
       }
       case 'get':
-        // TODO: fs.exists depreciated
-        fs.exists(loc, exists => {
-          if (exists) {
+        fs.access(loc, fs.constants.F_OK, err => {
+          if (!err) {
             load_parse(loc, cb, { plugin: undefined })
           } else {
             tryDefaults(file, defloc => {
               if (defloc) {
                 load_parse(defloc, cb)
               } else {
-                glob('wiki-plugin-*/pages', { cwd: argv.packageDir }, (e, plugins) => {
-                  if (e) return cb(e)
-
-                  // if no plugins found
-                  if (plugins.length === 0) {
-                    cb(null, 'Page not found', 404)
-                  }
-
-                  let count = plugins.length
-                  const giveUp = () => {
-                    count -= 1
-                    if (count === 0) {
-                      cb(null, 'Page not found', 404)
-                    }
-                  }
-                  plugins.forEach(plugin => {
-                    const pluginName = plugin.slice(12, -6)
-                    const pluginloc = path.join(argv.packageDir, plugin, file)
-                    fs.exists(pluginloc, exists => {
-                      if (exists) {
-                        load_parse(pluginloc, cb, { plugin: pluginName })
-                      } else {
-                        giveUp()
-                      }
-                    })
-                  })
-                })
+                if (pluginPages.has(file)) {
+                  const { pluginName, pluginPath } = pluginPages.get(file)
+                  load_parse(path.join(pluginPath, file), cb, { plugin: pluginName.slice(12) })
+                } else {
+                  cb(null, 'Page not found', 404)
+                }
               }
             })
           }
@@ -272,11 +296,11 @@ module.exports = exports = argv => {
         break
       case 'put':
         page = JSON.stringify(page, null, 2)
-        fs.exists(path.dirname(loc), exists => {
-          if (exists) {
+        fs.access(path.dirname(loc), fs.constants.F_OK, err => {
+          if (!err) {
             fs.writeFile(loc, page, err => {
               if (err) {
-                console.log('ERROR: write file #{loc} ', err)
+                console.log(`ERROR: write file ${loc} `, err)
               }
               cb(err)
             })
@@ -285,7 +309,7 @@ module.exports = exports = argv => {
               if (err) cb(err)
               fs.writeFile(loc, page, err => {
                 if (err) {
-                  console.log('ERROR: write file #{loc} ', err)
+                  console.log(`ERROR: write file ${loc} `, err)
                 }
                 cb(err)
               })
@@ -294,7 +318,7 @@ module.exports = exports = argv => {
         })
         break
       default:
-        console.log('pagehandler: unrecognized action #{action}')
+        console.log(`pagehandler: unrecognized action ${action}`)
     }
   }
 
@@ -392,43 +416,46 @@ module.exports = exports = argv => {
       }
       return collaborativeLinks
     }
+
     fs.readdir(argv.db, (e, files) => {
       if (e) return cb(e)
-      // used to make sure all of the files are read
-      // and processesed in the site map before responding
-      const doSitemap = (file, cb) => {
-        itself.get(file, (e, page, status) => {
-          if (file.match(/^\./)) return cb()
-          if (e || status === 404) {
-            console.log('Problem building sitemap:', file, 'e: ', e, 'status:', status)
-            return cb() // Ignore errors in the pagehandler get.
-          }
-          let pageLinksMap
-          try {
-            pageLinksMap = page.story.reduce(extractPageLinks, new Map())
-          } catch (err) {
-            console.log('METADATA *** #{wikiName} reduce to extract links on #{file} failed', err.message)
-            pageLinksMap = []
-          }
-          //
-          const pageLinks = pageLinksMap.size > 0 ? Object.fromEntries(pageLinksMap) : undefined
-
-          cb(null, {
-            slug: file,
-            title: page.title,
-            date: editDate(page.journal),
-            synopsis: synopsis(page),
-            links: pageLinks,
+      const doSitemap = async file => {
+        return new Promise(resolve => {
+          itself.get(file, (e, page, status) => {
+            if (file.match(/^\./)) return resolve(null)
+            if (e || status === 404) {
+              console.log('Problem building sitemap:', file, 'e: ', e, 'status:', status)
+              return resolve(null) // Ignore errors in the pagehandler get.
+            }
+            let pageLinksMap
+            try {
+              pageLinksMap = page.story.reduce(extractPageLinks, new Map())
+            } catch (err) {
+              console.log(`METADATA *** ${wikiName} reduce to extract links on ${file} failed`, err.message)
+              pageLinksMap = []
+            }
+            //
+            const pageLinks = pageLinksMap.size > 0 ? Object.fromEntries(pageLinksMap) : undefined
+
+            resolve({
+              slug: file,
+              title: page.title,
+              date: editDate(page.journal),
+              synopsis: synopsis(page),
+              links: pageLinks,
+            })
           })
         })
       }
-      async.map(files, doSitemap, (e, sitemap) => {
-        if (e) return cb(e)
-        cb(
-          null,
-          sitemap.filter(item => item != null),
-        )
-      })
+
+      Promise.all(files.map(doSitemap))
+        .then(sitemap => {
+          cb(
+            null,
+            sitemap.filter(item => item != null),
+          )
+        })
+        .catch(e => cb(e))
     })
   }
 

package/lib/plugins.js

@@ -8,12 +8,11 @@
 
 // support server-side plugins
 
-const fs = require('node:fs')
-const glob = require('glob')
-const { pathToFileURL } = require('node:url')
-// forward = require './forward'
+import fs from 'node:fs'
+import { pathToFileURL } from 'node:url'
+// import forward from './forward.cjs'; // Uncomment if needed and adjust import style if it's not a default export
 
-module.exports = exports = argv => {
+export default argv => {
   // NOTE: plugins are now in their own package directories alongside this one...
   // Plugins are in directories of the form wiki-package-*
   // those with a server component will have a server directory
@@ -24,8 +23,8 @@ module.exports = exports = argv => {
 
   const startServer = (params, plugin) => {
     const server = `${argv.packageDir}/${plugin}/server/server.js`
-    fs.exists(server, exists => {
-      if (exists) {
+    fs.access(server, fs.constants.F_OK, err => {
+      if (!err) {
         console.log('starting plugin', plugin)
         import(pathToFileURL(server))
           .then(exported => {
@@ -40,14 +39,12 @@ module.exports = exports = argv => {
   }
 
   const startServers = params => {
-    // emitter = new events.EventEmitter()
-    // forward.init params.app, emitter
-    // params.emitter = emitter
-    glob('wiki-plugin-*', { cwd: argv.packageDir }, (e, plugins) => {
-      plugins.forEach(plugin => {
+    const dependencies = params.packageJson.dependencies
+    Object.keys(dependencies)
+      .filter(depend => depend.startsWith('wiki-plugin'))
+      .forEach(plugin => {
         startServer(params, plugin)
       })
-    })
   }
 
   return { startServers }

package/lib/random_id.js

@@ -10,6 +10,4 @@
 // Simple random hex generator, takes an optional number of
 // chars that defaults to 16 and returns a random id.
 
-const random_id = (chars = 16) => [...Array(chars)].map(() => Math.floor(Math.random() * 16).toString(16)).join('')
-
-module.exports = random_id.random_id = random_id
+export default (chars = 16) => [...Array(chars)].map(() => Math.floor(Math.random() * 16).toString(16)).join('')

package/lib/search.js

@@ -8,15 +8,15 @@
 
 // **search.js**
 
-const fs = require('node:fs')
-const path = require('node:path')
-const events = require('node:events')
-const url = require('node:url')
-const writeFileAtomic = require('write-file-atomic')
+import fs from 'node:fs'
+import path from 'node:path'
+import events from 'node:events'
+import url from 'node:url'
+import writeFileAtomic from 'write-file-atomic'
 
-const miniSearch = require('minisearch')
+import miniSearch from 'minisearch'
 
-module.exports = exports = argv => {
+export default argv => {
   const wikiName = new URL(argv.url).hostname
   let siteIndex = []
   const queue = []
@@ -85,8 +85,8 @@ module.exports = exports = argv => {
 
   const searchSave = (siteIndex, cb) => {
     // save index to file
-    fs.exists(argv.status, exists => {
-      if (exists) {
+    fs.access(argv.status, fs.constants.F_OK, err => {
+      if (!err) {
         writeFileAtomic(siteIndexLoc, JSON.stringify(siteIndex), e => {
           if (e) return cb(e)
           touch(indexUpdateFlag, () => {
@@ -108,8 +108,8 @@ module.exports = exports = argv => {
 
   const searchRestore = cb => {
     // restore index, or create if it doesn't already exist
-    fs.exists(siteIndexLoc, exists => {
-      if (exists) {
+    fs.access(siteIndexLoc, fs.constants.F_OK, err => {
+      if (!err) {
         fs.readFile(siteIndexLoc, (err, data) => {
           if (err) return cb(err)
           try {
@@ -169,8 +169,12 @@ module.exports = exports = argv => {
       .replace(/<(?:"[^"]*"['"]*|'[^']*'['"]*|[^'">])+>/g, ' ')
       .replace(/<(?:[^>])+>/g, ' ')
       .replace(/(https?:.*?)(?=\p{White_Space}|\p{Quotation_Mark}|$)/gu, match => {
-        const myUrl = url.parse(match)
-        return myUrl.hostname + ' ' + myUrl.pathname
+        try {
+          const myUrl = new URL(match)
+          return myUrl.hostname
+        } catch {
+          return ' '
+        }
       })
       .replace(/[\p{P}\p{Emoji}\p{Symbol}}]+/gu, ' ')
       .replace(/[\p{White_Space}\n\t]+/gu, ' ')
@@ -250,7 +254,7 @@ module.exports = exports = argv => {
     // we save the pagehandler, so we can recreate the site index if it is removed
     searchPageHandler = searchPageHandler ?? pagehandler
 
-    //timeLabel = "SITE INDEX #{wikiName} : Created"
+    //timeLabel = `SITE INDEX ${wikiName} : Created`
     //console.time timeLabel
 
     pagehandler.slugs((e, slugs) => {

package/lib/security.js

@@ -13,11 +13,11 @@
 // allow the server to run read-only.
 
 // #### Requires ####
-const fs = require('node:fs')
+import fs from 'node:fs'
 
 // Export a function that generates security handler
 // when called with options object.
-module.exports = exports = (log, loga, argv) => {
+export default (log, loga, argv) => {
   const security = {}
 
   // #### Private utility methods. ####
@@ -41,8 +41,8 @@ module.exports = exports = (log, loga, argv) => {
 
   // Retrieve owner infomation from identity file in status directory
   security.retrieveOwner = cb => {
-    fs.exists(idFile, exists => {
-      if (exists) {
+    fs.access(idFile, fs.constants.F_OK, err => {
+      if (!err) {
         fs.readFile(idFile, (err, data) => {
           if (err) return cb(err)
           owner += data
@@ -84,7 +84,16 @@ module.exports = exports = (log, loga, argv) => {
   }
   // Wiki server admin
   security.isAdmin = () => {
-    return false
+    // nobody is admin - unless legacy support, and test
+    if (argv.security_legacy) {
+      if (argv.test) {
+        return true
+      } else {
+        return false
+      }
+    } else {
+      return false
+    }
   }
   security.defineRoutes = (app, cors, updateOwner) => {
     // default security does not have any routes

package/lib/server.js

@@ -19,44 +19,72 @@
 //     npm install
 
 // Standard lib
-const fs = require('fs')
-const path = require('path')
-const http = require('http')
-const url = require('url')
-const { pipeline } = require('node:stream/promises')
+import fs from 'fs'
+import path from 'path'
+import url from 'url'
+import { pipeline } from 'node:stream/promises'
 
 // From npm
-const express = require('express')
-const hbs = require('express-hbs')
-const glob = require('glob')
-const async = require('async')
-const f = require('flates')
+import express from 'express'
+import hbs from 'express-hbs'
+import f from 'flates'
 
-const createDOMPurify = require('dompurify')
-const { JSDOM } = require('jsdom')
+import createDOMPurify from 'dompurify'
+import { JSDOM } from 'jsdom'
 
 const window = new JSDOM('').window
 const DOMPurify = createDOMPurify(window)
 
-// node-fetch is now ESM only
-const fetch = (...args) => import('node-fetch').then(({ default: fetch }) => fetch(...args))
+// Using native fetch API (available in Node.js 18+)
 
 // Express 4 middleware
-const logger = require('morgan')
-const cookieParser = require('cookie-parser')
-const methodOverride = require('method-override')
-// session = require 'express-session'
-const sessions = require('client-sessions')
-const bodyParser = require('body-parser')
-const errorHandler = require('errorhandler')
+import logger from 'morgan'
+import cookieParser from 'cookie-parser'
+import methodOverride from 'method-override'
+// session = require('express-session') // This one was commented out — uncomment if used
+import sessions from 'client-sessions'
+import bodyParser from 'body-parser'
+import errorHandler from 'errorhandler'
 
 // Local files
-const random = require('./random_id')
-const defargs = require('./defaultargs')
-const resolveClient = require('wiki-client/lib/resolve')
-const pluginsFactory = require('./plugins')
-const sitemapFactory = require('./sitemap')
-const searchFactory = require('./search')
+// Make sure these files are ESM modules or compatible
+// If they are CommonJS, you will need to dynamically import them (see below)
+import defargs from './defaultargs.js'
+import resolveClient from 'wiki-client/lib/resolve.js'
+import pluginsFactory from './plugins.js'
+import sitemapFactory from './sitemap.js'
+import searchFactory from './search.js'
+import { warn } from 'node:console'
+import { createRequire } from 'module'
+const require = createRequire(import.meta.url)
+
+// Use import to load package.json from the main application's working directory
+//const { default: packageJson } = await import('wiki/package.json', { with: { type: 'json' } })
+const wikiPackageImport = async () => {
+  let done = false
+  return new Promise(resolve => {
+    import('wiki/package.json', { with: { type: 'json' } })
+      .then(imported => {
+        done = true
+        resolve(imported.default)
+      })
+      .catch(e => {
+        return e
+      })
+      .then(async () => {
+        if (done) return
+        const packageJsonPath = path.join(process.cwd(), 'package.json')
+        const packageJsonUrl = url.pathToFileURL(packageJsonPath).href
+        import(packageJsonUrl, { with: { type: 'json' } })
+          .then(imported => {
+            resolve(imported.default)
+          })
+          .catch(e => console.error('problems importing package', e))
+      })
+  })
+}
+
+const packageJson = await wikiPackageImport()
 
 const render = page => {
   return (
@@ -93,7 +121,7 @@ const render = page => {
   )
 }
 // Set export objects for node and coffee to a function that generates a sfw server.
-module.exports = exports = argv => {
+export default async argv => {
   // Create the main application object, app.
   const app = express()
 
@@ -107,6 +135,8 @@ module.exports = exports = argv => {
 
   app.startOpts = argv
 
+  const wikiName = new URL(argv.url).hostname
+
   const log = (...stuff) => {
     if (argv.debug) console.log(stuff)
   }
@@ -128,18 +158,23 @@ module.exports = exports = argv => {
     }
     next()
   }
+
   let pagehandler, sitemaphandler, searchhandler, securityhandler
-  // Require the database adapter and initialize it with options.
-  app.pagehandler = pagehandler = require(argv.database.type)(argv)
 
-  // Require the sitemap adapter and initialize it with options.
+  // Dynamically import database adapter (since the module name is dynamic)
+  const dbModule = await import(argv.database.type)
+  app.pagehandler = pagehandler = dbModule.default(argv)
+
+  // Initialize sitemap handler
   app.sitemaphandler = sitemaphandler = sitemapFactory(argv)
 
-  // Require the site indexer and initialize it with options
+  // Initialize search handler
   app.searchhandler = searchhandler = searchFactory(argv)
 
-  // Require the security adapter and initialize it with options.
-  app.securityhandler = securityhandler = require(argv.security_type)(log, loga, argv)
+  // Dynamically import security adapter (also dynamic)
+  console.log('security_type', argv.security_type)
+  const securityModule = await import(argv.security_type)
+  app.securityhandler = securityhandler = securityModule.default(log, loga, argv)
 
   // If the site is owned, owner will contain the name of the owner
   let owner = ''
@@ -163,7 +198,7 @@ module.exports = exports = argv => {
 
   const remoteGet = (remote, slug, cb) => {
     // assume http, as we know no better at this point and we need to specify a protocol.
-    const remoteURL = new URL('http://#{remote}/#{slug}.json').toString()
+    const remoteURL = new URL(`http://${remote}/${slug}.json`).toString()
     // set a two second timeout
     fetch(remoteURL, { signal: AbortSignal.timeout(2000) })
       .then(res => {
@@ -222,7 +257,7 @@ module.exports = exports = argv => {
   // use logger, at least in development, probably needs a param to configure (or turn off).
   // use stream to direct to somewhere other than stdout.
   logger.token('vhost', (req, res) => {
-    return colorString(req.hostname)
+    return colorString(wikiName)
   })
   app.use(logger(':vhost :method :url :status :res[content-length] - :response-time ms'))
   app.use(cookieParser())
@@ -271,13 +306,13 @@ module.exports = exports = argv => {
   app.use('/assets', cors, express.static(argv.assets))
 
   // Add static routes to the plugins client.
-  glob('wiki-plugin-*/client', { cwd: argv.packageDir }, (e, plugins) => {
-    plugins.map(plugin => {
-      const pluginName = plugin.slice(12, -7)
-      const pluginPath = '/plugins/' + pluginName
-      app.use(pluginPath, cors, express.static(path.join(argv.packageDir, plugin), staticPathOptions))
+  Object.keys(packageJson.dependencies)
+    .filter(depend => depend.startsWith('wiki-plugin'))
+    .forEach(plugin => {
+      const clientPath = path.join(path.dirname(require.resolve(`${plugin}/package`)), 'client')
+      const pluginPath = '/plugins/' + plugin.slice(12)
+      app.use(pluginPath, cors, express.static(clientPath, staticPathOptions))
     })
-  })
 
   // Add static routes to the security client.
   if (argv.security != './security') {
@@ -387,32 +422,28 @@ module.exports = exports = argv => {
   app.get('/system/factories.json', (req, res) => {
     res.status(200)
     res.header('Content-Type', 'application/json')
-    // Plugins are located in packages in argv.packageDir, with package names of the form wiki-plugin-*
-    glob(path.join(argv.packageDir, 'wiki-plugin-*', 'factory.json'), (e, files) => {
-      if (e) {
-        return res.e(e)
-      }
 
-      const doFactories = (file, cb) => {
-        fs.readFile(file, (err, data) => {
-          if (err) {
-            return cb()
-          }
-          try {
-            const factory = JSON.parse(data)
-            cb(null, factory)
-          } catch (err) {
-            return cb()
-          }
-        })
-      }
-      async.map(files, doFactories, (e, factories) => {
-        if (e) {
-          res.e(e)
-        }
-        res.end(JSON.stringify(factories))
+    const factories = []
+
+    const getPackageFactory = plugin => {
+      return new Promise(resolve => {
+        import(`${plugin}/factory.json`, { with: { type: 'json' } })
+          .then(({ default: factory }) => {
+            resolve(factories.push(factory))
+          })
+          .catch(() => {
+            resolve()
+          })
       })
-    })
+    }
+
+    Promise.all(
+      Object.keys(packageJson.dependencies)
+        .filter(depend => depend.startsWith('wiki-plugin'))
+        .map(plugin => {
+          return getPackageFactory(plugin)
+        }),
+    ).then(() => res.end(JSON.stringify(factories)))
   })
 
   // ###### Json Routes ######
@@ -444,7 +475,7 @@ module.exports = exports = argv => {
   // If themes doesn't exist send 404 and let the client
   // deal with it.
   app.get(/^\/theme\/(\w+\.\w+)$/, cors, (req, res) => {
-    res.sendFile(path.join(argv.status, 'theme', req.params[0]), e => {
+    res.sendFile(path.join(argv.status, 'theme', req.params[0]), { dotfiles: 'allow' }, e => {
       if (e) {
         // swallow the error if the theme does not exist...
         if (req.path === '/theme/style.css') {
@@ -462,9 +493,9 @@ module.exports = exports = argv => {
   const favLoc = path.join(argv.status, 'favicon.png')
   const defaultFavLoc = path.join(argv.root, 'default-data', 'status', 'favicon.png')
   app.get('/favicon.png', cors, (req, res) => {
-    fs.exists(favLoc, exists => {
-      if (exists) {
-        res.sendFile(favLoc)
+    fs.access(favLoc, fs.constants.F_OK, err => {
+      if (!err) {
+        res.sendFile(favLoc, { dotfiles: 'allow' })
       } else {
         res.sendFile(defaultFavLoc)
       }
@@ -484,9 +515,9 @@ module.exports = exports = argv => {
   // save it.
   app.post('/favicon.png', authorized, (req, res) => {
     const favicon = req.body.image.replace(/^data:image\/png;base64,/, '')
-    const buf = new Buffer(favicon, 'base64')
-    fs.exists(argv.status, exists => {
-      if (exists) {
+    const buf = Buffer.from(favicon, 'base64')
+    fs.access(argv.status, fs.constants.F_OK, err => {
+      if (!err) {
         fs.writeFile(favLoc, buf, e => {
           if (e) {
             return res.e(e)
@@ -508,7 +539,7 @@ module.exports = exports = argv => {
 
   // Redirect remote favicons to the server they are needed from.
   app.get(/^\/remote\/([a-zA-Z0-9:.-]+\/favicon.png)$/, (req, res) => {
-    const remotefav = 'http://#{req.params[0]}'
+    const remotefav = `http://${req.params[0]}`
     res.redirect(remotefav)
   })
 
@@ -519,38 +550,40 @@ module.exports = exports = argv => {
   // negative space outward pointing arrows nicely indicates that items can be removed
   const recyclerFavLoc = path.join(argv.root, 'default-data', 'status', 'recycler.png')
   app.get('/recycler/favicon.png', authorized, (req, res) => {
-    res.sendFile(recyclerFavLoc)
+    res.sendFile(recyclerFavLoc, { dotfiles: 'allow' })
   })
 
   // Send an array of pages currently in the recycler via json
   app.get('/recycler/system/slugs.json', authorized, (req, res) => {
     fs.readdir(argv.recycler, (e, files) => {
-      const doRecyclermap = (file, cb) => {
-        const recycleFile = 'recycler/' + file
-        pagehandler.get(recycleFile, (e, page, status) => {
-          if (e || status === 404) {
-            console.log('Problem building recycler map:', file, 'e: ', e)
-            // this will leave an undefined/empty item in the array, which we will filter out later
-            return cb()
-          }
-          cb(null, {
-            slug: file,
-            title: page.title,
+      if (e) {
+        return res.e(e)
+      }
+      const doRecyclermap = async file => {
+        return new Promise(resolve => {
+          const recycleFile = 'recycler/' + file
+          pagehandler.get(recycleFile, (e, page, status) => {
+            if (e || status === 404) {
+              console.log('Problem building recycler map:', file, 'e: ', e)
+              // this will leave an undefined/empty item in the array, which we will filter out later
+              return resolve(null)
+            }
+            resolve({
+              slug: file,
+              title: page.title,
+            })
           })
         })
       }
 
-      if (e) {
-        return res.e(e)
-      }
-      async.map(files, doRecyclermap, (e, recyclermap) => {
-        if (e) {
-          return res.e(e)
-        }
-        // remove any empty items
-        recyclermap = recyclermap.filter(el => !!el)
-        res.send(recyclermap)
-      })
+      Promise.all(files.map(doRecyclermap))
+        .then(recyclermap => {
+          recyclermap = recyclermap.filter(el => !!el)
+          res.send(recyclermap)
+        })
+        .catch(error => {
+          res.e(error)
+        })
     })
   })
 
@@ -590,21 +623,21 @@ module.exports = exports = argv => {
 
   // Returns a list of installed plugins. (does this get called anymore!)
   app.get('/system/plugins.json', cors, (req, res) => {
-    glob('wiki-plugin-*', { cwd: argv.packageDir }, (e, files) => {
-      if (e) {
-        return res.e(e)
-      }
-      // extract the plugin name from the name of the directory it's installed in
-      files = files.map(file => file.slice(12))
-      res.send(files)
-    })
+    try {
+      const pluginNames = Object.keys(require.main.require('./package').dependencies)
+        .filter(depend => depend.startsWith('wiki-plugin'))
+        .map(name => name.slice(12))
+      res.send(pluginNames)
+    } catch (e) {
+      return res.e(e)
+    }
   })
   //{
   const sitemapLoc = path.join(argv.status, 'sitemap.json')
   app.get('/system/sitemap.json', cors, (req, res) => {
-    fs.exists(sitemapLoc, exists => {
-      if (exists) {
-        res.sendFile(sitemapLoc)
+    fs.access(sitemapLoc, fs.constants.F_OK, err => {
+      if (!err) {
+        res.sendFile(sitemapLoc, { dotfiles: 'allow' })
       } else {
         // only createSitemap if we are not already creating one
         if (!sitemaphandler.isWorking()) {
@@ -612,7 +645,7 @@ module.exports = exports = argv => {
         }
         // wait for the sitemap file to be written, before sending
         sitemaphandler.once('finished', () => {
-          res.sendFile(sitemapLoc)
+          res.sendFile(sitemapLoc, { dotfiles: 'allow' })
         })
       }
     })
@@ -620,15 +653,15 @@ module.exports = exports = argv => {
 
   const xmlSitemapLoc = path.join(argv.status, 'sitemap.xml')
   app.get('/sitemap.xml', cors, (req, res) => {
-    fs.exists(sitemapLoc, exists => {
-      if (exists) {
-        res.sendFile(xmlSitemapLoc)
+    fs.access(sitemapLoc, fs.constants.F_OK, err => {
+      if (!err) {
+        res.sendFile(xmlSitemapLoc, { dotfiles: 'allow' })
       } else {
         if (!sitemaphandler.isWorking()) {
           sitemaphandler.createSitemap(pagehandler)
         }
         sitemaphandler.once('finished', () => {
-          res.sendFile(xmlSitemapLoc)
+          res.sendFile(xmlSitemapLoc, { dotfiles: 'allow' })
         })
       }
     })
@@ -636,16 +669,16 @@ module.exports = exports = argv => {
 
   const searchIndexLoc = path.join(argv.status, 'site-index.json')
   app.get('/system/site-index.json', cors, (req, res) => {
-    fs.exists(searchIndexLoc, exists => {
-      if (exists) {
-        res.sendFile(searchIndexLoc)
+    fs.access(searchIndexLoc, fs.constants.F_OK, err => {
+      if (!err) {
+        res.sendFile(searchIndexLoc, { dotfiles: 'allow' })
       } else {
         // only create index if we are not already creating one
         if (!searchhandler.isWorking()) {
           searchhandler.createIndex(pagehandler)
         }
         searchhandler.once('indexed', () => {
-          res.sendFile(searchIndexLoc)
+          res.sendFile(searchIndexLoc, { dotfiles: 'allow' })
         })
       }
     })
@@ -656,28 +689,29 @@ module.exports = exports = argv => {
       if (e) {
         return res.e(e)
       }
-      async.map(
-        sitemap,
-        (stub, done) => {
+      const pagePromises = sitemap.map(stub => {
+        return new Promise((resolve, reject) => {
           pagehandler.get(stub.slug, (error, page) => {
-            if (e) {
-              return done(e)
+            if (error) {
+              return reject(error)
             }
-            done(null, { slug: stub.slug, page })
+            resolve({ slug: stub.slug, page })
           })
-        },
-        (e, pages) => {
-          if (e) {
-            return res.e(e)
-          }
-          res.json(
-            pages.reduce((dict, combined) => {
-              dict[combined.slug] = combined.page
-              return dict
-            }, {}),
-          )
-        },
-      )
+        })
+      })
+
+      Promise.all(pagePromises)
+        .then(pages => {
+          const pageExport = pages.reduce((dict, combined) => {
+            dict[combined.slug] = combined.page
+            return dict
+          }, {})
+          // TODO: this fails for a very large site
+          res.json(pageExport)
+        })
+        .catch(error => {
+          res.e(error)
+        })
     })
   })
 
@@ -691,33 +725,59 @@ module.exports = exports = argv => {
   }
 
   app.get('/system/version.json', admin, (req, res) => {
-    const versions = {}
-    const wikiModule = module.parent.parent.parent
-    versions[wikiModule.require('./package').name] = wikiModule.require('./package').version
-    versions[wikiModule.require('wiki-server/package').name] = wikiModule.require('wiki-server/package').version
-    versions[wikiModule.require('wiki-client/package').name] = wikiModule.require('wiki-client/package').version
-    versions['security'] = {}
-    versions['plugins'] = {}
-
-    glob('+(wiki-security-*|wiki-plugin-*)', { cwd: argv.packageDir }, (e, plugins) => {
-      plugins.map(plugin => {
-        if (plugin.includes('wiki-security')) {
-          versions.security[wikiModule.require(plugin + '/package').name] = wikiModule.require(
-            plugin + '/package',
-          ).version
-        } else {
-          versions.plugins[wikiModule.require(plugin + '/package').name] = wikiModule.require(
-            plugin + '/package',
-          ).version
+    const getPackageVersion = packageName => {
+      return new Promise(resolve => {
+        try {
+          // Use import to load package.json from the main application's working directory
+          import(`${packageName}/package.json`, { with: { type: 'json' } }).then(({ default: packageJson }) => {
+            resolve({ [packageName]: packageJson.version })
+          })
+        } catch (error) {
+          console.error(`Error reading package for ${packageName}:`, error)
+          resolve({ [packageName]: 'unknown' })
         }
-        res.json(versions)
       })
+    }
+
+    const versions = {}
+
+    const security = () => {
+      return new Promise(resolve => {
+        Promise.all(
+          Object.keys(packageJson.dependencies)
+            .filter(depend => depend.startsWith('wiki-security'))
+            .map(key => {
+              return getPackageVersion(key)
+            }),
+        ).then(values => {
+          resolve({ security: values.reduce((acc, cV) => Object.assign(acc, cV), {}) })
+        })
+      })
+    }
+
+    const plugins = () => {
+      return new Promise(resolve => {
+        Promise.all(
+          Object.keys(packageJson.dependencies)
+            .filter(depend => depend.startsWith('wiki-plugin'))
+            .map(key => {
+              return getPackageVersion(key)
+            }),
+        ).then(values => {
+          resolve({ plugins: values.reduce((acc, cV) => Object.assign(acc, cV), {}) })
+        })
+      })
+    }
+
+    Promise.all([getPackageVersion('wiki-server'), getPackageVersion('wiki-client'), security(), plugins()]).then(v => {
+      Object.assign(versions, { [packageJson.name]: packageJson.version }, ...v)
+      res.json(versions)
     })
   })
 
   // ##### Proxy routes #####
 
-  app.get('/proxy/*', authorized, (req, res) => {
+  app.get('/proxy/*splat', authorized, (req, res) => {
     const pathParts = req.originalUrl.split('/')
     const remoteHost = pathParts[2]
     pathParts.splice(0, 3)
@@ -731,7 +791,7 @@ module.exports = exports = argv => {
       requestURL.endsWith('.jpg') ||
       pathParts[0] === 'plugin'
     ) {
-      fetch(requestURL, { timeout: 2000 })
+      fetch(requestURL, { signal: AbortSignal.timeout(2000) })
         .then(async fetchRes => {
           if (fetchRes.ok) {
             res.set('content-type', fetchRes.headers.get('content-type'))
@@ -929,7 +989,7 @@ module.exports = exports = argv => {
     // ### Plugins ###
     // Should replace most WebSocketServers below.
     const plugins = pluginsFactory(argv)
-    plugins.startServers({ argv, app })
+    plugins.startServers({ argv, app, packageJson })
     // ### Sitemap ###
     // create sitemap at start-up
     sitemaphandler.createSitemap(pagehandler)

package/lib/sitemap.js

@@ -7,14 +7,13 @@
  */
 
 // **sitemap.coffee**
+import fs from 'node:fs'
+import path from 'node:path'
+import events from 'node:events'
+import writeFileAtomic from 'write-file-atomic'
+import xml2js from 'xml2js'
 
-const fs = require('fs')
-const path = require('path')
-const events = require('events')
-const writeFileAtomic = require('write-file-atomic')
-const xml2js = require('xml2js')
-
-const synopsis = require('wiki-client/lib/synopsis')
+import synopsis from 'wiki-client/lib/synopsis.js' // Add .js if needed
 
 const asSlug = name =>
   name
@@ -22,7 +21,7 @@ const asSlug = name =>
     .replace(/[^A-Za-z0-9-]/g, '')
     .toLowerCase()
 
-module.exports = exports = argv => {
+export default argv => {
   const wikiName = new URL(argv.url).hostname
 
   let sitemap = []
@@ -119,8 +118,8 @@ module.exports = exports = argv => {
   }
 
   const sitemapSave = (sitemap, cb) => {
-    fs.exists(argv.status, exists => {
-      if (exists) {
+    fs.access(argv.status, fs.constants.F_OK, err => {
+      if (!err) {
         writeFileAtomic(sitemapLoc, JSON.stringify(sitemap), e => {
           if (e) return cb(e)
           cb()
@@ -136,8 +135,8 @@ module.exports = exports = argv => {
   }
 
   const sitemapRestore = cb => {
-    fs.exists(sitemapLoc, exists => {
-      if (exists) {
+    fs.access(sitemapLoc, fs.constants.F_OK, err => {
+      if (!err) {
         fs.readFile(sitemapLoc, (err, data) => {
           if (err) return cb(err)
           try {
@@ -172,8 +171,8 @@ module.exports = exports = argv => {
     const xmlmap = { urlset: { $: { xmlns: 'http://www.sitemaps.org/schemas/sitemap/0.9' }, url: xmlmapPages } }
     const builder = new xml2js.Builder()
     const xml = builder.buildObject(xmlmap)
-    fs.exists(argv.status, exists => {
-      if (exists) {
+    fs.access(argv.status, fs.constants.F_OK, err => {
+      if (!err) {
         writeFileAtomic(xmlSitemapLoc, xml, e => {
           if (e) return cb(e)
           cb()

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "wiki-server",
   "description": "A Federated Wiki Server",
-  "version": "0.26.0-rc.0",
+  "version": "0.26.0-rc.10",
+  "type": "module",
   "author": {
     "name": "Ward Cunningham",
     "email": "ward@c2.com",
@@ -29,40 +30,39 @@
     "Andrew Shell <andrew@andrewshell.org>",
     "jon r <jon@allmende.io>"
   ],
+  "main": "index.js",
   "dependencies": {
-    "async": "^3.2.4",
-    "body-parser": "^2.2.0",
+    "body-parser": "^2.2.1",
     "client-sessions": "^0.8.0",
     "coffeescript": "^2.5.0",
     "cookie-parser": "^1.4.4",
-    "dompurify": "^3.1.0",
+    "dompurify": "^3.3.0",
     "errorhandler": "^1.5.1",
-    "express": "^4.21.2",
+    "express": "^5.1.0",
     "express-hbs": "^2.5.0",
     "flates": "0.0.5",
-    "glob": "^7.2.3",
-    "jsdom": "^26.0.0",
+    "jsdom": "^27.2.0",
     "method-override": "^3.0.0",
-    "minisearch": "^7.1.0",
-    "morgan": "^1.9.1",
-    "node-fetch": "^3.3.2",
-    "write-file-atomic": "^6.0.0",
+    "minisearch": "^7.2.0",
+    "morgan": "^1.10.1",
+    "write-file-atomic": "^7.0.0",
     "xml2js": "^0.6.2"
   },
   "scripts": {
     "prettier:format": "prettier --write './**/*.js'",
     "prettier:check": "prettier --check ./**/*.js",
-    "test": "node --test",
+    "test": "cd test; node --test",
+    "watch": "cd test; node --test --watch",
     "update-authors": "node scripts/update-authors.js"
   },
   "devDependencies": {
-    "@eslint/js": "^9.29.0",
-    "eslint": "^9.29.0",
-    "globals": "^16.1.0",
+    "@eslint/js": "^9.39.1",
+    "eslint": "^9.39.1",
+    "globals": "^16.5.0",
     "grunt-git-authors": "^3.2.0",
-    "prettier": "^3.5.3",
-    "supertest": "^7.0.0",
-    "wiki-client": "^0.31.2",
+    "prettier": "^3.7.3",
+    "supertest": "^7.1.4",
+    "wiki-client": "^0.31.6",
     "wiki-plugin-activity": "0.7",
     "wiki-plugin-video": "^0.4"
   },