godprotocol 1.2.18 → 1.2.20

package/Objects/Manager.js

@@ -353,6 +353,45 @@ class Manager {
     return create_serv;
   }
 
+  get_init = async()=>{
+    let acc = this.init_account;
+
+    if (!acc && this.options.init_account) {
+      acc = await this.add_account(this.options.init_account.name, {password: this.options.init_account.password, init: true})
+    }
+
+    return acc;
+  }
+
+  get_from_repo = async(address, options={}) =>{
+    let acc = this.get_acc(options)
+
+    address = `.storage/${acc}/${address}/__literal__`
+    let content = await this.oracle.get_from_repos(address, {count: 1, args: options})
+
+    return content && JSON.parse(content)
+  }
+
+  get_acc = options=>{
+    let acc = options.account
+    if (!acc){
+      acc = this.options.init_account
+      if (!acc) return
+      acc = `Accounts/${acc.name}`
+    }
+
+    return acc;
+  }
+
+  set_to_repo =  async(address, content, options={}) =>{
+    let acc = this.get_acc(options)
+
+    address = `.storage/${acc}/${address}/__literal__`
+    let response = await this.oracle.set_to_repos(address, JSON.stringify(content), {count: 1, args: options})
+
+    return response
+  }
+
   get_account = async(name) => {
     let acc = this.accounts[name]
     if (!acc){

package/Objects/Oracle.js

@@ -3,356 +3,297 @@ import Github from "godprotocol/repos/github.js";
 import Handlers from "godprotocol/utils/oracle_handlers.js";
 import { post_request } from "godprotocol/utils/services.js";
 
-class Oracle extends Handlers{
+class Oracle extends Handlers {
   constructor(server, mirror) {
     super();
 
-    this.server = server
+    this.server = server;
     this.mirror = mirror;
-    this.repos = new Array()
-    this.remotes = new Array()
+    this.repos = new Array();
+    this.remotes = new Array();
+
+    this.account_repos = new Object();
   }
 
-  add_repo = async (repository)=>{
-    let {filter, repo} = repository
-    if (await this.get_repo(repo.type, repo.options.name))
-      return;
+  fetch = async (payload, server) => {
+    let response;
+    try {
+      response = await post_request({
+        options: {
+          ...server,
+          path: "/oracle",
+        },
+        data: JSON.stringify(payload),
+      });
+    } catch (e) {}
 
-    switch(repo.type){
-      case 'fs':
-        repo = new Fs(repo.options)
-        break
-      case 'github':
-        repo = new Github(repo.options)
-        break
-    }
-    this.repos.push({filter, repo})
+    return response;
+  };
 
-    if(!this.manager) return;
-    if (this.server_match(this.manager.server, this.server)){
-      for (let r=0; r< this.remotes.length; r++){
-        let remote = this.remotes[r]
+  call = async (payload) => {
+    let { method, args } = payload;
 
-        await this.fetch({
-          method: 'add_repo',
-          arg: {...repo}
-        }, remote)
-      }
-    } else {
-      await this.fetch({
-        method: 'add_repo',
-        arg: {...repo}
-      }, this.server)
-    }
-  }
+    switch (method) {
+      case "update_server":
+        let { repos, account, server } = args;
 
-  call = async(payload)=>{
-    let {method, arg} = payload, result = {};
-
-    switch(method){
-      case 'update_servers':
-        let addr = `.oracle/${arg.account}/.configs`
-        let servers = await this.get_from_repos(addr)
-        if (servers){
-          servers = JSON.parse(servers)
-          if (servers.find(s=>this.server_match(s, arg.server))){
-            return
-          }
-          servers.push(arg.server)
-        }else servers = [arg.server]
-        
-        await this.set_to_repos(addr, JSON.stringify(servers))
-        break;
-      case 'update_accounts':
-        let a_addr = `.oracle/${arg.address}/.configs`
-        let accs = await this.get_from_repos(a_addr)
-        if (accs){
-          accs = JSON.parse(accs)
-          if (accs.includes(arg.account)){
-            return
-          }
-          accs.push(arg.account)
-        }else accs = [arg.account]
-        
-        await this.set_to_repos(a_addr, JSON.stringify(accs))
-        break
-      case 'get_accounts':
-        result = this.get_accounts(arg.address, true)
-        break
-      case 'get_servers':
-        result = this.get_servers(arg.account, true)
-        break
-      case 'write':
-        await this.set_to_repos(`${arg.prefix}/${arg.path}`, arg.content)
-        break;
-      case 'read':
-        let res = await this.get_from_repos(`${arg.prefix}/${arg.path}`)
-        result = {content: res}
+        let servers = await this.get_servers(account);
+        if (servers.find((serv) => this.server_match(serv, server))) return;
+        servers.push(server);
+
+        let reps = await this.set_to_repos(
+          `.oracle/${account}/.config`,
+          JSON.stringify(servers),
+          { exclude: repos }
+        );
+        await this.merge_repos([...repos, ...reps], account);
+
+        return reps;
         break;
-      case 'fs':
-        let repo = await this.get_repo('fs', arg.name)
-        result = await repo.call(arg.payload)
-        break
-      case 'sync':
-        let repos = this.string_repos()
-        await this.push_remote(arg.manager_server)
-        result = {repos}
-        break
-      case 'add_repo':
-        await this.add_repo(arg)
-        break
     }
+  };
 
-    return result
-  }
+  stringify_repos = async () => {
+    let rp = [];
+    for (let r = 0; r < this.repos.length; r++) {
+      let repo = this.repos[r];
 
-  push_remote = async(remote)=>{
-    if (this.remotes.find(rem=>this.server_match(rem, remote))) return;
+      rp.push({ repo: await repo.repo.objectify(), filter: repo.filter });
+    }
+    return rp;
+  };
 
-    this.remotes.push(remote)
-  }
+  server_match = (s1, s2) => {
+    return s1.port === s2.port && s1.hostname === s2.hostname;
+  };
 
-  string_repos = ()=>{
-    let repos = new Array();
-    for(let r=0; r< this.repos.length; r++){
-      let {filter, repo} = this.repos[r];
-      repos.push({filter, repo:{type: repo.type, options: repo.objectify()}})
+  cloth_repo = async (repo) => {
+    switch (repo.type) {
+      case "fs":
+        repo = new Fs(repo.options || repo);
+        break;
+      case "github":
+        repo = new Github(repo.options || repo);
+        break;
     }
-    return repos;
-  }
 
-  get_repo = async(type, name) => {
-    for (let r=0; r< this.repos.length; r++){
-      let {repo} = this.repos[r]
+    return repo;
+  };
 
-      if (repo.type === type && repo.name === name)
-        return repo
+  repo_object = (repos, account) => {
+    repos = [...repos];
+    let acc_repos = this.account_repos[account] || [];
+    for (let r = 0; r < repos.length; r++) {
+      let repo = repos[r];
+
+      let fnd =
+        this.repos.find((r) => r.repo.get_id() === repo) ||
+        acc_repos.find((r) => r.repo._id === repo);
+      if (fnd) {
+        if (fnd.repo.get_id) {
+          fnd.repo = fnd.repo.objectify();
+        }
+        repos[r] = fnd;
+      }
     }
-  }
 
-  fetch = async(payload, server)=>{
-    let res;
-    try{
-      res = await post_request({
-        options: {
-          ...server,
-          path: '/oracle'
-        },
-        data: JSON.stringify(payload)
-      })
-    }catch(e){
-      console.log(e)
+    return repos.filter((r) => !!r.repo);
+  };
+
+  merge_repos = async (repos, account) => {
+    let reps = Array.isArray(account) ? account : this.account_repos[account];
+    if (!reps) {
+      reps = new Array();
+      this.account_repos[account] = reps;
     }
 
-    return res;
-  }
+    for (let r = 0; r < repos.length; r++) {
+      let repo = repos[r];
+      if (reps.find((rp) => rp.repo._id === repo.repo._id)) continue;
 
-  set_to_repos = async(address, content, options)=>{
-    let {count, args} = options, counted = count != null, res;
-    for (let r=0; r< this.repos.length; r++){
-      let repo = this.repos[r]
+      repo.repo = await this.cloth_repo(repo.repo);
 
-      if (!repo.filter || address.match(repo.filter)){
-        res = await repo.repo.write_file(address, content, args)
-        if (!args.just_exists){
-          res = await repo.repo.objectify()
-        }
-        if (counted && !count) break;
-        count --
-      }
+      reps.push(repo);
     }
+    return reps;
+  };
 
-    return res;
-  }
+  get_from_repos = async (path, options = {}) => {
+    let repos = await this.parse_option_repos(options),
+      content;
 
-  get_from_repos = async(address, repo_)=>{
-    let content
-    for (let r=0; r< this.repos.length; r++){
-      let repo = this.repos[r]
-      
-      if(repo_ && repo.repo.match(repo_)){
-        content = await repo.repo.read_file(address)
-        break
-      } else if (!repo.filter || address.match(repo.filter)){
-        content = await repo.repo.read_file(address)
-        if (content) break
+    for (let r = 0; r < repos.length; r++) {
+      let repo = repos[r];
+      if (!repo.filter || path.match(repo.filter)) {
+        content = await repo.repo.read_file(path);
+        if (content) break;
       }
     }
-    return content
-  }
+    return content;
+  };
 
-  read = async(path, options={})=>{
-    let {address, account, prefix} = options;
-    prefix = prefix || '.storage'
-
-    let has = (await this.get_accounts(address)).includes(account)
-
-    if(!has) return;
-    
-    let servers = await this.get_servers(account)
-    for (let s=0; s< servers.length; s++){
-      let server = servers[s]
-      if (this.server_match(server, this.server)){
-        let res = await this.fetch({
-          method: 'read',
-          arg: {path, prefix}
-        }, server)
-        
-        if(res && res.content){
-          return res.content
-        }else break;
+  parse_option_repos = async (options) => {
+    let repos = [];
+    if (options.repos) {
+      for (let r = 0; r < options.repos[r]; r++) {
+        let rep = options.repos[r];
+        repos.push({
+          filter: rep.filter,
+          repo: await this.cloth_repo(rep.repo),
+        });
       }
-    }
-    for (let s=0; s< servers.length; s++){
-      let server = servers[s]
-      if (this.server_match(server, this.server)){
-        continue
+    } else repos = this.repos;
+
+    return repos;
+  };
+
+  set_to_repos = async (path, content, options = {}) => {
+    let { exclude } = options;
+    let repos = await this.parse_option_repos(options),
+      content,
+      reps = [];
+
+    for (let r = 0; r < repos.length; r++) {
+      let repo = repos[r];
+      if (exclude && exclude.find((e) => e._id === repo.repo.get_id())) {
+        continue;
       }
+      if (!repo.filter || path.match(repo.filter)) {
+        await repo.repo.write_file(path, content);
 
-      let res = await this.fetch({
-        method: 'read',
-        arg: {path, prefix}
-      }, server)
-      if(res && res.content){
-        return res.content
+        reps.push({ filter: repo.filter, repo: repo.repo.objectify() });
       }
     }
-  }
-
-  write = async(path, content, options={})=>{
-    let {account, address, prefix} = options
-    prefix = prefix || '.storage'
+    return reps;
+  };
 
-    await this.update_accounts(address, account)
-    let servers = await this.get_servers(account)
+  get_servers = async (account) => {
+    let servers = await this.get_from_repos(`.oracle/${account}/.config`);
+    if (servers) servers = JSON.parse(servers);
+    else servers = [];
 
-    for (let s=0; s< servers.length; s++){
-      let server = servers[s]
+    return servers;
+  };
 
-      await this.fetch({
-        method: 'write',
-        arg: {path, content, prefix}
-      }, server)
+  get_config = async (address, cache) => {
+    let conf;
+    if (cache) {
+      conf = this.configs[address];
+      if (conf) return conf;
     }
-  }
+    conf = await this.get_from_repos(`.oracle/${address}/.config`);
+    if (!conf) return;
 
-  get_servers = async(account, mirroring)=>{
-    let addr = `.oracle/${account}/.configs`
-    let servers = await this.get_from_repos(addr)
-    servers = servers ? JSON.parse(servers) : []
-
-    if(!mirroring && !servers.length && this.mirror){
-      servers = await this.fetch({
-        method: 'get_servers',
-        arg: {account}
-      }, this.mirror)
-      if (servers.length){ 
-        await this.set_to_repos(addr, JSON.stringify(servers))
-        await this.update_servers(account, [...servers])
-      }
-    }
-    return servers
-  }
+    conf = JSON.parse(conf);
+    this.configs[address] = conf;
 
-  update_servers = async(account, servers)=>{
-    servers = servers || await this.get_servers(account)
-    
-    if (servers.find(s=>this.server_match(s, this.server))){
-      return
-    }
+    return conf;
+  };
 
-    servers.push(this.server)
-    for (let s=0; s< servers.length; s++){
-      let server = servers[s]
+  dot_config = ".config";
 
-      await this.fetch({
-        method: 'update_servers',
-        arg: {account, server: this.server},
-      }, server)
-    }
+  write = async (path, content, options = {}) => {
+    let { account, address } = options;
 
-    return servers
-  }
+    if (path.endsWith(this.dot_config)) {
+      conf = await this.get_config(
+        path.slice(0, (this.dot_config.length + 1) * -1)
+      );
 
-  get_accounts = async(address, mirroring)=>{
-    let addr = `.oracle/${address}/.configs`
-    let accounts = await this.get_from_repos(addr)
-    
-    accounts = accounts ? JSON.parse(accounts) : []
-
-    if (!mirroring && !accounts.length && this.mirror){
-      accounts = await this.fetch({
-        method: 'get_accounts',
-        arg: {address}
-      }, this.mirror)
-    }
+      let conf_repos = conf ? this.repo_object(conf.repositories, account) : [];
+      let reps = this.merge_repos(conf_repos, await this.filter_repos(path));
 
-    return accounts 
-  }
+      await this.set_to_repos(
+        `.oracle/${path}`,
+        JSON.stringify({
+          ...conf,
+          content,
+          repos: reps.map((r) => r.repo._id),
+        }),
+        { repos: reps }
+      );
+    } else {
+      conf = await this.get_config(address, true);
 
-  update_accounts = async(address, account)=>{
-    let accounts = await this.get_accounts(address)
-    
-    if (accounts.includes(account)){
-      return
-    }
+      let conf_repos = conf ? this.repo_object(conf.repositories, account) : [];
+      let reps = this.merge_repos(conf_repos, await this.filter_repos(path));
 
-    accounts.push(account)
+      await this.set_to_repos(`.storage/${path}`, content, { repos: reps });
+    }
+  };
 
-    let servers = await this.get_servers_from_address(address, accounts)
+  read = async (path, options = {}) => {
+    let { account, address } = options,
+      content;
 
-    for (let s=0; s< servers.length; s++){
-      let server = servers[s]
+    if (path.endsWith(this.dot_config.length)) {
+      content = await this.get_config(
+        path.slice(0, (this.dot_config.length + 1) * -1)
+      );
+      content = content ? content.content : content;
+    } else {
+      let conf = await this.get_config(address, true);
+      let conf_repos = conf ? this.repo_object(conf.repositories, account) : [];
+      let reps = this.merge_repos(conf_repos, await this.filter_repos(path));
 
-      await this.fetch({
-        method: 'update_accounts',
-        arg: {address, account},
-      }, server)
+      content = await this.get_from_repos(`.storage/${path}`, { repos: reps });
     }
 
-    return accounts
-  }
+    return content;
+  };
 
-  get_servers_from_address = async(address, accounts)=>{
-    accounts = accounts || await this.get_accounts(address)
-
-    let servers = []
-    for (let a=0; a< accounts.length; a++){
-      let acc = accounts[a]
-      let servers_ = await this.get_servers(acc)
-      servers_.map(serv=>{
-        if(!servers.find(s=>this.server_match(s, serv)))
-          servers.push(serv)
-      })
+  update_server = async (account) => {
+    let servers = await this.get_servers(account);
+    if (servers.find((serv) => this.server_match(serv, this.server))) {
+      return;
     }
 
-    return servers
-  }
+    servers.push(this.server);
+    let repos = await this.set_to_repos(
+      `.oracle/${account}/.config`,
+      JSON.stringify(servers)
+    );
+    this.account_repos[account] = repos;
 
-  server_match = (s1, s2)=>{
-    return s1.hostname === s2.hostname && s1.port === s2.port
-  }
+    for (let s = 0; s < servers.length - 1; s++) {
+      let server = servers[s];
+
+      let reps = await this.fetch(
+        {
+          method: "update_server",
+          args: { account, repos, server: this.server },
+        },
+        server
+      );
 
-  set_manager = async(manager)=>{
-    console.log(`Manager:${manager.name} Oracle running at ${this.server.hostname}:${this.server.port}`)
+      await this.merge_repos(reps, account);
+    }
+  };
 
-    if (!this.server_match(this.server, manager.server)){
-      let response = await this.fetch({
-        method: 'sync',
-        arg: {manager_server: manager.server}
-      }, this.server)
+  filter_repos = async (address, repos) => {
+    repos = repos || this.repos;
 
-      for (let r=0; r< response.repos.length; r++){
-        let repository = response.repos[r]
+    let filtered_repos = new Array();
+    for (let r = 0; r < repos.length; r++) {
+      let repo = repos[r];
 
-        await this.add_repo(repository)
+      if (!repo.filter || address.match(repo.filter)) {
+        filtered_repos.push(repo);
       }
     }
-  }
 
-  sync = async () => {
-    
+    return filtered_repos;
   };
+
+  add_repo = async (repository) => {
+    let { filter, repo } = repository;
+    if (await this.get_repo(repo.type, repo.options.name)) return;
+
+    repo = await this.cloth_repo(repo);
+    this.repos.push({ filter, repo });
+  };
+
+  sync = async () => {};
 }
 
 export default Oracle;

package/Objects/Repository.js

@@ -1,26 +1,43 @@
-class Repository{
-  constructor(type){
+class Repository {
+  constructor(type) {
     this.type = type;
   }
 
-  objectify = ()=>{
-    let obj = {}
-    if (this.type === 'fs'){
+  objectify = () => {
+    let obj = { type: this.type };
+    if (this.type === "fs") {
       obj.name = this.name;
-      obj.remote = this.remote
-      obj.__dirname = this.__dirname
-    }else if (this.type === 'github'){
-      obj.key = this.auth_token
-      obj.username = this.owner
+      obj.remote = this.remote;
+      obj.__dirname = this.__dirname;
+      obj._id = `${this.__dirname}/${this.name}`;
+    } else if (this.type === "github") {
+      obj.key = this.auth_token;
+      obj.username = this.owner;
       obj.repo = this.repo;
+      obj._id = `${this.owner}/${this.repo}`;
     }
 
-    return obj
-  }
+    return obj;
+  };
 
-  match = async()=>{
-    return false
-  }
+  get_id = () => {
+    if (this._id) return this._id;
+
+    switch (this.type) {
+      case "fs":
+        this._id = `${this.__dirname}/${this.name}`;
+        break;
+      case "github":
+        this._id = `${this.owner}/${this.repo}`;
+        break;
+    }
+
+    return this._id;
+  };
+
+  match = async () => {
+    return false;
+  };
 }
 
-export default Repository;
+export default Repository;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "godprotocol",
-  "version": "1.2.18",
+  "version": "1.2.20",
   "description": "A distributed computing environment",
   "main": "Index.js",
   "scripts": {

package/utils/create_server.js

@@ -1,116 +1,133 @@
-import { set_page } from '../html/index.js';
-import { generate_random_string } from 'generalised-datastore/utils/functions.js';
+import { set_page } from "../html/index.js";
+import { generate_random_string } from "generalised-datastore/utils/functions.js";
 
-let PORT = Number(process.env.PORT) || 1408, account_uids = {};
+let PORT = Number(process.env.PORT) || 1408,
+  account_uids = {};
 
 export const handle_routes = async (req, res, manager, app) => {
   try {
     // CORS
-    res.setHeader('Access-Control-Allow-Origin', '*');
-    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
-    res.setHeader('Access-Control-Allow-Headers', '*');
-
-    if (req.method === 'OPTIONS') {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader(
+      "Access-Control-Allow-Methods",
+      "GET, POST, PUT, DELETE, OPTIONS"
+    );
+    res.setHeader("Access-Control-Allow-Headers", "*");
+
+    if (req.method === "OPTIONS") {
       res.writeHead(204);
       return res.end();
     }
 
     // GET pages
-    if (req.method === 'GET') {
-      if (req.url === '/') {
-        res.writeHead(200, { 'Content-Type': 'text/html' });
+    if (req.method === "GET") {
+      if (req.url === "/") {
+        res.writeHead(200, { "Content-Type": "text/html" });
         return res.end(set_page(req.url, manager));
       }
 
-      if (['/create_account', '/load', '/run', '/parse', '/oracle'].includes(req.url)) {
-        res.writeHead(200, { 'Content-Type': 'text/html' });
+      if (
+        ["/create_account", "/load", "/run", "/parse", "/oracle"].includes(
+          req.url
+        )
+      ) {
+        res.writeHead(200, { "Content-Type": "text/html" });
         return res.end(set_page(req.url.slice(1), manager));
       }
 
       // hand over untouched
-      return app ? app(req, res) : res.writeHead(404).end('Not Found');
+      return app ? app(req, res) : res.writeHead(404).end("Not Found");
     }
 
     // Only custom POST endpoints handled here
-    if (['/create_account', '/load', '/run', '/parse', '/oracle'].includes(req.url)) {
-      let body = '';
-      req.on('data', chunk => { body += chunk; });
-      await new Promise(resolve => req.on('end', resolve));
+    if (
+      ["/create_account", "/load", "/run", "/parse", "/oracle"].includes(
+        req.url
+      )
+    ) {
+      let body = "";
+      req.on("data", (chunk) => {
+        body += chunk;
+      });
+      await new Promise((resolve) => req.on("end", resolve));
 
       if (!body) {
-        res.writeHead(400, { 'Content-Type': 'application/json' });
-        return res.end(JSON.stringify({ error: 'Request body cannot be empty' }));
+        res.writeHead(400, { "Content-Type": "application/json" });
+        return res.end(
+          JSON.stringify({ error: "Request body cannot be empty" })
+        );
       }
 
       const data = JSON.parse(body);
       let result;
 
       switch (req.url) {
-        case '/create_account': {
+        case "/create_account": {
           let acc = await manager.get_account(data.name);
           if (acc) {
-            if (!await acc.verify(data.password)) {
-              result = { message: 'Incorrect password.' };
+            if (!(await acc.verify(data.password))) {
+              result = { message: "Incorrect password." };
             } else {
-              const uid = generate_random_string(16, 'alnum');
+              const uid = generate_random_string(16, "alnum");
               account_uids[uid] = data.name;
-              result = { uid, message: 'Account signed-in successfully.' };
+              result = { uid, message: "Account signed-in successfully." };
             }
           } else {
-            let newAcc = await manager.add_account(data.name, { password: data.password });
-            if (newAcc) {
-              const uid = generate_random_string(16, 'alnum');
+            let new_acc = await manager.add_account(data.name, {
+              password: data.password,
+            });
+            if (new_acc) {
+              const uid = generate_random_string(16, "alnum");
               account_uids[uid] = data.name;
-              result = { uid, message: 'Account created successfully.' };
+              result = { uid, message: "Account created successfully." };
             } else {
-              result = { message: 'Account creation failed.' };
+              result = { message: "Account creation failed." };
             }
           }
           break;
         }
 
-        case '/oracle':
+        case "/oracle":
           result = await manager.oracle.call(data);
           break;
 
-        case '/load':
-        case '/run':
-        case '/parse': {
+        case "/load":
+        case "/run":
+        case "/parse": {
           const accountName = account_uids[data.account];
           if (!accountName) {
             result = { message: `Account ${data.account} not found` };
           } else {
             const accountObj = await manager.get_account(accountName);
-            if (req.url === '/load') result = await accountObj.load(data);
-            if (req.url === '/run') result = await accountObj.run(data);
-            if (req.url === '/parse') result = await accountObj.parse(data);
+            if (req.url === "/load") result = await accountObj.load(data);
+            if (req.url === "/run") result = await accountObj.run(data);
+            if (req.url === "/parse") result = await accountObj.parse(data);
           }
           break;
         }
       }
 
-      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.writeHead(200, { "Content-Type": "application/json" });
       return res.end(JSON.stringify(result));
     }
 
     // Everything else → forward to express app
-    return app ? app(req, res) : res.writeHead(404).end('Not Found');
-
+    return app ? app(req, res) : res.writeHead(404).end("Not Found");
   } catch (err) {
-    console.error('Handler error:', err);
-    res.writeHead(500, { 'Content-Type': 'application/json' });
+    console.error("Handler error:", err);
+    res.writeHead(500, { "Content-Type": "application/json" });
     return res.end(JSON.stringify({ error: err.message }));
   }
 };
 
-
 const create_server = (settings) => {
   settings = settings || {};
   let { port, manager } = settings;
 
   port = port || PORT;
-  
-  let handler = async (req, res) => await handle_routes(req, res, manager, manager.options.app);
+
+  let handler = async (req, res) =>
+    await handle_routes(req, res, manager, manager.options.app);
 
   return handler;
 };