@metric-im/administrate 1.0.0

package/.claude/settings.local.json

@@ -0,0 +1,10 @@
+{
+  "permissions": {
+    "allow": [
+      "Read(//home/msprague/workspace/sitewell/**)",
+      "Read(//home/msprague/workspace/rootz/data-wallet-demos/**)"
+    ],
+    "deny": [],
+    "ask": []
+  }
+}

package/README.md

@@ -0,0 +1,2 @@
+# administrate
+Tools for site administration

package/certify.mjs

@@ -0,0 +1,155 @@
+import express from 'express';
+import Acme from 'acme-client';
+import tls from 'tls';
+import { Config } from './config.mjs';
+import moment from 'moment';
+
+const MAX_AGE = 75; // days
+const MAX_WAIT_TIME = 60; // seconds
+
+export class Certify {
+    constructor(app,options) {
+        this.app = app;
+        this.options = options || {};
+        this.pending = {};
+        this.challenges = {};
+        this.contactEmail = undefined;
+    }
+    static async attach(app,options) {
+        const instance = new Certify(app,options);
+        instance.config = new Config();
+        if (!instance.config.data.ssl) instance.config.data.ssl = {};
+        instance.contactEmail = instance.config.profile?.email || instance.options.contactEmail;
+        instance.acme = new Acme.Client({
+            directoryUrl: Acme.directory.letsencrypt[process.env.PROFILE==='DEV'?'staging':'production'],
+            accountKey: await Acme.crypto.createPrivateKey(),
+        });
+        if (process.env.PROFILE==='DEV'){
+          Acme.setLogger((message) => {
+            console.log(message);
+          });
+        }
+        app.use('/',instance.routes());
+        return instance;
+    }
+    get SNI() {
+        return {SNICallback: async (hostname, cb) => {
+            try {
+              console.log(`SNL get keys for ${hostname}`)
+              const siteKeys = await this.getSiteKeys(hostname);
+              cb(null, tls.createSecureContext(siteKeys));
+            } catch (error) {
+              console.error(`Error loading certificate for ${hostname}:`, error);
+              cb(error);
+            }
+        }}
+    }
+    routes() {
+        const router = express.Router();
+
+        router.get(/^\/\.well-known\/acme-challenge\/([^\/]+)$/,(req,res)=>{
+            const token = req.params[0];
+            if (token in this.challenges) {
+                res.writeHead(200);
+                res.end(this.challenges[token]);
+                return;
+            }
+            // Don't redirect ACME challenges - return 404 instead (says Claude, used to be 302)
+            res.writeHead(404);
+            res.end('Challenge not found');
+        });
+        // router.use('/',(req, res, next) => {
+        //     if (!req.secure && process.env.FORCE_HTTPS?.toLowerCase() !== 'false') {
+        //         return res.redirect(`https://${req.hostname}${req.url}`);
+        //     }
+        //     next();
+        // });
+        return router;
+    }
+    async getSiteKeys(sitename) {
+      // For localhost and local domains, don't try to get Let's Encrypt certificates
+      if (sitename === 'localhost' || sitename.includes('.local') || sitename.match(/^\d+\.\d+\.\d+\.\d+$/)) {
+        return null; // Use default certificate
+      }
+      
+      const site = this.config.data.ssl ? this.config.data.ssl[sitename] : undefined;
+      if (!site?.certified || moment().isAfter(moment(site.certified).add(MAX_AGE, 'days'))) {
+        if (!this.pending[sitename] || moment().isAfter(moment(this.pending[sitename]).add(MAX_WAIT_TIME, 'seconds'))) {
+          try {
+            this.pending[sitename] = moment();
+            setTimeout(async () => {
+              try {
+                await this.renewCert(sitename);
+              } catch (e) {
+                console.error(`Failed to renew certificate for ${sitename}:`, e);
+                delete this.pending[sitename];
+              }
+            },10);
+          } catch(e) {
+            console.error(e);
+            delete this.pending[sitename];
+          }
+        }
+      }
+      if (site) {
+        const key = this.config.readFile(site.key).toString();
+        const cert = this.config.readFile(site.cert).toString();
+        return {key: key, cert: cert};
+      } else {
+        return null;
+      }
+    }
+    async renewCert(sitename) {
+      const site = this.config.data.ssl ? this.config.data.ssl[sitename] : undefined;
+      if (site?.certified && moment().isBefore(moment(site.certified).add(MAX_AGE, 'days'))) {
+        return;
+      } else {
+        if (!this.contactEmail) throw new Error(`cannot request certificate without CONTACT_EMAIL set`);
+        this.pending[sitename] = true;
+        
+        try {
+          // Add timeout wrapper for the entire certificate renewal process
+          await Promise.race([
+            this.doRenewCert(sitename),
+            new Promise((_, reject) => 
+              setTimeout(() => reject(new Error(`Certificate renewal timeout for ${sitename}`)), 120000) // 2 minute timeout
+            )
+          ]);
+        } catch (error) {
+          console.error(`Certificate renewal failed for ${sitename}:`, error);
+          delete this.pending[sitename];
+          throw error;
+        }
+      }
+    }
+
+    async doRenewCert(sitename) {
+      // create CSR
+      const [key, csr] = await Acme.crypto.createCsr({
+        altNames: [sitename],
+      });
+      
+      // order certificate with timeout
+      const cert = await this.acme.auto({
+        csr,
+        email: this.contactEmail,
+        termsOfServiceAgreed: true,
+        challengePriority: ['http-01'],
+        challengeCreateFn: (authz, challenge, keyAuthorization) => {
+          this.challenges[challenge.token] = keyAuthorization;
+        },
+        challengeRemoveFn: (authz, challenge) => {
+          delete this.challenges[challenge.token];
+        },
+      });
+      
+      // save certificate
+      this.config.writeFile(sitename+'.cert', cert);
+      this.config.writeFile(sitename+'.key', key.toString());
+      this.config.data.ssl[sitename] = {key:sitename+'.key', cert:sitename+'.cert',certified:moment().format("YYYY-MM-DD")};
+      delete this.pending[sitename];
+      this.config.save();
+      
+      console.log(`Certificate successfully renewed for ${sitename}`);
+    }
+}

package/config.mjs

@@ -0,0 +1,95 @@
+import fs from 'fs';
+import ini from 'ini';
+import {dirname, join, resolve} from "path";
+import * as domain from "node:domain";
+
+export class Config {
+    constructor(rootName) {
+        this.rootName = rootName || 'metric-im';
+        this.homeDir = (process.platform === 'win32' ? process.env.USERPROFILE : process.env.HOME);
+        this.configDir = join(this.homeDir, '.' + this.rootName);
+        this.configFile = join(this.configDir, 'config.ini');
+        if (!fs.existsSync(this.configFile)) {
+            this.initialize();
+        } else {
+            this.load();
+        }
+    }
+
+    initialize() {
+        this.data = ini.decode("");
+        if (!fs.existsSync(this.configDir)) {
+            fs.mkdirSync(this.configDir);
+        }
+        this.save()
+    }
+
+    load() {
+        let fileData = fs.readFileSync(this.configFile);
+        this.data = ini.decode(fileData.toString());
+    }
+
+    save() {
+        let text = ini.stringify(this.data, {});
+        fs.writeFileSync(this.configFile, text);
+    }
+
+    readFile(filename) {
+        return fs.readFileSync(join(this.configDir, filename));
+    }
+
+    writeFile(filename, data) {
+        fs.writeFileSync(join(this.configDir, filename), data);
+    }
+}
+
+export class DomainConfig extends Config {
+  constructor(rootName,domain) {
+    super(rootName);
+    this.domain = domain;
+    this.domainData = {};
+  }
+
+  setDomain(domain) {
+    this.domain = domain;
+    this.domainConfigDir = join(this.configDir, domain);
+    this.domainConfigFile = join(this.domainConfigDir, 'config.ini');
+    if (!fs.existsSync(this.domainConfigDir)) {
+      fs.mkdirSync(this.domainConfigDir);
+      fs.writeFileSync(this.domainConfigFile,JSON.stringify([]));
+    }
+    this.load();
+  }
+  getDomain(domain) {
+    let filename = join(this.configDir, domain, 'config.ini');
+    if (fs.existsSync(filename)) {
+      const text = fs.readFileSync(filename);
+      return ini.decode(text.toString());
+    } else {
+      return null;
+    }
+  }
+  load() {
+    if (this.domain) {
+      const text = fs.readFileSync(this.domainConfigFile);
+      this.domainData = ini.decode(text.toString());
+    }
+    super.load();
+  }
+  save() {
+    if (this.domain) {
+      const text = ini.stringify(this.domainData);
+      fs.writeFileSync(this.domainConfigFile, text);
+    }
+    super.save();
+  }
+  readFile(filename) {
+    if (this.domain) return fs.readFileSync(join(this.domainConfigDir, filename));
+    else return super.readFile(filename);
+  }
+
+  writeFile(filename, data) {
+    if (this.domain) fs.writeFileSync(join(this.domainConfigDir, filename), data);
+    else return super.writeFile(filename);
+  }
+}

package/index.mjs

@@ -0,0 +1,4 @@
+export { Certify } from './certify.mjs';
+export { Config, DomainConfig } from './config.mjs';
+export { Synchronize } from './synchronize.mjs';
+export { MultiSite, Site } from './multisite.mjs';

package/multisite.mjs

@@ -0,0 +1,327 @@
+import express from 'express';
+import tls from 'tls';
+import { Config } from './config.mjs';
+import moment from 'moment';
+import fs from "fs";
+import {resolve} from "path";
+import child_process from "child_process";
+import axios from 'axios';
+
+const MAX_AGE = 75; // days
+const MAX_WAIT_TIME = 60; // seconds
+
+export class MultiSite {
+    constructor(app,options) {
+        this.app = app;
+        this.options = options || {};
+        this.sites = {};
+        this._spawnPort = (parseInt(this.options.spawnPort||0) || 53874);
+        this.usedPorts = new Set();
+        this.healthCheckIntervals = new Map();
+        this.setupCleanup();
+    }
+    get spawnPort() {
+        const port = this._spawnPort++;
+        this.usedPorts.add(port);
+        return port;
+    }
+
+    setupCleanup() {
+        process.on('SIGTERM', () => this.cleanup());
+        process.on('SIGINT', () => this.cleanup());
+        process.on('exit', () => this.cleanup());
+    }
+
+    async cleanup() {
+        console.log('Cleaning up spawned processes...');
+        const promises = Object.values(this.sites).map(async (site) => {
+            if (site.proc && !site.proc.killed) {
+                return new Promise((resolve) => {
+                    const timeout = setTimeout(() => {
+                        if (!site.proc.killed) {
+                            console.log(`Force killing ${site.name} after timeout`);
+                            site.proc.kill('SIGKILL');
+                        }
+                        resolve();
+                    }, 10000); // 10 second timeout for graceful shutdown
+
+                    site.proc.kill('SIGTERM');
+
+                    site.proc.on('exit', () => {
+                        console.log(`${site.name} process terminated gracefully`);
+                        clearTimeout(timeout);
+                        resolve();
+                    });
+                });
+            }
+        });
+
+        await Promise.all(promises.filter(Boolean));
+
+        // Clear all health check intervals
+        this.healthCheckIntervals.forEach(interval => clearInterval(interval));
+        this.healthCheckIntervals.clear();
+
+        console.log('All spawned processes cleaned up');
+    }
+
+    startHealthCheck(site) {
+        const intervalId = setInterval(async () => {
+            if (!site.proc || site.proc.killed) {
+                clearInterval(intervalId);
+                this.healthCheckIntervals.delete(site.name);
+                return;
+            }
+
+            try {
+                await axios.get(`http://127.0.0.1:${site.options.env.PORT}/health`, {
+                    timeout: 5000,
+                    validateStatus: () => true
+                });
+            } catch (error) {
+                if (error.code === 'ECONNREFUSED' || error.code === 'ETIMEDOUT') {
+                    console.log(`Health check failed for ${site.name}, marking for restart...`);
+                    clearInterval(intervalId);
+                    this.healthCheckIntervals.delete(site.name);
+
+                    // Mark the process as failed for cleanup
+                    if (site.proc && !site.proc.killed) {
+                        site.proc.kill('SIGTERM');
+                    }
+                }
+            }
+        }, 30000); // Check every 30 seconds
+
+        this.healthCheckIntervals.set(site.name, intervalId);
+    }
+
+    restartSite(domain) {
+        const oldSite = this.sites[domain];
+        if (oldSite) {
+            // Clear health check
+            const intervalId = this.healthCheckIntervals.get(oldSite.name);
+            if (intervalId) {
+                clearInterval(intervalId);
+                this.healthCheckIntervals.delete(oldSite.name);
+            }
+
+            // Kill old process
+            if (oldSite.proc && !oldSite.proc.killed) {
+                oldSite.proc.kill('SIGTERM');
+            }
+
+            // Remove from used ports
+            this.usedPorts.delete(oldSite.options.env.PORT);
+        }
+
+        // Create new site
+        this.sites[domain] = Site.Clone(domain, this);
+        console.log(`Restarted site for domain: ${domain}`);
+    }
+
+    removeDeadSites() {
+        Object.keys(this.sites).forEach(domain => {
+            const site = this.sites[domain];
+            if (site.proc && site.proc.killed) {
+                this.usedPorts.delete(site.options.env.PORT);
+                delete this.sites[domain];
+                console.log(`Removed dead site: ${domain}`);
+            }
+        });
+    }
+    static async attach(app,options) {
+        const instance = new MultiSite(app,options);
+        instance.config = new Config();
+        // spawn declared sites
+        if (fs.existsSync(resolve('./sites'))) {
+            instance.sites = (fs.readdirSync(resolve('./sites'))).reduce((result,hostName)=>{
+                const domainName = Site.GetId(hostName);
+                const options = {
+                    cwd: resolve(`./sites/${hostName}`),
+                    env: {PORT:instance.spawnPort,meta:instance.options}
+                };
+                result[domainName] = Site.Spawn(domainName,options,instance);
+                return result;
+            },{});
+        }
+        app.use('/',instance.routes());
+        return instance;
+    }
+    routes() {
+        const router = express.Router();
+
+        router.all(/.*/, async (req, res) => {
+            const domain = Site.GetId(req.hostname);
+            const site = this.sites[domain];
+            if (site) {
+                let target = `http://127.0.0.1:${site.options.env.PORT}${req.url}`;
+                const method = req.method;
+                const isBodyMethod = ['POST', 'PUT', 'PATCH'].includes(method);
+                const payload = isBodyMethod ? req.body : null;
+
+                // Debug logging for POST requests
+                if (method === 'POST') {
+                    console.log(`[Proxy] ${method} ${target}`);
+                    console.log(`[Proxy] Request body:`, req.body);
+                    console.log(`[Proxy] Payload:`, payload);
+                }
+
+                const headersToForward = {
+                    ...req.headers,
+                    'content-length': undefined // Let Axios compute
+                };
+
+
+                try {
+                    // Determine if this is a binary file request
+                    const isBinaryRequest = /\.(woff2?|ttf|eot|otf|ico|png|jpe?g|gif|svg|pdf|zip|exe)(\?.*)?$/i.test(req.url);
+
+                    if (isBinaryRequest) {
+                        // Use streaming for binary files to avoid corruption
+                        const response = await axios({
+                            method,
+                            url: target,
+                            headers: headersToForward,
+                            data: payload,
+                            params: req.query,
+                            validateStatus: () => true,
+                            timeout: 30000,
+                            responseType: 'stream'
+                        });
+                        
+                        console.log(`${response.status} ${target} (binary stream)`);
+                        
+                        // Set headers without the problematic ones
+                        const cleanHeaders = {...response.headers};
+                        delete cleanHeaders['transfer-encoding'];
+                        delete cleanHeaders['content-encoding'];
+                        
+                        res.status(response.status).set(cleanHeaders);
+                        response.data.pipe(res);
+                    } else {
+                        // Keep existing text/json handling
+                        const response = await axios({
+                            method,
+                            url: target,
+                            headers: headersToForward,
+                            data: payload,
+                            params: req.query,
+                            validateStatus: () => true,
+                            timeout: 30000,
+                            responseType: 'text'
+                        });
+                        
+                        console.log(`${response.status} ${target}`);
+                        
+                        const cleanHeaders = {...response.headers};
+                        delete cleanHeaders['transfer-encoding'];
+                        delete cleanHeaders['content-encoding'];
+                        
+                        res.status(response.status).set(cleanHeaders).send(response.data);
+                    }
+                } catch (error) {
+                    console.error(`[Proxy] Error connecting to ${target}:`, error.message);
+
+                    // // Clean up dead processes
+                    // this.removeDeadSites();
+                    //
+                    // // Try to respawn the site if it's down
+                    // if (error.code === 'ECONNREFUSED') {
+                    //     console.log(`[Proxy] Attempting to respawn site for ${domain}`);
+                    //     this.sites[domain] = Site.Clone(domain, this);
+                    //     return res.status(503).send('Service temporarily unavailable. Please try again in a few seconds.');
+                    // }
+
+                    res.status(502).send('Bad Gateway. Try reloading.');
+                }
+            } else {
+                this.sites[domain] = Site.Clone(domain,this);
+                // Retry the request after spawning
+                setTimeout(() => {
+                    res.redirect(`//${req.hostname}${req.url}`);
+                }, 2000);
+            }
+        });
+        return router;
+    }
+}
+export class Site {
+    constructor(name,options={},parent) {
+        this.name = name;
+        this.options = options;
+        this.parent = parent;
+    }
+    static Spawn(name, options, parent) {
+        const instance = new Site(name, options, parent);
+        instance.spawn();
+        return instance;
+    }
+    static Clone(name, multisite) {
+        const options = {
+            cwd: process.cwd(),
+            env: {PORT:multisite.spawnPort,meta:multisite.options}
+        };
+        const instance = new Site(name,options);
+        instance.spawn();
+        return instance;
+    }
+    spawn() {
+        let commands = (['run', 'start', this.name]);
+        console.log(`Spawning site ${this.name} on port ${this.options.env.PORT}`);
+
+        try {
+            this.proc = child_process.spawn('npm', commands, this.options);
+
+            this.proc.stdout.on('data', (data) => {
+                process.stdout.write(`${this.name}: ${data.toString()}`);
+            });
+
+            this.proc.stderr.on('data', (data) => {
+                process.stdout.write(`${this.name}:E: ${data.toString()}`);
+            });
+
+            this.proc.on('close', (code) => {
+                console.log(`${this.name}: process exited with code ${code}`);
+                this.proc = null;
+
+                // Clear health check when process exits
+                if (this.healthCheckIntervals) {
+                    const intervalId = this.healthCheckIntervals.get(this.name);
+                    if (intervalId) {
+                        clearInterval(intervalId);
+                        this.healthCheckIntervals.delete(this.name);
+                    }
+                }
+            });
+
+            this.proc.on('error', (err) => {
+                console.error(`${this.name}: Failed to start process:`, err);
+                this.proc = null;
+            });
+
+            // Give the process time to start, then begin health checks
+            setTimeout(() => {
+                if (this.proc && !this.proc.killed) {
+                    console.log(`${this.name}: Successfully started on port ${this.options.env.PORT}`);
+
+                    // Start health monitoring after a delay to allow process to fully start
+                    if (this.startHealthCheck) {
+                        setTimeout(() => {
+                            if (this.proc && !this.proc.killed) {
+                                this.startHealthCheck(this);
+                            }
+                        }, 5000); // Wait 5 seconds before starting health checks
+                    }
+                }
+            }, 1000);
+
+        } catch (err) {
+            console.error(`${this.name}: Exception while spawning:`, err);
+            this.proc = null;
+        }
+   }
+    static GetId(hostName="") {
+        if (hostName.match(/^[\d]{1,3}\.[\d]{1,3}\.[\d]{1,3}\.[\d]{1,3}$/)) return null
+        return hostName.toLowerCase().replace(/[^a-z0-9-]+/g,'_');
+    }
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@metric-im/administrate",
+  "version": "1.0.0",
+  "description": "Tools for site administration",
+  "homepage": "https://github.com/metric-im/administrate#readme",
+  "bugs": {
+    "url": "https://github.com/metric-im/administrate/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/metric-im/administrate.git"
+  },
+  "license": "MIT",
+  "author": "Michael Sprague",
+  "type": "commonjs",
+  "main": "index.mjs",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "@metric-im/componentry": "^1.4.4",
+    "acme-client": "^5.4.0",
+    "axios": "^1.7.0",
+    "express": "^5.1.0",
+    "ini": "^5.0.0",
+    "moment": "^2.30.1"
+  }
+}

package/synchronize.mjs

@@ -0,0 +1,137 @@
+/**
+ *  Synchronize
+ *
+ *  Open a web hook, or monitor a branch, so that the app running this
+ *  code will automatically remain in sync with the given branch of the
+ *  given repository on Github.
+ *
+ */
+import fs from 'fs';
+import express from 'express';
+import {resolve} from "path";
+import {spawn, exec} from 'child_process';
+
+export class Synchronize {
+  constructor(branch) {
+    this.repositoryPath = this.discoverRepositoryPath();
+    this.branch = branch || 'main';
+    this.appName = this.getAppName();
+  }
+
+  static attach(app,branch) {
+    const instance = new Synchronize(branch);
+    app.use('/',instance.routes());
+  }
+
+  discoverRepositoryPath() {
+    try {
+      const packageJsonPath = resolve(process.cwd(), 'package.json');
+      if (fs.existsSync(packageJsonPath)) {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        if (packageJson.repository) {
+          return process.cwd();
+        }
+      }
+    } catch (error) {
+      console.warn('Could not find repository path:', error.message);
+    }
+    return process.cwd(); // fallback to current directory
+  }
+
+  getAppName() {
+    try {
+      const packageJsonPath = resolve(this.repositoryPath || process.cwd(), 'package.json');
+      if (fs.existsSync(packageJsonPath)) {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        return packageJson.name;
+      }
+    } catch (error) {
+      console.warn('Could not extract app name from package.json:', error.message);
+    }
+
+    // Fallback: extract from repository path or current directory
+    const repoPath = this.repositoryPath || process.cwd();
+    return repoPath.split('/').pop();
+  }
+
+  routes() {
+    const router = new express.Router();
+    router.get(/^\/_update/, async (req, res) => {
+      try {
+        await this.update();
+        res.json({success: true, message: 'Update completed successfully'});
+      } catch (error) {
+        res.status(500).json({success: false, error: error.message});
+      }
+    });
+    return router;
+  }
+  async update() {
+    console.log(`Starting deployment update for ${this.repositoryPath} on branch ${this.branch}`);
+
+    try {
+      // Pull latest changes from GitHub
+      await this.executeCommand('git', ['fetch', 'origin', this.branch]);
+      await this.executeCommand('git', ['reset', '--hard', `origin/${this.branch}`]);
+
+      // Install/update dependencies
+      await this.executeCommand('npm', ['install']);
+
+      // Restart the service using systemctl
+      console.log(`Restarting service: ${this.appName}`);
+      await this.executeCommand('sudo', ['systemctl', 'restart', this.appName]);
+
+      console.log('Deployment update completed successfully');
+    } catch (error) {
+      console.error('Deployment update failed:', error.message);
+      throw error;
+    }
+  }
+
+  executeCommand(command, args) {
+    return new Promise((resolve, reject) => {
+      console.log(`Executing: ${command} ${args.join(' ')}`);
+      const process = spawn(command, args, {
+        stdio: 'inherit',
+        cwd: this.repositoryPath || process.cwd()
+      });
+
+      process.on('close', (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`Command "${command} ${args.join(' ')}" failed with exit code ${code}`));
+        }
+      });
+
+      process.on('error', (error) => {
+        reject(error);
+      });
+    });
+  }
+  static async ActiveBranch() {
+    return new Promise((resolve, reject) => {
+      exec('git branch --show-current', (error, stdout, stderr) => {
+        if (error) {
+          console.error(`Error executing git command: ${error.message}`);
+          resolve()
+        }
+        if (stderr) {
+          console.error(`Git stderr: ${stderr}`);
+          resolve()
+        }
+        resolve(stdout.trim());
+      });
+    });
+  }
+  static get Package() {
+    if (!Syncrhonize._Package) {
+      let text = fs.readFileSync(resolve('./package.json'), 'utf8');
+      Syncrhonize._Package = JSON.parse(text.toString())
+    }
+    return Syncrhonize._Package;
+  }
+  static get Version() {
+    return Synchronize.Package.version;
+  }
+}