@fullstackunicorn/create-root 1.0.23 → 1.0.25

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

@@ -1,288 +1,218 @@
-// 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)
+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'
 
-//             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
+export class Sync {
 
-//             this.def.reportConfig(`🛜 Send-request ${this.def.endpoints.file}`)
+    constructor(init) {
 
-//             const response = await sender.upload(upload)
+        this.def = init.def
+        this.tools = new Tools(init)
+        this.local = new Local(init)
+    }
 
-//             this.def.reportConfig(`🛜 Send-request-report-start`)
-//             this.def.reportConfig(`🛜 ${response?.callback?.report.join('\n🛜 ')}`)
-//             this.def.reportConfig(`🛜 Send-request-report-end`)
+    getWorkspaceApp = () => {
+        const text = JSON.stringify(app, null, 2)
+        const buffer = Buffer.from(text, 'utf8')
+        const hash = this.tools.hash(buffer)
+        return {
+            relPath: 'config/app.json',
+            text,
+            buffer,
+            hash
+        }
+    }
 
-//             if (response?.callback?.isOk) this.def.writeConfig(target, `🔥🔥🔥 Sync.runConfig:success`)
-//             else this.def.writeConfig(target, `❌❌❌ Sync.runConfig:failed`)
+    runWorkspacePush = async (target) => {
 
-//         } catch (e) {
-//             this.def.writeConfig(target, `❌❌❌ Sync.runConfig:error`)
-//             F3.catch.throw(e)
-//         }
+        this.def.spinner.start()
+        this.def.reportWorkspace(`🔥🔥🔥 Sync.runWorkspacePush:start`)
 
-//     }
+        if (target) this.def.app.target = target
 
-//     runAssets = async (target) => {
+        try {
 
-//         this.def.spinner.start()
-//         this.def.reportAssets(`🔥🔥🔥 Sync.runAssets:start`)
-//         if (target) this.def.app.target = target
+            const headers = {}
+            headers.Authorization = await auth.getToken()
+            this.def.reportWorkspace(`✅ workspace-token-obtained`)
 
-//         try {
+            const dataPush = {}
+            dataPush.clientId = this.def.app.clientId
+            dataPush.target = this.def.app.target
+            dataPush.manifest = await this.tools.getWorkspaceManifest()
+            const workspaceApp = this.getWorkspaceApp()
+            dataPush.manifest.files[workspaceApp.relPath] = workspaceApp.hash
+            dataPush.manifest.total = Object.keys(dataPush.manifest.files).length
+            this.def.reportWorkspace(`✅ workspace-manifest-created`)
 
-//             const headers = {}
-//             headers.Authorization = await auth.getToken()
-//             this.def.reportAssets(`✅ plan-token-obtained`)
+            this.def.reportWorkspace(`🛜 Send-workspace-push ${this.def.endpoints.workspacePush}`)
 
-//             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`)
+            const response = await axios.post(this.def.endpoints.workspacePush, dataPush, { headers })
 
-//             this.def.reportAssets(`🛜 Send-request-plan ${this.def.endpoints.plan}`)
+            this.def.reportWorkspace(`🛜 Send-workspace-push-report-start`)
+            this.def.reportWorkspace(`🛜 ${response?.data?.report.join('\n🛜 ')}`)
+            this.def.reportWorkspace(`🛜 Send-workspace-push-report-end`)
 
-//             const response = await axios.post(this.def.endpoints.plan, dataPlan, { headers })
+            const plan = response?.data?.plan
+            if (!F3.obj.isGood(plan)) F3.throw(`missing-workspace-plan`)
 
-//             this.def.reportAssets(`🛜 Send-request-plan-report-start`)
-//             this.def.reportAssets(`🛜 ${response?.data?.report.join('\n🛜 ')}`)
-//             this.def.reportAssets(`🛜 Send-request-plan-report-end`)
+            await fsa.ensureFileDir(this.def.files.export.manifest)
+            await fsa.writeJSON(this.def.files.export.manifest, dataPush.manifest)
+            this.def.reportWorkspace(`✅ written-workspace-manifest \n💾 ${this.def.files.export.manifest}`)
 
-//             const plan = response?.data?.plan
-//             if (!F3.obj.isGood(plan)) F3.throw(`missing-plan`)
+            await fsa.ensureFileDir(this.def.files.export.plan)
+            await fsa.writeJSON(this.def.files.export.plan, plan)
+            this.def.reportWorkspace(`✅ written-workspace-plan \n💾 ${this.def.files.export.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}`)
+            if (plan.isAlreadyInSync) {
+                this.def.writeWorkspace(target, `🔥🔥🔥 Sync.runWorkspacePush:success-already-in-sync`)
+                return true
+            }
 
-//             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}`)
+            const uploadPaths = Object.keys(F3.obj.safe(plan.upload))
 
-//             if (!F3.obj.isGood(plan.upload)) {
-//                 this.def.writeAssets(target, '🔥🔥🔥 Sync.runAssets:success-already-in-sync')
-//                 return true
-//             }
+            if (!uploadPaths.length) {
+                this.def.writeWorkspace(target, `🔥🔥🔥 Sync.runWorkspacePush:success-manifest-only`)
+                return true
+            }
 
-//             const uploadPaths = Object.keys(plan.upload)
-//             const zip = new JSZip()
+            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}`)
-//             }
+            for (const relPath of uploadPaths) {
+                let buffer = null
 
-//             await fsa.safeRemove(this.def.files.export.volumeZip)
-//             this.def.reportAssets(`✅ removed-old-zip-folder`)
+                if (relPath === workspaceApp.relPath) buffer = workspaceApp.buffer
+                else {
+                    const fullPath = `${this.def.workspace}/${relPath}`
+                    buffer = await fsa.readFile(fullPath)
+                }
 
-//             await fsa.ensureFileDir(this.def.files.export.volumeZip)
-//             this.def.reportAssets(`✅ created-new-zip-folder`)
+                if (!buffer) F3.throw(`workspace-zip-missing-file:${relPath}`)
+                zip.file(relPath, buffer)
+                this.def.reportWorkspace(`✅ ➕ zip ${relPath}`)
+            }
 
-//             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}`)
+            await fsa.safeRemove(this.def.files.export.workspaceZip)
+            await fsa.ensureFileDir(this.def.files.export.workspaceZip)
+            const bufferZip = await zip.generateAsync({ type: 'nodebuffer', compression: 'DEFLATE' })
+            await fsa.writeFile(this.def.files.export.workspaceZip, bufferZip)
 
-//             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)
+            this.def.reportWorkspace(`✅ written-workspace-zip \n💾 ${this.def.files.export.workspaceZip}`)
 
-//             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
+            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)
 
-//             this.def.reportAssets(`🛜 Send-assets-zip ${this.def.endpoints.plan}`)
+            const upload = {}
+            upload.bytes = bufferZip
+            upload.target = this.def.app.target
+            upload.token = await auth.getToken()
+            upload.payload = {}
+            upload.payload.callback = 'workspace'
+            upload.payload.importId = plan.importId
+            upload.payload.clientId = this.def.app.clientId
 
-//             const senderRes = await sender.upload(argsUpload)
+            this.def.reportWorkspace(`🛜 Send-workspace-zip ${this.def.endpoints.file}`)
 
-//             this.def.reportAssets(`🛜 Send-assets-zip-report-start`)
-//             this.def.reportAssets(`🛜 ${senderRes?.callback?.report.join('\n🛜 ')}`)
-//             this.def.reportAssets(`🛜 Send-assets-zip-report-end`)
+            const senderRes = await sender.upload(upload)
 
-//             if (senderRes?.callback?.isOk) this.def.writeAssets(target, `🔥🔥🔥 Sync.runAssets:success`)
-//             else this.def.writeAssets(target, `❌❌❌ Sync.runAssets:failed`)
+            this.def.reportWorkspace(`🛜 Send-workspace-zip-report-start`)
+            this.def.reportWorkspace(`🛜 ${senderRes?.callback?.report.join('\n🛜 ')}`)
+            this.def.reportWorkspace(`🛜 Send-workspace-zip-report-end`)
 
-//         } catch (e) {
-//             this.def.writeAssets(target, `❌❌❌ Sync.runAssets:error`)
-//             F3.catch.throw(e)
-//         }
+            if (senderRes?.callback?.isOk) this.def.writeWorkspace(target, `🔥🔥🔥 Sync.runWorkspacePush:success`)
+            else this.def.writeWorkspace(target, `❌❌❌ Sync.runWorkspacePush:failed`)
 
-//     }
+        } catch (e) {
+            this.def.writeWorkspace(target, `❌❌❌ Sync.runWorkspacePush: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
+    runConfig = async (target) => {
+        return await this.runWorkspacePush(target)
+    }
 
-//         try {
+    runPush = async (target) => {
+        return await this.runWorkspacePush(target)
+    }
 
-//             const payload = {}
-//             payload.clientId = this.def.app.clientId
-//             payload.target = this.def.app.target
+    runWorkspacePull = async (target) => {
 
-//             this.def.reportWorkers(`🛜 Send-workers ${this.def.endpoints.workers}`)
+        this.def.spinner.start()
+        this.def.reportWorkspace(`🔥🔥🔥 Sync.runWorkspacePull:start`)
 
-//             const response = await axios.post(this.def.endpoints.workers, payload)
+        if (target) this.def.app.target = target
 
-//             if (response?.data?.isLocal) {
+        try {
 
-//                 await this.local.run(response.data)
+            const headers = {}
+            headers.Authorization = await auth.getToken()
 
-//                 this.def.writeAssets(target, '🔥🔥🔥 Sync.runAssets:success-local')
-//                 return true
-//             }
+            const payload = {}
+            payload.clientId = this.def.app.clientId
+            payload.target = this.def.app.target
 
-//             this.def.reportWorkers(`🛜 Send-workers-report-start`)
-//             this.def.reportWorkers(`🛜 ${response?.data?.report.join('\n🛜 ')}`)
-//             this.def.reportWorkers(`🛜 Send-workers-report-end`)
+            this.def.reportWorkspace(`🛜 Send-workspace-pull ${this.def.endpoints.workspacePull}`)
 
-//             if (response?.data?.isOk) this.def.writeWorkers(target, `🔥🔥🔥 Sync.runWorkers:success`)
-//             else this.def.writeWorkers(target, `❌❌❌ Sync.runWorkers:failed`)
+            const response = await axios.post(this.def.endpoints.workspacePull, payload, {
+                headers,
+                responseType: 'arraybuffer'
+            })
 
-//         } catch (e) {
-//             this.def.writeWorkers(target, `❌❌❌ Sync.runWorkers:error`)
-//             F3.catch.throw(e)
-//         }
-//     }
-// }
+            const filePath = this.def.getPullFile(this.def.app.target)
 
-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'
+            await fsa.ensureFileDir(filePath)
+            await fsa.writeFile(filePath, response.data)
 
-export class Sync {
+            this.def.reportWorkspace(`✅ 💾 workspace-pull-written ${filePath}`)
+            this.def.writeWorkspace(target, `🔥🔥🔥 Sync.runWorkspacePull:success`)
 
-    constructor(init) {
+            return true
 
-        this.def = init.def
-        this.tools = new Tools(init)
-        this.local = new Local(init)
+        } catch (e) {
+            this.def.writeWorkspace(target, `❌❌❌ Sync.runWorkspacePull:error`)
+            F3.catch.throw(e)
+        }
     }
 
-    runConfig = async (target) => {
+    runCleanup = async (kind = 'workspace') => {
 
         this.def.spinner.start()
-        this.def.reportConfig(`🔥🔥🔥 Sync.runConfig:start`)
-
-        if (target) this.def.app.target = target
+        this.def.reportWorkspace(`🔥🔥🔥 Sync.runCleanup:start ${kind}`)
 
         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 headers = {}
+            headers.Authorization = await auth.getToken()
 
             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)
+            payload.clientId = this.def.app.clientId
+            payload.kind = kind
 
-            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.reportWorkspace(`🛜 Send-workspace-cleanup ${this.def.endpoints.workspaceCleanup}`)
+
+            const response = await axios.post(this.def.endpoints.workspaceCleanup, payload, { headers })
 
-            this.def.reportConfig(`🛜 Send-request ${this.def.endpoints.file}`)
+            const report = F3.arr.safe(response?.data?.report)
+            if (report.length) {
+                this.def.reportWorkspace(`🛜 ${report.join('\n🛜 ')}`)
+            }
 
-            const response = await sender.upload(upload)
+            if (!response?.data?.isOk) F3.throw(`workspace-cleanup-failed:${kind}`)
 
-            this.def.reportConfig(`🛜 Send-request-report-start`)
-            this.def.reportConfig(`🛜 ${response?.callback?.report.join('\n🛜 ')}`)
-            this.def.reportConfig(`🛜 Send-request-report-end`)
+            this.def.writeWorkspace('local', `🔥🔥🔥 Sync.runCleanup:success ${kind}`)
 
-            if (response?.callback?.isOk) this.def.writeConfig(target, `🔥🔥🔥 Sync.runConfig:success`)
-            else this.def.writeConfig(target, `❌❌❌ Sync.runConfig:failed`)
+            return true
 
         } catch (e) {
-            this.def.writeConfig(target, `❌❌❌ Sync.runConfig:error`)
+            this.def.writeWorkspace('local', `❌❌❌ Sync.runCleanup:error ${kind}`)
             F3.catch.throw(e)
         }
 
@@ -296,87 +226,19 @@ export class Sync {
 
         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`)
+            const payload = {}
+            payload.clientId = this.def.app.clientId
+            payload.target = this.def.app.target
 
-            this.def.reportAssets(`🛜 Send-request-plan ${this.def.endpoints.plan}`)
+            this.def.reportAssets(`🛜 Send-assets ${this.def.endpoints.assets}`)
 
-            const response = await axios.post(this.def.endpoints.plan, dataPlan, { headers })
+            const response = await axios.post(this.def.endpoints.assets, payload)
 
-            this.def.reportAssets(`🛜 Send-request-plan-report-start`)
+            this.def.reportAssets(`🛜 Send-assets-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`)
+            this.def.reportAssets(`🛜 Send-assets-report-end`)
 
-            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`)
+            if (response?.data?.isOk) this.def.writeAssets(target, `🔥🔥🔥 Sync.runAssets:success`)
             else this.def.writeAssets(target, `❌❌❌ Sync.runAssets:failed`)
 
         } catch (e) {
@@ -402,10 +264,6 @@ export class Sync {
 
             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 = {}
@@ -419,6 +277,10 @@ export class Sync {
                 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`)
 
@@ -427,4 +289,4 @@ export class Sync {
             F3.catch.throw(e)
         }
     }
-}
+}

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

@@ -16,17 +16,17 @@ export class Tools {
         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 () => {
+    getManifest = async (basePath = this.def.folders.volume, schema = 'manifest.raw.sync.request', filter = null) => {
 
         try {
 
             const manifest = {}
-            manifest.schema = 'manifest.raw.sync.request'
+            manifest.schema = schema
             manifest.date = this.getManifestDate()
             manifest.version = 1
             manifest.total = 0
             manifest.files = {}
-            await this.addFiles(this.def.folders.volume, '', manifest)
+            await this.addFiles(basePath, '', manifest, filter)
             await fsa.ensureFileDir(this.def.files.export.manifest)
             await fsa.writeJSON(this.def.files.export.manifest, manifest)
             return manifest
@@ -34,8 +34,39 @@ export class Tools {
         } catch (error) { F3.catch.throw(error, 'sync-client-getManifest-failed') }
     }
 
+    getWorkspaceManifest = async () => {
+        return await this.getManifest(this.def.workspace, 'manifest.workspace.sync.request', relPath => this.isWorkspaceFile(relPath))
+    }
+
+    isWorkspaceFile = (relPath = '') => {
+
+        if (!F3.str.isGood(relPath)) return false
+
+        const root = relPath.split('/')[0]
+        if (!['config', 'volume'].includes(root)) return false
+
+        const reports = [
+            'local.workspace.md',
+            'local.assets.md',
+            'local.workers.md',
+            'sv1.workspace.md',
+            'sv1.assets.md',
+            'sv1.workers.md',
+            'stage.workspace.md',
+            'stage.assets.md',
+            'stage.workers.md',
+            'production.workspace.md',
+            'production.assets.md',
+            'production.workers.md'
+        ]
 
-    addFiles = async (basePath, rel = '', manifest) => {
+        if (reports.includes(relPath)) return false
+
+        return true
+    }
+
+
+    addFiles = async (basePath, rel = '', manifest, filter = null) => {
 
         const dir = rel ? `${basePath}/${rel}` : basePath
         const entries = await fsa.readDir(dir)
@@ -49,10 +80,12 @@ export class Tools {
             const stat = await fsa.stat(fullPath)
 
             if (stat.isDirectory()) {
-                await this.addFiles(basePath, nextRel, manifest)
+                await this.addFiles(basePath, nextRel, manifest, filter)
                 continue
             }
 
+            if (typeof filter === 'function' && !filter(nextRel)) continue
+
             const buffer = await fsa.readFile(fullPath)
             const hash = this.hash(buffer)
             manifest.files[nextRel] = hash
@@ -99,4 +132,4 @@ export class Tools {
         ref[last] = val
     }
 
-}
+}