@knowlearning/agents 0.3.16 → 0.3.18

package/agents/generic.js

@@ -1,5 +1,7 @@
 import MutableProxy from '../persistence/json.js'
 
+const HEARTBEAT_TIMEOUT = 10000
+
 //  transform our custom path implementation to the standard JSONPatch path
 function standardJSONPatch(patch) {
   return patch.map(p => {
@@ -34,6 +36,8 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
   let failedConnections = 0
   let mode = 'normal'
   const environmentPromise = new Promise(r => resolveEnvironment = r)
+  let lastSentSI = -1
+  let lastHeartbeat
 
   const sessionData = new MutableProxy({}, patch => queueMessage({scope: 'sessions', patch}))
 
@@ -44,6 +48,9 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
     patches: {}
   }
 
+  log('INITIALIZING AGENT CONNECTION')
+  initWS()
+
   function log() {
     if (mode === 'debug') console.log(...arguments)
   }
@@ -53,11 +60,6 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
     if (watcherIndex > -1) watchers[key].splice(watcherIndex, 1)
     else console.warn('TRIED TO REMOVE WATCHER THAT DOES NOT EXIST')
   }
-
-  log('INITIALIZING AGENT CONNECTION')
-  initWS()
-
-  let lastSentSI = -1
   function flushMessageQueue() {
     //  TODO: probably want to make this loop async so we don't try and push more to
     //        a closed connection
@@ -78,16 +80,43 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
     flushMessageQueue()
   }
 
+  function checkHeartbeat() {
+    clearTimeout(lastHeartbeat)
+    lastHeartbeat = setTimeout(
+      () => {
+        log('CLOSING DUE TO HEARTBEAT TIMEOUT')
+        restartConnection()
+      },
+      HEARTBEAT_TIMEOUT
+    )
+  }
+
+  async function restartConnection() {
+    if (authed) log(`CLOSED DOMAIN ${domain} USER ${user} SESSION ${session} CONNECTION TO SERVER ${server}`)
+    authed = false
+    ws.onmessage = () => {} // needs to be a no-op since a closing ws can still get messages
+    if (!disconnected) {
+      await new Promise(r => setTimeout(r, Math.min(1000, failedConnections * 100)))
+      failedConnections += 1
+      initWS() // TODO: don't do this if we are purposefully unloading...
+    }
+  }
+
   function initWS() {
     ws = new WebSocket(`${protocol}://${host}`)
 
+    let opened = false
     ws.onopen = async () => {
+      opened = true
       log('AUTHORIZING NEWLY OPENED WS FOR SESSION:', session)
       failedConnections = 0
       ws.send(JSON.stringify({ token: await token(), session }))
     }
 
     ws.onmessage = async ({ data }) => {
+      checkHeartbeat()
+      if (data.length === 0) return // heartbeat
+
       try {
         log('handling message', disconnected, authed)
         const message = JSON.parse(data)
@@ -151,19 +180,16 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
     }
 
     ws.onerror = async error => {
-      log('WS CONNECTION ERROR', error.message)
+      log('WS CONNECTION ERROR', error.message, opened)
+      if (!opened) restartConnection() // onclose won't trigger if never opened
     }
 
-    ws.onclose = async () => {
-      if (authed) log(`CLOSED DOMAIN ${domain} USER ${user} SESSION ${session} CONNECTION TO SERVER ${server}`)
-      authed = false
-      ws.onmessage = () => {} // needs to be a no-op since a closing ws can still get messages
-      if (!disconnected) {
-        await new Promise(r => setTimeout(r, Math.min(1000, failedConnections * 100)))
-        failedConnections += 1
-        initWS() // TODO: don't do this if we are purposefully unloading...
-      }
+    ws.onclose = async error => {
+      log('WS CLOSURE', error.message, opened)
+      restartConnection()
     }
+
+    checkHeartbeat()
   }
 
   function environment() { return environmentPromise }
@@ -205,7 +231,7 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
       //        POSSIBLE: wait for most recent interaction update response for key k that we sent...
       await lastInteractionUpdateForWatchedScope[k]
       //  TODO: probably something like await updateMessageReceivedForLastInteractionWeSentForKey[k]
-      resolveState(states[k])
+      resolveState(structuredClone(await states[k]))
     })
 
     promise.watch = fn => {

package/agents/node.js

@@ -14,5 +14,5 @@ export default () => new Agent({
   uuid,
   fetch,
   applyPatch: fastJSONPatch.applyPatch,
-  reboot: () => process.exit()
+  reboot: () => process.exit(1)
 })

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@knowlearning/agents",
-    "version": "0.3.16",
+    "version": "0.3.18",
     "description": "API for embedding applications in KnowLearning systems.",
     "main": "node.js",
     "browser": "browser.js",