iosignal-cli 1.0.0

package/README.md

@@ -0,0 +1,198 @@
+# IOSignal CLI
+
+iosignal-cli program that makes it simple to run a iosignal server and client. It uses the [iosignal](https://www.npmjs.com/package/iosignal)  library and uses Redis for authentication database functionality.
+
+## supports 
+Windows, Mac, and Linux.
+
+## install
+Linux, Mac and shell
+```sh
+# global install.
+$ npm install -g iosignal-cli
+
+# If NO Permissioin error, use sudo prefix.
+$ sudo npm install -g iosignal-cli
+```
+windows as admin permission
+```sh
+# global install.
+$ npm install -g iosignal-cli
+```
+
+
+## IOSignal server
+
+```sh
+$ io-server
+# start server with default option.
+# default. open port 7777 with WebSocket. 
+
+
+$ io-server -l 5555 
+# you can specify listen port number
+
+$ io-server -l 0 -L 5555
+# use number 0 to disable WebSocket service.
+
+```
+
+## iosignal client
+
+
+```sh
+$ io # or io alias
+# connect to localhost:7777 with websocket.
+
+# use -c to define websocket url and port number.
+$ io -c wss://websocket_server_url:port
+$ io -c ws://localhost:7777
+
+# support ws or wss(TLS).
+
+```
+
+## iosignal commands
+
+- subscribe('tag')
+- publish('tag', message ) 
+- signal('tag', message )  // same with publish
+- not ready whole document.
+
+## tutorial 
+
+### signaling 
+
+- multi-cast: publish/subscribe channel_name
+- uni-cast: use cid(communication id)
+
+1. start server
+```sh
+$ io-server  # alias ios
+
+```
+
+2. start client A.
+
+```sh
+$ io
+Connecting to ws://localhost:7777
+ready:  cid: ?c3Nr 
+# connected and receive client cid.
+# CID(Communicaion Id of the io client.)
+
+> .subscribe channel_name  
+# subscribe some channel
+```
+
+3. start client B.
+```sh
+$ io
+Connecting to ws://localhost:7777
+ready:  cid: ?rr75
+> 
+# connected and received cid.
+
+# multicast.
+> .signal channel_name some_message   
+
+# unicast to A.
+> .signal ?c3Nr@ direct_message  
+# IMPORTANT. 
+# unicast signal tag must include '@' charactor.  tag = 'cid' + @
+```
+
+### authentication
+
+#### type1. auth data from file.
+
+- for personal use only
+- raw plain password string. (Not Hashed)
+- each device have 4 values: `deviceId`, `deviceKey`, `deviceCId`, `level`
+- you can find sample auth_file.mjs and auth_file.json in root folder.
+```sh
+$ io-server -d auth_file.json
+   or
+$ io-server -d auth_file.mjs
+```
+
+auth_file.json structure
+- deviceId string size limit: 8 charactors.
+- No passphrase string limit. (It will be digested 32bytes with sha256.)
+- CID string size limit: current 20 chars. can be changed.
+- JSON file does not support comment.
+```js
+[
+  ["id","key","cid",0],
+  ["did2","did2key","did2-cid",0],
+  ["uno3","uno3-key","uno3-cid",1]
+]
+```
+
+### auth_file.mjs 
+- support comments.
+
+```js
+// *.mjs file support comments.
+export const authInfo = [
+  // device id, key, communication id, level:Number(0~255)
+  ["did","passowrd","cid",0],  
+  ["device1","device1_key","device1_cid",0],
+  ["root","root-key","root-cid",255],  // default admin_root level is 255
+  ["uno","uno-key","uno",1]
+]
+```
+
+
+
+#### type2. auth data from Redis(or other DataBase)
+- Recommended
+- you can find source and examples here.
+  - `iosiganl` "/src/auth/"
+  - `iosignal-cli` "/test_auth_redis/"
+
+Before running the server, you need to make sure that your Redis server is up and running and that you have registered your device credentials. A simple credentials enrollment example is included in the source above.
+
+start server with local redis-auth-system
+```sh
+$ io-server -r   //  redis://localhost:6379
+```
+
+
+#### auth client
+1. start auth server.
+2. connect and login
+
+```sh
+$ io
+ready:  cid: ?YXDr
+> .login uno3 uno3-key
+try manual login:  uno3
+> >> QUOTA_LEVEL :  1
+current quota: {"signalSize":255,"publishCounter":10,"trafficRate":100000}
+ready:  cid: uno3-cid
+ 
+# now device have (pre-registered) CID.
+
+```
+
+## Support for both web browsers and Arduino
+### Specifying two types of ports
+IOSignal uses websockets for web browser peer connections. If you want to use an Arduino connection, you must specify the use of the CongSocket port using the -L option.
+
+The -l option specifies the Websocket port, and the -L option specifies the CongSocket port for the Arduino.
+
+```sh
+
+$ io-server -l 7777 -L 8888
+# -l option for WebSocket port
+# -L option for CongSocket port ( Arduino connection)
+```
+
+### IOSignal Arduino Library
+
+Search for `IOSignal` in the Arduino library manager and install it, or see the [`iosignal-arduino`](https://github.com/remocons/iosignal-arduino) github repository
+
+
+## iosignal stack
+![IOSignal](./img/iosignal_stack.png)

package/bin/getVersion.js

@@ -0,0 +1,9 @@
+import { readFile } from 'fs/promises';
+
+const json = JSON.parse(
+  await readFile(
+    new URL('../package.json', import.meta.url)
+  )
+);
+
+export let version = json.version

package/bin/io-client.js

@@ -0,0 +1,400 @@
+#!/usr/bin/env node
+
+import { IO, IOCongSocket, ENC_MODE, serverOption } from 'iosignal'
+import { EventEmitter } from 'events'
+import readline from 'readline'
+import tty from 'tty'
+import { program } from 'commander'
+import { version } from './getVersion.js'
+
+class Console extends EventEmitter {
+  constructor() {
+    super()
+
+    this.showIncommingMessage = true
+    this.stdin = process.stdin
+    this.stdout = process.stdout
+    this.stderr = process.stderr
+
+    this.readlineInterface = readline.createInterface(this.stdin, this.stdout)
+
+    this.readlineInterface
+      .on('line', (data) => {
+        this.emit('line', data)
+      })
+      .on('close', () => {
+        this.emit('close')
+      })
+
+    this._resetInput = () => {
+      this.clear()
+    }
+  }
+
+  static get Colors() {
+    return {
+      Red: '\u001b[31m',
+      Green: '\u001b[32m',
+      Yellow: '\u001b[33m',
+      Blue: '\u001b[34m',
+      Default: '\u001b[39m'
+    }
+  }
+
+  static get Types() {
+    return {
+      Incoming: '< ',
+      Control: '',
+      Error: 'error: ',
+      Put: '.'
+    }
+  }
+
+  prompt() {
+    this.readlineInterface.prompt(true)
+  }
+
+  print(type, msg, color) {
+    if (tty.isatty(1)) {
+      this.clear()
+
+      // if (options.execute) color = type = '';
+      // else if (!options.color) color = '';
+
+      this.stdout.write(color + type + msg + Console.Colors.Default + '\n')
+      this.prompt()
+    } else if (type === Console.Types.Incoming) {
+      this.stdout.write(msg + '\n')
+    } else if (type === Console.Types.Error) {
+      this.stderr.write(type + msg + '\n')
+    } else if (type === Console.Types.Put) {
+      // this.stdout.write( '.' )
+    } else {
+      // is a control message and we're not in a tty... drop it.
+    }
+  }
+
+  clear() {
+    if (tty.isatty(1)) {
+      this.stdout.write('\r\u001b[2K\u001b[3D')
+    }
+  }
+
+  pause() {
+    this.stdin.on('keypress', this._resetInput)
+  }
+
+  resume() {
+    this.stdin.removeListener('keypress', this._resetInput)
+  }
+}
+
+function noop() { }
+
+program
+  .version(version)
+  .usage('[options] (--connect <url> )')
+  .option('-t, --timeout <milliseconds>', 'ping period & timeout')
+  .option('-s, --show-message <none|message|frame>', 'show receive message. ')
+  .option('-c, --connect <url>', 'connect to a server')
+  .option('-i, --id <id>', 'userId')
+  .option('-k, --key <key>', 'userKey')
+  .option('-a, --auth-idKey <idkey>', 'auth id.key')
+  .option('-j, --join-channel <channelName>', 'join to channel')
+  .parse(process.argv)
+
+const options = program.opts()
+
+console.log(options)
+
+
+if (!options.connect) {
+  options.connect = 'localhost:' + serverOption.port;
+}
+
+
+const wsConsole = new Console()
+
+let connectUrl = options.connect
+// console.log('connectUrl raw', connectUrl )
+
+let io;
+
+
+if (connectUrl.indexOf('cong') === 0) {
+  //use TCP connection
+  io = new IOCongSocket(connectUrl)
+} else { // ws connection
+  if (!connectUrl.match(/\w+:\/\/.*$/i)) {
+    connectUrl = `ws://${connectUrl}`
+  }
+  io = new IO(connectUrl)
+}
+
+if (options.id && options.key) {
+  io.auth(options.id, options.key)
+} else if (options.authIdKey) {
+  io.auth(options.authIdKey)
+}
+
+
+io.listen('@', (...args) => {
+  console.log('rcv @', args)
+})
+
+if (options.joinChannel) {
+  console.log('options joinchannel', options.joinChannel)
+  io.channels.add(options.joinChannel)
+
+}
+
+
+wsConsole.print(Console.Types.Control, `Connecting to ${connectUrl}`, Console.Colors.Yellow)
+
+io.on('@pong', (...data) => {
+  wsConsole.print(
+    Console.Types.Control,
+    `>> receive pong from ${data[0]}`,
+    Console.Colors.Yellow)
+})
+
+io.on('ready', () => {
+  wsConsole.print(
+    Console.Types.Control,
+    `ready:  cid: ${io.cid}`,
+    Console.Colors.Green)
+})
+
+io.on('close', () => {
+  wsConsole.print(Console.Types.Control, `closed`, Console.Colors.Yellow)
+})
+
+
+io.on('authorized', () => {
+  wsConsole.print(
+    Console.Types.Control,
+    `Boho authorized. TLS: ${io.TLS}`,
+    Console.Colors.Yellow)
+})
+
+io.on('auth_fail', () => {
+  wsConsole.print(
+    Console.Types.Control,
+    `Boho auth_fail.`,
+    Console.Colors.Yellow)
+})
+io.on('over_size', () => {
+  wsConsole.print(
+    Console.Types.Control,
+    `OVER_SIZE: your signalSize limit is: ${io.quota.signalSize}`,
+    Console.Colors.Yellow)
+})
+
+
+io.on('message', (data, isBinary) => {
+
+  let moreBytesIndicator = ""
+  if (isBinary) {
+    let buffer
+    const displayBufferLimit = 20
+    if (data.byteLength > displayBufferLimit) {
+      buffer = Buffer.from(data, 0, displayBufferLimit);
+      moreBytesIndicator = "..."
+    } else {
+      buffer = Buffer.from(data);
+    }
+
+    let prn = `${buffer.toString('hex')}${moreBytesIndicator} [${data.byteLength} bytes total]`;
+    if (wsConsole.showIncommingMessage) wsConsole.print(Console.Types.Incoming, `rx: bin [hex] ${prn}`, Console.Colors.Green)
+
+  } else {
+    if (wsConsole.showIncommingMessage) wsConsole.print(Console.Types.Incoming, `rx: text: ${data}`, Console.Colors.Green)
+  }
+})
+
+// to send frame message.
+wsConsole.on('line', (data) => {
+  if (data[0] === '.') {
+    const toks = data.split(/\s+/)
+    const cmd = toks[0].substring(1)
+    let ch = ""
+    switch (cmd) {
+      case 'login':
+        toks.shift()
+        io.login(...toks)
+        break;
+      case 'auth':
+        toks.shift()
+        io.auth(...toks)
+        break;
+
+      case 'encNo':
+        io.encMode = ENC_MODE.NO
+        wsConsole.print(Console.Types.Incoming, `encMode: ${ENC_MODE[io.encMode]}`, Console.Colors.Green)
+        break;
+      case 'encYes':
+        io.encMode = ENC_MODE.YES
+        wsConsole.print(Console.Types.Incoming, `encMode: ${ENC_MODE[io.encMode]}`, Console.Colors.Green)
+        break;
+      case 'encAuto':
+        io.encMode = ENC_MODE.AUTO
+        wsConsole.print(Console.Types.Incoming, `encMode: ${ENC_MODE[io.encMode]}`, Console.Colors.Green)
+        break;
+      case 'encMode':
+        wsConsole.print(Console.Types.Incoming, `encMode: ${ENC_MODE[io.encMode]}`, Console.Colors.Green)
+        break;
+
+      case 'echo':
+        io.echo(toks[1])
+        break;
+
+      case 'iam':
+        io.iam(toks[1])
+        break;
+
+      case 'id':
+        console.log(`cid: ${io.cid} level: ${io.level}`)
+        break;
+
+      case 'sudo':
+        toks.shift()
+        console.log('sudo toks', toks)
+        io.req('sudo', ...toks).then(res => {
+          if (res.ok) {
+            console.log('>> sudo response:', res.body)
+          } else {
+            console.log('>> sudo response:', res.body)
+          }
+        }).catch(err => {
+          console.log('sudo call err', err)
+        })
+
+        break;
+
+
+      case 'quota':
+        console.log(`quota: ${JSON.stringify(io.quota)}`)
+        break;
+
+      case 'ch':
+        let chList = []
+        io.channels.forEach(v => {
+          chList.push(v)
+        })
+        console.log(`channels: ${chList.toString()}`)
+        break;
+
+      case 'sig':
+      case 'signal':
+        toks.shift()
+        io.signal(...toks)
+        break;
+
+      case 'sig_bin':
+        toks.shift()
+        let to = toks[0]
+        let size = parseInt(toks[1])
+        console.log(`signal tag: ${to} size: ${size}`)
+        io.signal(to, new Uint8Array(size))
+        break;
+
+      case 'pub':
+      case 'publish':
+        toks.shift()
+        io.publish(...toks)
+        break;
+
+      case 'set':
+        io.set(toks[1])
+        break;
+
+      case 'api':
+      case 'req':
+        toks.shift()
+        if (toks.length < 2) {
+          wsConsole.print(
+            Console.Types.Error,
+            '[.req need at least two params]  req target command [, ..args]',
+            Console.Colors.Yellow
+          )
+          return
+        }
+        io.req(...toks).then(result => {
+          console.log('>> response:', result)
+        }).catch(e => {
+          console.log(e)
+        })
+        break;
+
+      case 'join':
+      case 'sub':
+      case 'subscribe':
+      case 'listen':
+        toks.shift()
+        let tag = toks[0]
+        console.log('listen tag', tag)
+        io.listen(tag, (...args) => {
+          console.log(`subscribe & listen  tag: ${tag} args:`, args)
+
+        })
+        io.subscribe_memory_channels()
+        break;
+
+
+      case 'unsub':
+        io.unsubscribe(toks[1]);
+        break;
+
+      case 'pping':
+        io.signal(toks[1] + "@ping", io.cid)
+        break;
+      case 'ping':
+        io.ping()
+        break;
+
+      case 'pong':
+        io.pong()
+        break
+
+      case 'close':
+        io.close()
+        break
+
+      case 'open':
+      case 'connect':
+        if (toks[1]) {
+          let url = toks[1]
+          if (!url.match(/\w+:\/\/.*$/i)) {
+            url = `ws://${url}`
+          }
+          io.open(url) // new url
+        } else {
+          io.open()  // last url
+        }
+        break
+      case 'show':
+        wsConsole.showIncommingMessage = true
+        break;
+      case 'hide':
+        wsConsole.showIncommingMessage = false
+        break;
+      case 'quit':
+      case 'exit':
+        process.exit();
+      default:
+        wsConsole.print(
+          Console.Types.Error,
+          'command list: .signal .sig .listen .publish .pub .subscribe .sub .unsub .ping .pong .id .iam .open .connect .close .login .auth .quit .exit',
+          Console.Colors.Yellow
+        )
+    }
+  } else {
+  }
+  wsConsole.prompt()
+})
+
+
+
+
+
+

package/bin/io-keygen.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+import { RAND } from 'iosignal'
+
+// base64 from random n-byte 
+function rand_b64(srcByteSize) {
+  return RAND(srcByteSize).toString('base64')
+}
+
+// accept 1 ~ 12
+function rand_number_string(len) {
+  if (len > 12) throw new RangeError("Member: rand_number range is over.")
+
+  let bigNumberBuffer, n, nString;
+  const cropFrom = 1;
+  do {
+    bigNumberBuffer = RAND(8);
+    n = bigNumberBuffer.readBigUInt64LE(0);
+    nString = n.toString()
+    // console.log('>', n )
+  } while ((n < 2 ** 44) || nString[cropFrom] == '0')  // 44-> 14digit.
+
+  nString = nString.substring(cropFrom, len + cropFrom)
+  return nString
+}
+
+
+let key20 = rand_b64(15)
+let did4 = rand_b64(3)
+let did8 = rand_b64(6)
+let randNumber4 = rand_number_string(4)
+let randNumber8 = rand_number_string(8)
+// console.log('rand number 8chars', rand_number_string(8) )
+// console.log('random 15bytes as base64 20chars: ', key )
+// console.log('random 3bytes as base64 4chars: ', did )
+
+console.log('\n random values')
+console.log('+------------------------------------+')
+console.log('| ID:', did4, ' KEY:', key20)
+console.log('+------------------------------------+')
+console.log('| ID_KEY: ', did4 + '.' + key20)
+console.log('+------------------------------------+')
+console.log('| numbers: ', randNumber4, randNumber8)
+console.log('+------------------------------------+')
+console.log('')

package/bin/io-server.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+
+import {
+  Server, serverOption, Auth_File, Auth_Env, Auth_Redis,
+  api_reply, api_sudo, RedisAPI
+} from 'iosignal'
+import { createClient } from 'redis';
+import { program } from 'commander'
+import { version } from './getVersion.js'
+
+program
+  .version(version)
+  .usage('[options] (--listen <port> )')
+  .option('-l, --listen <port>', 'listen on port (start WebSocket Server)')
+  .option('-L, --listen-congport <port>', 'listen on cong port (start CongSocket Server)')
+  .option('-d, --auth-file <path>', 'auth data file path')
+  .option('-e, --auth-param <id.key.level>', 'auth data from argument: id.key.level,id2.key2.level2')
+  .option('-E, --auth-env', 'auth data from shell env BOHO_AUTH')
+  .option('-r, --auth-redis', 'connect to redis. if exist use env REDIS_HOST, REDIS_PORT or localhost:6379')
+  .option('-t, --timeout <milliseconds>', 'ping period & timeout')
+  .option('-m, --metric <type>', 'show metric <number> 1:traffic, 2:echo')
+  .option('-s, --show-message <none|message|frame>', 'show receive message. ')
+  .option('-f, --file-logger', 'write log files.')
+  .option('-a, --api-list [list...]', 'one or multiple api names:  -a api_1 api_2 ')
+  .option('-o, --show-options', 'show server init options.')
+  .parse(process.argv)
+
+const options = program.opts()
+
+
+if (options.fileLogger) {
+  serverOption.fileLogger.connection.use = true;
+  serverOption.fileLogger.auth.use = true;
+  serverOption.fileLogger.attack.use = true;
+}
+
+if (options.listen) {
+  serverOption.port = options.listen
+}
+
+if (options.listenCongport) {
+  serverOption.congPort = parseInt(options.listenCongport)
+}
+
+if (options.showMessage) {
+  serverOption.showMessage = options.showMessage
+}
+
+if (options.metric) {
+  serverOption.showMetric = options.metric
+}
+
+if (options.timeout) {
+  serverOption.timeout = options.timeout
+}
+
+
+let authManager;
+let redisClient;
+
+if (options.authFile) {
+  console.log("auth data origin: auth_file")
+  let authFilePath = options.authFile;
+  authManager = new Auth_File(authFilePath)
+} else if (options.authParam) {
+  authManager = new Auth_Env(options.authParam)
+} else if (options.authEnv) {
+  authManager = new Auth_Env()
+} else if (options.authRedis) {
+  console.log("auth data origin: redis")
+  // console.log('####### default redis server url: redis://localhost:6379 ' )   
+  redisClient = createClient();
+  redisClient.on('error', (err) => console.log('Redis Client Error', err));
+  redisClient.connect();
+  authManager = new Auth_Redis(redisClient)
+} else {
+  console.log("No authentication support.")
+
+}
+
+
+const server = new Server(serverOption, authManager)
+
+if (options.apiList && options.apiList.length > 0) {
+  let apiList = options.apiList
+  console.log('api list', apiList)
+  if (apiList.includes('reply')) server.api('reply', api_reply)
+  if (apiList.includes('sudo')) server.api('sudo', api_sudo)
+  if (apiList.includes('redis')) server.api('redis', new RedisAPI(redisClient))
+
+}
+
+if (options.showOptions) {
+  console.log('ServerOptions:', serverOption)
+  console.log('server api list', server.apiNames)
+}
+
+
+

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "iosignal-cli",
+  "version": "1.0.0",
+  "description": "IOSignal server and client CLI program.",
+  "type": "module",
+  "bin": {
+    "io-server": "./bin/io-server.js",
+    "io-client": "./bin/io-client.js",
+    "ios": "./bin/io-server.js",
+    "io": "./bin/io-client.js",
+    "io-keygen": "./bin/io-keygen.js"
+  },
+  "author": {
+    "name": "Lee Dongeun",
+    "email": "sixgen@gmail.com"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^11.1.0",
+    "iosignal": "^1.0.0",
+    "meta-buffer-pack": "^1.3.1",
+    "redis": "^4.6.12"
+  }
+  ,
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/remocons/iosignal-cli.git"
+  },
+  "homepage": "https://iosignal.net",
+  "keywords": [
+    "io","pubsub","arduino","iot","auth","signal","CLI","remocon"
+  ]
+}

package/test_auth_redis/redis_addAdmin.js

@@ -0,0 +1,32 @@
+import { Auth_Redis } from 'iosignal'
+import { createClient  } from 'redis';
+
+let redisClient = createClient();
+redisClient.on('error', (err) => console.log('Redis Client Error', err));
+redisClient.connect();
+
+let auth = new Auth_Redis( redisClient)
+
+//addUSer(did,dkey,cid,level)
+if( process.argv.length != 5 ){
+  console.log('=> $ node addAdmin.js id key cid')
+  process.exit()
+}
+
+let did = process.argv[2] 
+let dkey = process.argv[3]
+let cid = process.argv[4] 
+
+let addResult = await auth.addAuth( did, dkey, cid ,255)
+let getResult = await auth.getAuth( did )
+let saveResult = await auth.save();
+
+console.log('add',addResult )
+console.log('get',getResult)
+console.log('data.key',getResult.key)
+console.log('save result', saveResult)
+
+process.exit()
+
+
+

package/test_auth_redis/redis_addMultipleDevice.js

@@ -0,0 +1,29 @@
+import { Auth_Redis } from 'iosignal'
+import { createClient  } from 'redis';
+
+let redisClient = createClient();
+redisClient.on('error', (err) => console.log('Redis Client Error', err));
+redisClient.connect();
+
+let auth = new Auth_Redis( redisClient)
+
+// node filename base_id level number
+// node uno 1 10
+//addUSer(did,dey,cid,level)
+let baseId = process.argv[2] ? process.argv[2] : 'uno'
+let level = process.argv[3] ? process.argv[3] : 1;
+let n = process.argv[4] ? process.argv[4] : 10;
+
+console.log( baseId, n )
+for(let i=0; i< n ;i++){
+  let id = baseId + i;
+  let addResult = await auth.addAuth( id, id, id ,level)
+  console.log('add',addResult )
+}
+
+await auth.save();
+
+process.exit()
+
+
+

package/test_auth_redis/redis_add_get_device.js

@@ -0,0 +1,24 @@
+import { Auth_Redis } from 'iosignal'
+import { createClient  } from 'redis';
+
+let redisClient = createClient();
+redisClient.on('error', (err) => console.log('Redis Client Error', err));
+redisClient.connect();
+
+let auth = new Auth_Redis( redisClient)
+
+//addUSer(did,dey,cid,level)
+let addResult = await auth.addAuth('uno','uno','uno',1)
+let getResult = await auth.getAuth('uno')
+let wrongResult = await auth.getAuth('noid')
+
+console.log('add',addResult )
+console.log('get',getResult)
+console.log('data.key',getResult.key)
+console.log('wrongResult',wrongResult)
+console.log('wrongResult.key',wrongResult?.key)
+
+process.exit()
+
+
+

package/test_auth_redis/server-Auth_Redis.js

@@ -0,0 +1,12 @@
+import { Auth_Redis , serverOption , Server } from 'iosignal'
+import { createClient  } from 'redis';
+
+let redisClient = createClient();
+redisClient.on('error', (err) => console.log('Redis Client Error', err));
+redisClient.connect();
+
+let authManager = new Auth_Redis( redisClient)
+
+serverOption.showMessage = 'message';
+const server = new Server( serverOption ,authManager  )
+console.log( 'serverOption:', serverOption )