@knowlearning/agents 0.9.26 → 0.9.28

package/agents/browser/embedded.js

@@ -7,6 +7,7 @@ export default function EmbeddedAgent() {
   const session = new Promise(r => resolveSession = r)
   const responses = {}
   const watchers = {}
+  const sentUpdates = {}
 
   function removeWatcher(key, fn) {
     const watcherIndex = watchers[key].findIndex(x => x === fn)
@@ -37,18 +38,33 @@ export default function EmbeddedAgent() {
     }
   }
 
+  let sessionResolved = false
   addEventListener('message', async ({ data }) => {
-    if (data.type === 'setup') resolveSession(data.session)
+    if (data.type === 'setup' && !sessionResolved) {
+      sessionResolved = true
+      resolveSession(data.session)
+    }
+    else if (!sessionResolved || data.session !== await session) return
     else if (responses[data.requestId]) {
       const { resolve, reject } = responses[data.requestId]
       if (data.error) reject(data.error)
       else resolve(data.response)
     }
     else if (data.ii !== undefined) {
-      const { scope, user } = data
-      const { auth } = await environment()
-      const key = isUUID(scope) ? scope : `${!user || auth.user === user ? '' : user}/${scope}`
-      if (watchers[key]) watchers[key].forEach(fn => fn(data))
+      const { scope, user, domain } = data
+      const { auth, domain:rootDomain } = await environment()
+      const d = !domain || domain === rootDomain ? '' : domain
+      const u = !user || auth.user === user ? '' : user
+      const key = isUUID(scope) ? scope : `${d}/${u}/${scope}`
+      if (watchers[key]) {
+        if (sentUpdates[key] + 1 === data.ii) {
+          sentUpdates[key] = data.ii
+          watchers[key].forEach(fn => fn(data))
+        }
+        else if (data.ii !== sentUpdates[key]) {
+          console.warn('Out of order or repeated update for', key, data.ii, sentUpdates[key])
+        }
+      }
     }
   })
 
@@ -57,9 +73,11 @@ export default function EmbeddedAgent() {
   }
 
   function create({ id=uuid(), active_type, active }) {
-    //  TODO: collapse into 1 patch and 1 interact call
-    interact(id, [{ op: 'add', path: ['active_type'], value: active_type }])
-    interact(id, [{ op: 'add', path: ['active'], value: active }])
+    if (!active_type) active_type = 'application/json'
+    interact(id, [
+      { op: 'add', path: ['active_type'], value: active_type },
+      { op: 'add', path: ['active'], value: active }
+    ])
     return id
   }
 
@@ -78,13 +96,26 @@ export default function EmbeddedAgent() {
     await tag(tag_type, target)
   }
 
-  function watch(id, fn, user) {
-    tagIfNotYetTaggedInSession('subscribed', id)
-    const key = isUUID(id) ? id : `${ user || ''}/${id}`
-    if (!watchers[key]) watchers[key] = []
-    watchers[key].push(fn)
-    send({ type: 'state', scope: id, user })
-    return () => removeWatcher(key, fn)
+  function watch(scope, fn, user, domain) {
+    tagIfNotYetTaggedInSession('subscribed', scope)
+
+    const key = (
+      environment()
+        .then(async ({ auth, domain:rootDomain }) => {
+          const d = !domain || domain === rootDomain ? '' : domain
+          const u = !user || auth.user === user ? '' : user
+          const key = isUUID(scope) ? scope : `${d}/${u}/${scope}`
+
+          const state = await send({ type: 'state', scope, user, domain })
+          const metadata = await send({ type: 'metadata', scope, user, domain })
+          fn({ state, patch: null, ii: metadata.ii })
+          sentUpdates[key] = metadata.ii
+          if (!watchers[key]) watchers[key] = []
+          watchers[key].push(fn)
+          return key
+        })
+    )
+    return async () => removeWatcher(await key, fn)
   }
 
   async function patch(root, scopes) {
@@ -92,14 +123,15 @@ export default function EmbeddedAgent() {
     return send({ type: 'patch', root, scopes })
   }
 
-  async function state(scope) {
+  async function state(scope, user, domain) {
     if (scope === undefined) {
       const { context } = await environment()
       scope = JSON.stringify(context)
     }
     tagIfNotYetTaggedInSession('subscribed', scope)
-    const startState = await send({ type: 'state', scope })
+    const startState = await send({ type: 'state', scope, user, domain })
     return new MutableProxy(startState, patch => {
+      //  TODO: reject updates if user is not owner
       const activePatch = structuredClone(patch)
       activePatch.forEach(entry => entry.path.unshift('active'))
       interact(scope, activePatch)

package/agents/browser/initialize.js

@@ -4,18 +4,20 @@ import { v1 as uuid, validate as validateUUID } from 'uuid'
 
 let Agent
 
-export default function browserAgent() {
-  if (Agent) return Agent
+export default function browserAgent(options={}) {
+  if (Agent && !options.unique) return Agent
 
   let embedded
 
   try { embedded = window.self !== window.top }
   catch (e) { embedded = true }
 
-  Agent = embedded ? EmbeddedAgent() : RootAgent()
-  Agent.embed = embed
+  const newAgent = embedded && !options.root ? EmbeddedAgent() : RootAgent(options)
+  newAgent.embed = embed
 
-  return Agent
+  if (!Agent) Agent = newAgent
+
+  return newAgent
 }
 
 const copy = x => JSON.parse(JSON.stringify(x))
@@ -57,10 +59,9 @@ function embed(environment, iframe) {
       if (listeners.close) listeners.close(message.info)
     }
     else if (type === 'environment') {
+      const { context } = message
       const env = await Agent.environment()
-      const context = [...env.context, environment.id]
-      Object.assign(env, { ...env, context })
-      sendDown(env)
+      sendDown({ ...env, context: [...env.context, environment.id] })
     }
     else if (type === 'interact') {
       const { scope, patch } = message
@@ -80,13 +81,13 @@ function embed(environment, iframe) {
       sendDown(await Agent.tag(tag_type, target, prependedContext))
     }
     else if (type === 'state') {
-      const { scope, user } = message
+      const { scope, user, domain } = message
 
-      const statePromise = Agent.state(scope, user)
+      const statePromise = Agent.state(scope, user, domain)
 
-      const key = `${user || ''}/${scope}`
+      const key = `${ domain || ''}/${user || ''}/${scope}`
       if (!watchers[key]) {
-        watchers[key] = Agent.watch(scope, postMessage, user)
+        watchers[key] = Agent.watch(scope, postMessage, user, domain)
       }
 
       if (listeners.state) listeners.state({ scope })
@@ -154,6 +155,7 @@ function embed(environment, iframe) {
     else iframe.src = id //  TODO: ensure is url
 
     while(!embeddedAgentInitialized) {
+      //  TODO: wait for any other agents that are initializing from other potential root agents
       postMessage({ type: 'setup', session })
       await new Promise(r => setTimeout(r, 100))
     }

package/agents/browser/root.js

@@ -8,13 +8,13 @@ const REMOTE_HOST = 'api.knowlearning.systems'
 
 function isLocal() { return localStorage.getItem('api') === 'local' }
 
-export default () => {
+export default options => {
   const { host, protocol } = window.location
 
   const agent = GenericAgent({
     host: isLocal() ? DEVELOPMENT_HOST : REMOTE_HOST,
     protocol: protocol === 'https:' ? 'wss' : 'ws',
-    token: getToken,
+    token: options.getToken || getToken,
     WebSocket,
     uuid,
     fetch,

package/agents/generic/index.js

@@ -44,6 +44,7 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
     tagIfNotYetTaggedInSession,
     interact,
     fetch,
+    synced,
     metadata
   }
 
@@ -51,7 +52,7 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
 
   async function environment() { return { ...(await environmentPromise), context: [] } }
 
-  function state(scope, user) { return stateImplementation(scope, user, internalReferences) }
+  function state(scope, user, domain) { return stateImplementation(scope, user, domain, internalReferences) }
 
   function download(id) { return downloadImplementation(id, internalReferences) }
 
@@ -60,6 +61,7 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
   function log() { if (mode === 'debug') console.log(...arguments) }
 
   function create({ id=uuid(), active_type, active, name }) {
+    if (!active_type) active_type = 'application/json'
     const patch = [
       { op: 'add', path: ['active_type'], value: active_type },
       { op: 'add', path: ['active'], value: active }
@@ -110,7 +112,7 @@ export default function Agent({ host, token, WebSocket, protocol='ws', uuid, fet
     const response = queueMessage({scope, patch})
 
     //  if we are watching this scope, we want to keep track of last interaction we fired
-    const qualifiedScope = isUUID(scope) ? scope : `/${scope}`
+    const qualifiedScope = isUUID(scope) ? scope : `//${scope}`
     if (states[qualifiedScope] !== undefined) {
       let resolve
       lastInteractionResponse[qualifiedScope] = new Promise(r => resolve = r)

package/agents/generic/message-queue.js

@@ -18,7 +18,6 @@ export default function messageQueue(setEnvironment, { token, protocol, host, We
   let ws
   let user
   let authed = false
-  let isSynced = false
   let session
   let server
   let si = -1
@@ -30,7 +29,7 @@ export default function messageQueue(setEnvironment, { token, protocol, host, We
   let lastSynchronousScopePatchPromise = null
   let restarting = false
   let disconnected = false
-  const syncedPromiseResolutions = []
+  const outstandingSyncPromises = []
   const responses = {}
 
 
@@ -41,7 +40,6 @@ export default function messageQueue(setEnvironment, { token, protocol, host, We
   }
 
   function queueMessage({ scope, patch }) {
-    isSynced = false
     if (lastSynchronousScopePatched === scope) {
       const i = messageQueue.length - 1
       messageQueue[i].patch = [...messageQueue[i].patch, ...patch]
@@ -74,8 +72,10 @@ export default function messageQueue(setEnvironment, { token, protocol, host, We
   }
 
   function resolveSyncPromises() {
-    while (syncedPromiseResolutions.length) syncedPromiseResolutions.shift()()
-    isSynced = true
+    const lowestOutstandingResponseIndex = Object.keys(responses).map(parseInt).sort()[0] || Infinity
+    while (outstandingSyncPromises[0] && outstandingSyncPromises[0].si < lowestOutstandingResponseIndex) {
+      outstandingSyncPromises.shift().resolve()
+    }
   }
 
   function checkHeartbeat() {
@@ -162,7 +162,7 @@ export default function messageQueue(setEnvironment, { token, protocol, host, We
 
               delete responses[message.si]
               ws.send(JSON.stringify({ack: message.si})) //  acknowledgement that we have received the response for this message
-              if (Object.keys(responses).length === 0) resolveSyncPromises()
+              resolveSyncPromises()
             }
             else {
               //  TODO: consider what to do here... probably want to throw error if in dev env
@@ -170,7 +170,10 @@ export default function messageQueue(setEnvironment, { token, protocol, host, We
             }
           }
           else {
-            const qualifiedScope = isUUID(message.scope) ? message.scope : `${ message.user === user ? '' : message.user}/${message.scope}`
+            const d = message.domain === window.location.host ? '' : message.domain
+            const u = message.user === user ? '' : message.user
+            const s = message.scope
+            const qualifiedScope = isUUID(s) ? s : `${d}/${u}/${s}`
             if (watchers[qualifiedScope]) {
               states[qualifiedScope] = await states[qualifiedScope]
 
@@ -205,7 +208,11 @@ export default function messageQueue(setEnvironment, { token, protocol, host, We
     checkHeartbeat()
   }
 
-  async function synced() { return isSynced ? null : new Promise(res => syncedPromiseResolutions.push(res)) }
+  async function synced() {
+    const syncPromise = new Promise(resolve => outstandingSyncPromises.push({ si: lastSentSI, resolve }))
+    resolveSyncPromises()
+    return syncPromise
+  }
 
   function lastMessageResponse() { return new Promise((res, rej) => responses[si].push([res, rej])) }
 

package/agents/generic/state.js

@@ -3,12 +3,12 @@ import MutableProxy from '../../persistence/json.js'
 
 const SUBSCRIPTION_TYPE = 'application/json;type=subscription'
 
-export default function(scope='[]', user, { keyToSubscriptionId, watchers, states, create, environment, lastMessageResponse, lastInteractionResponse, tagIfNotYetTaggedInSession, interact }) {
+export default function(scope='[]', user, domain, { keyToSubscriptionId, watchers, states, create, environment, lastMessageResponse, lastInteractionResponse, tagIfNotYetTaggedInSession, interact }) {
   let resolveMetadataPromise
   let metadataPromise = new Promise(resolve => resolveMetadataPromise = resolve)
 
   const statePromise = new Promise(async (resolveState, rejectState) => {
-    const qualifiedScope = isUUID(scope) ? scope : `${user || ''}/${scope}`
+    const qualifiedScope = isUUID(scope) ? scope : `${domain || ''}/${user || ''}/${scope}`
     if (!keyToSubscriptionId[qualifiedScope]) {
       const id = uuid()
 
@@ -19,7 +19,7 @@ export default function(scope='[]', user, { keyToSubscriptionId, watchers, state
         create({
           id,
           active_type: SUBSCRIPTION_TYPE,
-          active: { session, scope, user, ii: null, initialized: Date.now() },
+          active: { session, scope, user, domain, ii: null, initialized: Date.now() },
         })
 
         try {

package/agents/generic/watch.js

@@ -1,39 +1,31 @@
 import { validate as isUUID } from 'uuid'
 
-export default function({ metadata, state, watchers }) {
+export default function({ metadata, state, watchers, synced }) {
 
-  function watch(scope=DEFAULT_SCOPE_NAME, fn, user) {
-    if (Array.isArray(scope)) return watchResolution(scope, fn, user)
+  function watch(scope=DEFAULT_SCOPE_NAME, fn, user, domain) {
+    if (Array.isArray(scope)) return watchResolution(scope, fn, user, domain)
 
-    let initialSent = false
-    const queue = []
-    function cb(update) {
-      if (initialSent) fn(update)
-      else queue.push(update)
-    }
-
-    const statePromise = state(scope, user)
-    const qualifiedScope = isUUID(scope) ? scope : `${user || ''}/${scope}`
-
-    if (!watchers[qualifiedScope]) watchers[qualifiedScope] = []
-    watchers[qualifiedScope].push(cb)
+    const statePromise = state(scope, user, domain)
+    const qualifiedScope = isUUID(scope) ? scope : `${domain || ''}/${user || ''}/${scope}`
 
-    metadata(scope, user)
+    metadata(scope, user, domain)
       .then(async ({ ii }) => {
         fn({
           scope,
+          user,
+          domain,
           state: await statePromise,
           patch: null,
           ii
         })
-        initialSent = true
-        queue.forEach(fn)
+        if (!watchers[qualifiedScope]) watchers[qualifiedScope] = []
+        watchers[qualifiedScope].push(fn)
       })
 
-    return () => removeWatcher(qualifiedScope, cb)
+    return () => removeWatcher(qualifiedScope, fn)
   }
 
-  function watchResolution(path, callback, user) {
+  function watchResolution(path, callback, user, domain) {
     const id = path[0]
     const references = path.slice(1)
     let unwatchDeeper = () => {}
@@ -57,13 +49,13 @@ export default function({ metadata, state, watchers }) {
           index === references.length - 1
         ) callback(value)
         else if (isUUID(value)) {
-          unwatchDeeper = watchResolution([value, ...references.slice(index + 1)], callback, user)
+          unwatchDeeper = watchResolution([value, ...references.slice(index + 1)], callback, user, domain)
           return
         }
       }
     }
 
-    const unwatch = watch(id, watchCallback, user)
+    const unwatch = watch(id, watchCallback, user, domain)
 
     return () => {
       unwatch()

package/package.json

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