@knowlearning/agents 0.3.17 → 0.4.0

package/agents/browser/embed.js

@@ -95,28 +95,27 @@ export default function embed(environment, iframe) {
 
   //  TODO: make sure content security policy headers for embedded domain always restrict iframe
   //        src to only self for embedded domain
-  Agent
-    .environment()
-    .then(async ({ embed }) => {
-      iframe.onload = () => {
-        frameLoaded = true
-        processPostMessageQueue()
-      }
-      const { protocol, pathname } = window.location
-      if (validateUUID(environment.content)) {
-        //  TODO: fix development port workararounds for embed
-        if (protocol === 'http:') embed = embed.replace(':32002', ':32020')
-        iframe.src = `${protocol}//${embed}${pathname}?s=${session}`
-      }
-      else {
-        iframe.src = environment.content
-      }
+  iframe.onload = () => {
+    frameLoaded = true
+    processPostMessageQueue()
+  }
 
-      while(!embeddedAgentInitialized) {
-        postMessage({ type: 'setup', session })
-        await new Promise(r => setTimeout(r, 100))
-      }
-    })
+  setUpEmbeddedFrame()
+
+  async function setUpEmbeddedFrame() {
+    const { protocol } = window.location
+    const { id } = environment
+    if (validateUUID(id)) {
+      const { domain } = await Agent.metadata(id)
+      iframe.src = `${protocol}//${domain}/${id}`
+    }
+    else iframe.src = id //  TODO: ensure is url
+
+    while(!embeddedAgentInitialized) {
+      postMessage({ type: 'setup', session })
+      await new Promise(r => setTimeout(r, 100))
+    }
+  }
 
   function remove () {
     if (iframe.parentNode) iframe.parentNode.removeChild(iframe)

package/agents/generic.js

@@ -36,15 +36,17 @@ 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}))
+  //  TODO: probably an use "mutate" function from below
+  const subscriptions = new MutableProxy({}, patch => queueMessage({scope: 'subscriptions', patch}))
+  const uploads = new MutableProxy({}, patch => queueMessage({scope: 'uploads', patch}))
+  const downloads = new MutableProxy({}, patch => queueMessage({scope: 'downloads', patch}))
+  const patches = new MutableProxy({}, patch => queueMessage({scope: 'patches', patch}))
 
-  sessionData[session] = {
-    subscriptions: {},
-    uploads: {},
-    downloads: {},
-    patches: {}
-  }
+  log('INITIALIZING AGENT CONNECTION')
+  initWS()
 
   function log() {
     if (mode === 'debug') console.log(...arguments)
@@ -55,11 +57,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
@@ -80,23 +77,34 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
     flushMessageQueue()
   }
 
-  let lastHeartbeat
   function checkHeartbeat() {
     clearTimeout(lastHeartbeat)
     lastHeartbeat = setTimeout(
       () => {
         log('CLOSING DUE TO HEARTBEAT TIMEOUT')
-        ws.close()
+        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 () => {
-      checkHeartbeat()
+      opened = true
       log('AUTHORIZING NEWLY OPENED WS FOR SESSION:', session)
       failedConnections = 0
       ws.send(JSON.stringify({ token: await token(), session }))
@@ -146,10 +154,10 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
           else {
             const key = `${message.domain}/${message.user}/${message.scope}`
             if (watchers[key]) {
-              if (sessionData[session].subscriptions[key] + 1 !== message.ii) {
+              if (subscriptions[key] + 1 !== message.ii) {
                 //  TODO: this seems to be an error that happens with decent regularity (an answer with a given si was skipped/failed)
                 //        we should be wary of out-of-order ii being passed down (maybe need to wait for older ones???)
-                console.warn('UNEXPECTED UPDATE INTERACTION INDEX!!!!!!!!!!! last index in session', sessionData[session].subscriptions[key], ' passed index ', message.ii)
+                console.warn('UNEXPECTED UPDATE INTERACTION INDEX!!!!!!!!!!! last index in session', subscriptions[key], ' passed index ', message.ii)
               }
               states[key] = await states[key] || {}
 
@@ -158,7 +166,7 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
 
               applyPatch(states[key], standardJSONPatch(message.patch.slice(lastResetPatchIndex + 1)))
               watchers[key].forEach(fn => fn({ ...message, state: states[key] }))
-              sessionData[session].subscriptions[key] = message.ii
+              subscriptions[key] = message.ii
             }
           }
         }
@@ -169,19 +177,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 }
@@ -203,15 +208,15 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
       if (states[k] === undefined) {
         watchers[k] = []
         states[k] = new Promise(async resolve => {
-          sessionData[session].subscriptions[k] = null
+          subscriptions[k] = null
           const { ii, state } = await lastMessageResponse()
-          sessionData[session].subscriptions[k] = ii
+          subscriptions[k] = ii
           resolve(state)
           if (ii === -1) {
             // -1 indicates the result is a computed scope, so
             // ii does not apply (we clear out the subscription to not cache value)
             delete states[k]
-            delete sessionData[session].subscriptions[k]
+            delete subscriptions[k]
           }
         })
       }
@@ -223,7 +228,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 => {
@@ -241,7 +246,7 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
       const k = await key
       removeWatcher(k, watchFn)
       if (watchers[k].length === 0) {
-        delete sessionData[session].subscriptions[k]
+        delete subscriptions[k]
         delete watchers[k]
       }
     }
@@ -252,9 +257,9 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
   //  TODO: if no data, set up streaming upload
   async function upload(name, type, data, id=uuid()) {
     //  TODO: include data size info...
-    sessionData[session].uploads[id] = { url: null, sent: 0, name, type }
+    uploads[id] = { url: null, sent: 0, name, type }
     const { url } = await lastMessageResponse()
-    sessionData[session].uploads[id].url = url
+    uploads[id].url = url
 
     if (data === undefined) return url
     else {
@@ -268,9 +273,9 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
   }
 
    async function download(id, passthrough=false) {
-    sessionData[session].downloads[id] = { url: null, size: null, sent: 0 }
+    downloads[id] = { url: null, size: null, sent: 0 }
     const { url } = await lastMessageResponse()
-    sessionData[session].downloads[id].url = url
+    downloads[id].url = url
 
     if (passthrough) return url
     else {
@@ -283,7 +288,7 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
   }
 
   async function patch(root, scopes) {
-    sessionData[session].patches[uuid()] = { root, scopes }
+    patches[uuid()] = { root, scopes }
     const { swaps } = await lastMessageResponse()
     return { swaps }
   }
@@ -325,6 +330,7 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
   }
 
   async function mutate(scope, initialize=true) {
+    //  TODO: probably can remove redundant copy
     const initial = initialize ? copy(await state(scope) || {}) : {}
     return new MutableProxy(initial, patch => interact(scope, patch))
   }

package/package.json

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

package/vue/3/content.vue

@@ -12,10 +12,6 @@ export default {
     id: {
       type: String,
       required: true
-    },
-    scope: {
-      type: String,
-      required: false
     }
   },
   unmounted() {
@@ -25,9 +21,9 @@ export default {
     setup(iframe) {
       if (!iframe || this.iframe === iframe) return
 
-      const { id, scope } = this
+      const { id } = this
       this.iframe = iframe
-      this.embedding = Agent.embed({ content: id, scope }, iframe)
+      this.embedding = Agent.embed({ id }, iframe)
 
 /*
       const { handle } = this.embedding