@fullstackunicorn/create-root 1.0.16 → 1.0.18

package/assets/root.fullstackunicorn.dev/assets/modules/sync.js

@@ -0,0 +1,430 @@
+// import { app, fsa, axios, crypto, JSZip, Sender } from '#@/index.dep.js'
+// import { auth } from '#@/modules/sync.auth.js'
+// import { Local } from '#@/modules/sync.local.js'
+// import { Tools } from '#@/modules/sync.tools.js'
+
+// export class Sync {
+
+//     constructor(init) {
+
+//         this.def = init.def
+//         this.tools = new Tools(init)
+//         this.local = new Local(init)
+//     }
+
+//     runConfig = async (target) => {
+
+//         this.def.spinner.start()
+//         this.def.reportConfig(`🔥🔥🔥 Sync.runConfig:start`)
+
+//         if (target) this.def.app.target = target
+
+//         try {
+
+//             const list = await this.tools.getList(this.def.folders.config)
+
+//             this.def.reportConfig(`✅ file-list-read ${this.def.folders.config}`)
+
+//             const zip = new JSZip()
+//             zip.file('app.json', JSON.stringify(app, null, 2))
+
+//             for (const relPath of list) {
+//                 const buffer = await fsa.readFile(`${this.def.folders.config}/${relPath}`)
+//                 zip.file(relPath, buffer)
+//                 this.def.reportConfig(`✅ file-added-to-zip ${relPath}`)
+//             }
+
+//             await fsa.safeRemove(this.def.files.export.configZip)
+//             await fsa.ensureFileDir(this.def.files.export.configZip)
+//             const bufferZip = await zip.generateAsync({ type: 'nodebuffer', compression: 'DEFLATE' })
+//             await fsa.writeFile(this.def.files.export.configZip, bufferZip)
+
+//             this.def.reportConfig(`✅ written-zip \n💾 ${this.def.files.export.configZip}`)
+
+//             const payload = {}
+//             payload.crypto = crypto
+//             payload.fileEndpoint = this.def.endpoints.file
+//             payload.chunkEndpoint = this.def.endpoints.chunk
+//             payload.statusEndpoint = this.def.endpoints.status
+//             payload.finalizeEndpoint = this.def.endpoints.finalize
+//             const sender = new Sender(payload)
+
+//             const upload = {}
+//             upload.bytes = bufferZip
+//             upload.target = this.def.app.target
+//             upload.token = await auth.getToken()
+//             upload.payload = {}
+//             upload.payload.callback = 'configure'
+//             upload.payload.clientId = this.def.app.clientId
+
+//             this.def.reportConfig(`🛜 Send-request ${this.def.endpoints.file}`)
+
+//             const response = await sender.upload(upload)
+
+//             this.def.reportConfig(`🛜 Send-request-report-start`)
+//             this.def.reportConfig(`🛜 ${response?.callback?.report.join('\n🛜 ')}`)
+//             this.def.reportConfig(`🛜 Send-request-report-end`)
+
+//             if (response?.callback?.isOk) this.def.writeConfig(target, `🔥🔥🔥 Sync.runConfig:success`)
+//             else this.def.writeConfig(target, `❌❌❌ Sync.runConfig:failed`)
+
+//         } catch (e) {
+//             this.def.writeConfig(target, `❌❌❌ Sync.runConfig:error`)
+//             F3.catch.throw(e)
+//         }
+
+//     }
+
+//     runAssets = async (target) => {
+
+//         this.def.spinner.start()
+//         this.def.reportAssets(`🔥🔥🔥 Sync.runAssets:start`)
+//         if (target) this.def.app.target = target
+
+//         try {
+
+//             const headers = {}
+//             headers.Authorization = await auth.getToken()
+//             this.def.reportAssets(`✅ plan-token-obtained`)
+
+//             const dataPlan = {}
+//             dataPlan.clientId = this.def.app.clientId
+//             dataPlan.target = this.def.app.target
+//             dataPlan.manifest = await this.tools.getManifest()
+//             this.def.reportAssets(`✅ plan-manifest-created`)
+
+//             this.def.reportAssets(`🛜 Send-request-plan ${this.def.endpoints.plan}`)
+
+//             const response = await axios.post(this.def.endpoints.plan, dataPlan, { headers })
+
+//             this.def.reportAssets(`🛜 Send-request-plan-report-start`)
+//             this.def.reportAssets(`🛜 ${response?.data?.report.join('\n🛜 ')}`)
+//             this.def.reportAssets(`🛜 Send-request-plan-report-end`)
+
+//             const plan = response?.data?.plan
+//             if (!F3.obj.isGood(plan)) F3.throw(`missing-plan`)
+
+//             await fsa.ensureFileDir(this.def.files.export.manifest)
+//             await fsa.writeJSON(this.def.files.export.manifest, dataPlan.manifest)
+//             this.def.reportAssets(`✅ written-manifest-sent \n💾 ${this.def.files.export.manifest}`)
+
+//             await fsa.ensureFileDir(this.def.files.export.plan)
+//             await fsa.writeJSON(this.def.files.export.plan, plan)
+//             this.def.reportAssets(`✅ written-manifest-plan-response \n💾 ${this.def.files.export.plan}`)
+
+//             if (!F3.obj.isGood(plan.upload)) {
+//                 this.def.writeAssets(target, '🔥🔥🔥 Sync.runAssets:success-already-in-sync')
+//                 return true
+//             }
+
+//             const uploadPaths = Object.keys(plan.upload)
+//             const zip = new JSZip()
+
+//             for (const relPath of uploadPaths) {
+//                 const fullPath = `${this.def.folders.volume}/${relPath}`
+//                 const buffer = await fsa.readFile(fullPath)
+//                 if (!buffer) F3.throw(`zip-missing-file:${relPath}`)
+//                 zip.file(relPath, buffer)
+//                 this.def.reportAssets(`✅ file-added-to-zip ${relPath}`)
+//             }
+
+//             await fsa.safeRemove(this.def.files.export.volumeZip)
+//             this.def.reportAssets(`✅ removed-old-zip-folder`)
+
+//             await fsa.ensureFileDir(this.def.files.export.volumeZip)
+//             this.def.reportAssets(`✅ created-new-zip-folder`)
+
+//             const bufferZip = await zip.generateAsync({ type: 'nodebuffer', compression: 'DEFLATE' })
+//             await fsa.writeFile(this.def.files.export.volumeZip, bufferZip)
+//             this.def.reportAssets(`✅ written-zip \n💾 ${this.def.files.export.volumeZip}`)
+
+//             const initSender = {}
+//             initSender.crypto = crypto
+//             initSender.fileEndpoint = this.def.endpoints.file
+//             initSender.chunkEndpoint = this.def.endpoints.chunk
+//             initSender.statusEndpoint = this.def.endpoints.status
+//             initSender.finalizeEndpoint = this.def.endpoints.finalize
+//             const sender = new Sender(initSender)
+
+//             const argsUpload = {}
+//             argsUpload.bytes = bufferZip
+//             argsUpload.target = this.def.app.target
+//             argsUpload.token = await auth.getToken()
+//             argsUpload.payload = {}
+//             argsUpload.payload.callback = 'assets'
+//             argsUpload.payload.importId = plan.importId
+//             argsUpload.payload.clientId = this.def.app.clientId
+
+//             this.def.reportAssets(`🛜 Send-assets-zip ${this.def.endpoints.plan}`)
+
+//             const senderRes = await sender.upload(argsUpload)
+
+//             this.def.reportAssets(`🛜 Send-assets-zip-report-start`)
+//             this.def.reportAssets(`🛜 ${senderRes?.callback?.report.join('\n🛜 ')}`)
+//             this.def.reportAssets(`🛜 Send-assets-zip-report-end`)
+
+//             if (senderRes?.callback?.isOk) this.def.writeAssets(target, `🔥🔥🔥 Sync.runAssets:success`)
+//             else this.def.writeAssets(target, `❌❌❌ Sync.runAssets:failed`)
+
+//         } catch (e) {
+//             this.def.writeAssets(target, `❌❌❌ Sync.runAssets:error`)
+//             F3.catch.throw(e)
+//         }
+
+//     }
+
+//     runWorkers = async (target) => {
+
+//         this.def.spinner.start()
+//         this.def.reportWorkers(`🔥🔥🔥 Sync.runWorkers:start`)
+//         if (target) this.def.app.target = target
+
+//         try {
+
+//             const payload = {}
+//             payload.clientId = this.def.app.clientId
+//             payload.target = this.def.app.target
+
+//             this.def.reportWorkers(`🛜 Send-workers ${this.def.endpoints.workers}`)
+
+//             const response = await axios.post(this.def.endpoints.workers, payload)
+
+//             if (response?.data?.isLocal) {
+
+//                 await this.local.run(response.data)
+
+//                 this.def.writeAssets(target, '🔥🔥🔥 Sync.runAssets:success-local')
+//                 return true
+//             }
+
+//             this.def.reportWorkers(`🛜 Send-workers-report-start`)
+//             this.def.reportWorkers(`🛜 ${response?.data?.report.join('\n🛜 ')}`)
+//             this.def.reportWorkers(`🛜 Send-workers-report-end`)
+
+//             if (response?.data?.isOk) this.def.writeWorkers(target, `🔥🔥🔥 Sync.runWorkers:success`)
+//             else this.def.writeWorkers(target, `❌❌❌ Sync.runWorkers:failed`)
+
+//         } catch (e) {
+//             this.def.writeWorkers(target, `❌❌❌ Sync.runWorkers:error`)
+//             F3.catch.throw(e)
+//         }
+//     }
+// }
+
+import { app, fsa, axios, crypto, JSZip, Sender } from '#@/index.dep.js'
+import { auth } from '#@/modules/sync.auth.js'
+import { Local } from '#@/modules/sync.local.js'
+import { Tools } from '#@/modules/sync.tools.js'
+
+export class Sync {
+
+    constructor(init) {
+
+        this.def = init.def
+        this.tools = new Tools(init)
+        this.local = new Local(init)
+    }
+
+    runConfig = async (target) => {
+
+        this.def.spinner.start()
+        this.def.reportConfig(`🔥🔥🔥 Sync.runConfig:start`)
+
+        if (target) this.def.app.target = target
+
+        try {
+
+            const list = await this.tools.getList(this.def.folders.config)
+
+            this.def.reportConfig(`✅ file-list-read ${this.def.folders.config}`)
+
+            const zip = new JSZip()
+            zip.file('app.json', JSON.stringify(app, null, 2))
+
+            for (const relPath of list) {
+                const buffer = await fsa.readFile(`${this.def.folders.config}/${relPath}`)
+                zip.file(relPath, buffer)
+                this.def.reportConfig(`✅ file-added-to-zip ${relPath}`)
+            }
+
+            await fsa.safeRemove(this.def.files.export.configZip)
+            await fsa.ensureFileDir(this.def.files.export.configZip)
+            const bufferZip = await zip.generateAsync({ type: 'nodebuffer', compression: 'DEFLATE' })
+            await fsa.writeFile(this.def.files.export.configZip, bufferZip)
+
+            this.def.reportConfig(`✅ written-zip \n💾 ${this.def.files.export.configZip}`)
+
+            const payload = {}
+            payload.crypto = crypto
+            payload.fileEndpoint = this.def.endpoints.file
+            payload.chunkEndpoint = this.def.endpoints.chunk
+            payload.statusEndpoint = this.def.endpoints.status
+            payload.finalizeEndpoint = this.def.endpoints.finalize
+            const sender = new Sender(payload)
+
+            const upload = {}
+            upload.bytes = bufferZip
+            upload.target = this.def.app.target
+            upload.token = await auth.getToken()
+            upload.payload = {}
+            upload.payload.callback = 'configure'
+            upload.payload.clientId = this.def.app.clientId
+
+            this.def.reportConfig(`🛜 Send-request ${this.def.endpoints.file}`)
+
+            const response = await sender.upload(upload)
+
+            this.def.reportConfig(`🛜 Send-request-report-start`)
+            this.def.reportConfig(`🛜 ${response?.callback?.report.join('\n🛜 ')}`)
+            this.def.reportConfig(`🛜 Send-request-report-end`)
+
+            if (response?.callback?.isOk) this.def.writeConfig(target, `🔥🔥🔥 Sync.runConfig:success`)
+            else this.def.writeConfig(target, `❌❌❌ Sync.runConfig:failed`)
+
+        } catch (e) {
+            this.def.writeConfig(target, `❌❌❌ Sync.runConfig:error`)
+            F3.catch.throw(e)
+        }
+
+    }
+
+    runAssets = async (target) => {
+
+        this.def.spinner.start()
+        this.def.reportAssets(`🔥🔥🔥 Sync.runAssets:start`)
+        if (target) this.def.app.target = target
+
+        try {
+
+            const headers = {}
+            headers.Authorization = await auth.getToken()
+            this.def.reportAssets(`✅ plan-token-obtained`)
+
+            const dataPlan = {}
+            dataPlan.clientId = this.def.app.clientId
+            dataPlan.target = this.def.app.target
+            dataPlan.manifest = await this.tools.getManifest()
+            this.def.reportAssets(`✅ plan-manifest-created`)
+
+            this.def.reportAssets(`🛜 Send-request-plan ${this.def.endpoints.plan}`)
+
+            const response = await axios.post(this.def.endpoints.plan, dataPlan, { headers })
+
+            this.def.reportAssets(`🛜 Send-request-plan-report-start`)
+            this.def.reportAssets(`🛜 ${response?.data?.report.join('\n🛜 ')}`)
+            this.def.reportAssets(`🛜 Send-request-plan-report-end`)
+
+            const plan = response?.data?.plan
+            if (!F3.obj.isGood(plan)) F3.throw(`missing-plan`)
+
+            await fsa.ensureFileDir(this.def.files.export.manifest)
+            await fsa.writeJSON(this.def.files.export.manifest, dataPlan.manifest)
+            this.def.reportAssets(`✅ written-manifest-sent \n💾 ${this.def.files.export.manifest}`)
+
+            await fsa.ensureFileDir(this.def.files.export.plan)
+            await fsa.writeJSON(this.def.files.export.plan, plan)
+            this.def.reportAssets(`✅ written-manifest-plan-response \n💾 ${this.def.files.export.plan}`)
+
+            if (!F3.obj.isGood(plan.upload)) {
+                this.def.writeAssets(target, '🔥🔥🔥 Sync.runAssets:success-already-in-sync')
+                return true
+            }
+
+            const uploadPaths = Object.keys(plan.upload)
+            const zip = new JSZip()
+
+            for (const relPath of uploadPaths) {
+                const fullPath = `${this.def.folders.volume}/${relPath}`
+                const buffer = await fsa.readFile(fullPath)
+                if (!buffer) F3.throw(`zip-missing-file:${relPath}`)
+                zip.file(relPath, buffer)
+                this.def.reportAssets(`✅ file-added-to-zip ${relPath}`)
+            }
+
+            await fsa.safeRemove(this.def.files.export.volumeZip)
+            this.def.reportAssets(`✅ removed-old-zip-folder`)
+
+            await fsa.ensureFileDir(this.def.files.export.volumeZip)
+            this.def.reportAssets(`✅ created-new-zip-folder`)
+
+            const bufferZip = await zip.generateAsync({ type: 'nodebuffer', compression: 'DEFLATE' })
+            await fsa.writeFile(this.def.files.export.volumeZip, bufferZip)
+            this.def.reportAssets(`✅ written-zip \n💾 ${this.def.files.export.volumeZip}`)
+
+            const initSender = {}
+            initSender.crypto = crypto
+            initSender.fileEndpoint = this.def.endpoints.file
+            initSender.chunkEndpoint = this.def.endpoints.chunk
+            initSender.statusEndpoint = this.def.endpoints.status
+            initSender.finalizeEndpoint = this.def.endpoints.finalize
+            const sender = new Sender(initSender)
+
+            const argsUpload = {}
+            argsUpload.bytes = bufferZip
+            argsUpload.target = this.def.app.target
+            argsUpload.token = await auth.getToken()
+            argsUpload.payload = {}
+            argsUpload.payload.callback = 'assets'
+            argsUpload.payload.importId = plan.importId
+            argsUpload.payload.clientId = this.def.app.clientId
+
+            this.def.reportAssets(`🛜 Send-assets-zip ${this.def.endpoints.plan}`)
+
+            const senderRes = await sender.upload(argsUpload)
+
+            this.def.reportAssets(`🛜 Send-assets-zip-report-start`)
+            this.def.reportAssets(`🛜 ${senderRes?.callback?.report.join('\n🛜 ')}`)
+            this.def.reportAssets(`🛜 Send-assets-zip-report-end`)
+
+            if (senderRes?.callback?.isOk) this.def.writeAssets(target, `🔥🔥🔥 Sync.runAssets:success`)
+            else this.def.writeAssets(target, `❌❌❌ Sync.runAssets:failed`)
+
+        } catch (e) {
+            this.def.writeAssets(target, `❌❌❌ Sync.runAssets:error`)
+            F3.catch.throw(e)
+        }
+
+    }
+
+    runWorkers = async (target) => {
+
+        this.def.spinner.start()
+        this.def.reportWorkers(`🔥🔥🔥 Sync.runWorkers:start`)
+        if (target) this.def.app.target = target
+
+        try {
+
+            const payload = {}
+            payload.clientId = this.def.app.clientId
+            payload.target = this.def.app.target
+
+            this.def.reportWorkers(`🛜 Send-workers ${this.def.endpoints.workers}`)
+
+            const response = await axios.post(this.def.endpoints.workers, payload)
+
+            this.def.reportWorkers(`🛜 Send-workers-report-start`)
+            this.def.reportWorkers(`🛜 ${response?.data?.report.join('\n🛜 ')}`)
+            this.def.reportWorkers(`🛜 Send-workers-report-end`)
+
+            if (response?.data?.isLocal) {
+
+                const local = {}
+                local.payload = response?.data?.local
+                local.target = this.def.app.target
+                local.app = app
+
+                await this.local.run(local)
+
+                this.def.writeWorkers(target, `🔥🔥🔥 Sync.runWorkers:success-local`)
+                return true
+            }
+
+            if (response?.data?.isOk) this.def.writeWorkers(target, `🔥🔥🔥 Sync.runWorkers:success`)
+            else this.def.writeWorkers(target, `❌❌❌ Sync.runWorkers:failed`)
+
+        } catch (e) {
+            this.def.writeWorkers(target, `❌❌❌ Sync.runWorkers:error`)
+            F3.catch.throw(e)
+        }
+    }
+}

package/assets/root.fullstackunicorn.dev/assets/modules/sync.local.js

@@ -0,0 +1,117 @@
+import { fsa, axios, crypto, Sender } from '#@/index.dep.js'
+import { auth } from '#@/modules/sync.auth.js'
+
+export class Local {
+
+    constructor(init) {
+        this.def = init.def
+    }
+
+    getManager = (app, target) => {
+
+        if (!F3.obj.isGood(app)) F3.throw('local-app-not-valid')
+        if (!F3.obj.isGood(app.manager)) F3.throw('local-manager-not-valid')
+        if (!F3.str.isGood(target)) F3.throw('local-target-not-valid')
+
+        const manager = app.manager[target]
+        if (!F3.str.isGood(manager)) F3.throw('local-manager-target-not-valid', { target })
+
+        const result = {}
+        result.file = `${manager}/sync/file`
+        result.chunk = `${manager}/sync/chunk`
+        result.status = `${manager}/sync/status`
+        result.finalize = `${manager}/sync/finalize`
+
+        return result
+    }
+
+    send = async ({ app, target, plan, manifest }) => {
+
+        try {
+
+            if (!F3.obj.isGood(plan)) F3.throw('local-plan-not-valid')
+            if (!F3.obj.isGood(manifest)) F3.throw('local-manifest-not-valid')
+
+            const endpoints = this.getManager(app, target)
+
+            const payload = {}
+            payload.crypto = crypto
+            payload.fileEndpoint = endpoints.file
+            payload.chunkEndpoint = endpoints.chunk
+            payload.statusEndpoint = endpoints.status
+            payload.finalizeEndpoint = endpoints.finalize
+            const sender = new Sender(payload)
+
+            const upload = {}
+            upload.bytes = await fsa.readFile(this.def.files.export.volumeZip)
+            upload.target = target
+            upload.token = await auth.getToken()
+            upload.payload = {}
+            upload.payload.plan = plan
+            upload.payload.manifest = manifest
+
+            this.def.reportWorkers(`🛜 Send-local-manager-zip ${payload.fileEndpoint}`)
+
+            const response = await sender.upload(upload)
+
+            this.def.reportWorkers(`🛜 Send-local-manager-zip-report-start`)
+            this.def.reportWorkers(`🛜 💾 ${response?.callback?.written.join('\n🛜 💾 ')}`)
+            this.def.reportWorkers(`🛜 🗑️ ${response?.callback?.deleted.join('\n🛜 🗑️ ')}`)
+            this.def.reportWorkers(`🛜 Send-local-manager-zip-report-end`)
+
+            if (!response?.callback?.isOk) F3.throw('local-manager-send-failed')
+
+            this.def.reportWorkers(`✅ local-manager-send-success`)
+
+            return true
+
+        } catch (e) { F3.catch.throw(e) }
+    }
+
+    run = async ({ payload, app, target }) => {
+
+        try {
+
+            if (!F3.obj.isGood(payload)) F3.throw('local-payload-not-valid')
+            if (!F3.obj.isGood(app)) F3.throw('local-app-not-valid')
+            if (!F3.str.isGood(target)) F3.throw('local-target-not-valid')
+
+            const { get, confirm, meta } = payload
+
+            if (!F3.str.isGood(get)) F3.throw('local-get-not-valid')
+            if (!F3.str.isGood(confirm)) F3.throw('local-confirm-not-valid')
+            if (!F3.str.isGood(meta)) F3.throw('local-meta-not-valid')
+
+            const responseGet = await axios.get(get, { responseType: 'arraybuffer' })
+
+            if (!responseGet?.data) F3.throw('local-download-not-valid')
+
+            const filePath = this.def.files.export.volumeZip
+
+            await fsa.writeFile(filePath, responseGet.data)
+
+            this.def.reportWorkers(`✅ local-zip-downloaded ${filePath}`)
+
+            const responseMeta = await axios.post(meta)
+
+            if (!F3.obj.isGood(responseMeta?.data)) F3.throw('local-meta-response-not-valid')
+            if (!F3.obj.isGood(responseMeta?.data?.plan)) F3.throw('local-meta-plan-not-valid')
+            if (!F3.obj.isGood(responseMeta?.data?.manifest)) F3.throw('local-meta-manifest-not-valid')
+
+            const { plan, manifest } = responseMeta.data
+
+            this.def.reportWorkers(`✅ local-meta-received`)
+
+            await this.send({ app, target, plan, manifest })
+
+            const responseConfirm = await axios.post(confirm)
+
+            if (!responseConfirm?.data?.isOk) F3.throw('local-confirm-not-valid')
+
+            this.def.reportWorkers(`✅ local-confirm-sent`)
+
+            return true
+
+        } catch (e) { F3.catch.throw(e) }
+    }
+}

package/assets/root.fullstackunicorn.dev/assets/modules/sync.tools.js

@@ -0,0 +1,102 @@
+import { fsa, crypto } from '#@/index.dep.js'
+
+export class Tools {
+
+    constructor(init) {
+
+        this.def = init.def
+
+    }
+
+    getManifestDate = () => {
+        const d = new Date()
+        const days = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat']
+        const months = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec']
+        const timestamp = d.getTime()
+        return `${timestamp}-${days[d.getDay()]}.${String(d.getDate()).padStart(2, '0')}.${months[d.getMonth()]}.${d.getFullYear()}-${String(d.getHours()).padStart(2, '0')}.${String(d.getMinutes()).padStart(2, '0')}`
+    }
+
+    getManifest = async () => {
+
+        try {
+
+            const manifest = {}
+            manifest.schema = 'manifest.raw.sync.request'
+            manifest.date = this.getManifestDate()
+            manifest.version = 1
+            manifest.total = 0
+            manifest.files = {}
+            await this.addFiles(this.def.folders.volume, '', manifest)
+            await fsa.ensureFileDir(this.def.files.export.manifest)
+            await fsa.writeJSON(this.def.files.export.manifest, manifest)
+            return manifest
+
+        } catch (error) { F3.catch.throw(error, 'sync-client-getManifest-failed') }
+    }
+
+
+    addFiles = async (basePath, rel = '', manifest) => {
+
+        const dir = rel ? `${basePath}/${rel}` : basePath
+        const entries = await fsa.readDir(dir)
+
+        for (const entry of entries) {
+
+            if (fsa.isJunk(entry)) continue
+
+            const nextRel = rel ? `${rel}/${entry}` : entry
+            const fullPath = `${basePath}/${nextRel}`
+            const stat = await fsa.stat(fullPath)
+
+            if (stat.isDirectory()) {
+                await this.addFiles(basePath, nextRel, manifest)
+                continue
+            }
+
+            const buffer = await fsa.readFile(fullPath)
+            const hash = this.hash(buffer)
+            manifest.files[nextRel] = hash
+            manifest.total += 1
+        }
+    }
+
+    hash = (buffer) => {
+        const buf = buffer instanceof ArrayBuffer ? Buffer.from(buffer) : buffer
+        return crypto.createHash('sha256').update(buf).digest('hex')
+    }
+
+    getList = async basePath => {
+        const files = []
+        const scan = async dir => {
+            const entries = await fsa.readDir(dir)
+            for (const entry of entries) {
+                if (fsa.isJunk(entry)) continue
+                const fullPath = `${dir}/${entry}`
+                const stat = await fsa.stat(fullPath)
+                if (stat.isDirectory()) await scan(fullPath)
+                else files.push(fullPath.replace(`${basePath}/`, ''))
+            }
+        }
+        await scan(basePath)
+        return files
+    }
+
+    pathToObj = (obj, path, val) => {
+
+        if (!path) return
+
+        const keys = path.split('/')
+        const parents = keys.slice(0, -1)
+        const last = keys[keys.length - 1]
+
+        let ref = obj
+
+        for (const key of parents) {
+            if (!F3.isObj(ref[key])) ref[key] = {}
+            ref = ref[key]
+        }
+
+        ref[last] = val
+    }
+
+}

package/assets/root.fullstackunicorn.dev/assets/package.json

@@ -0,0 +1,32 @@
+{
+    "name": "@root.fullstackunicorn.dev/assets",
+    "author": "lucanigido (https://fullstackunicorn.dev/author/lucanigido)",
+    "version": "1.0.0",
+    "type": "module",
+    "license": "UNLICENSED",
+    "private": true,
+    "imports": {
+        "#@": "./",
+        "#@/*": "./*"
+    },
+    "scripts": {
+        "initialize": "chmod +x ./config.cmd.sh && bash ./config.cmd.sh add",
+        "cmd": "chmod +x ./config.cmd.sh && env-cmd -f .env bash ./config.cmd.sh",
+        "test": "exit 1"
+    },
+    "dependencies": {
+        "@fullstackunicorn/filesystem": "^1.0.16",
+        "@fullstackunicorn/initialize": "^1.0.15",
+        "@fullstackunicorn/upload": "^1.0.11",
+        "@fullstackunicorn/websites": "^1.0.10",
+        "axios": "^1.15.0",
+        "blurhash": "^2.0.5",
+        "jszip": "^3.10.1",
+        "sharp": "^0.34.5"
+    },
+    "devDependencies": {
+        "@fullstackunicorn/cli": "^1.0.8",
+        "env-cmd": "^11.0.0",
+        "nodemon": "^3.1.14"
+    }
+}