@knowlearning/agents 0.9.25 → 0.9.27

package/agents/browser/embedded.js

@@ -38,22 +38,19 @@ export default function EmbeddedAgent() {
   }
 
   addEventListener('message', async ({ data }) => {
-    if (data.type === 'auth') {
-      // TODO: switch to access_token
-      if (localStorage.getItem('state') === data.state) {
-        localStorage.setItem('token', data.token)
-      }
-      send({ type: 'close' })
-    }
-    else if (data.type === 'setup') resolveSession(data.session)
+    if (data.type === 'setup') resolveSession(data.session)
     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 } = data
-      if (watchers[scope]) watchers[scope].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]) watchers[key].forEach(fn => fn(data))
     }
   })
 
@@ -62,9 +59,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
   }
 
@@ -83,12 +82,13 @@ export default function EmbeddedAgent() {
     await tag(tag_type, target)
   }
 
-
-  function watch(id, fn) {
-    tagIfNotYetTaggedInSession('subscribed', id)
-    if (!watchers[id]) watchers[id] = []
-    watchers[id].push(fn)
-    return () => removeWatcher(id, fn)
+  function watch(scope, fn, user, domain) {
+    tagIfNotYetTaggedInSession('subscribed', scope)
+    const key = isUUID(scope) ? scope : `${ domain || ''}/${ user || ''}/${scope}`
+    if (!watchers[key]) watchers[key] = []
+    watchers[key].push(fn)
+    send({ type: 'state', scope, user, domain })
+    return () => removeWatcher(key, fn)
   }
 
   async function patch(root, scopes) {
@@ -96,19 +96,19 @@ 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)
     })
-
   }
 
   function reset(scope) {

package/agents/browser/initialize.js

@@ -4,15 +4,15 @@ 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 = embedded && !options.root ? EmbeddedAgent() : RootAgent(options)
   Agent.embed = embed
 
   return Agent
@@ -71,7 +71,8 @@ function embed(environment, iframe) {
       sendDown({}) // TODO: might want to send down the interaction index
     }
     else if (type === 'metadata') {
-      sendDown(await Agent.metadata(message.scope))
+      const { scope, user } = message
+      sendDown(await Agent.metadata(scope, user))
     }
     else if (type === 'tag') {
       const { tag_type, target, context } = message
@@ -79,11 +80,14 @@ function embed(environment, iframe) {
       sendDown(await Agent.tag(tag_type, target, prependedContext))
     }
     else if (type === 'state') {
-      const { scope } = message
+      const { scope, user, domain } = message
 
-      const statePromise = Agent.state(scope)
+      const statePromise = Agent.state(scope, user, domain)
 
-      if (!watchers[scope]) watchers[scope] = Agent.watch(scope, postMessage)
+      const key = `${ domain || ''}/${user || ''}/${scope}`
+      if (!watchers[key]) {
+        watchers[key] = Agent.watch(scope, postMessage, user, domain)
+      }
 
       if (listeners.state) listeners.state({ scope })
       sendDown(await statePromise)

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

@@ -51,7 +51,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 +60,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 +111,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

@@ -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]
 

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

@@ -2,8 +2,8 @@ import { validate as isUUID } from 'uuid'
 
 export default function({ metadata, state, watchers }) {
 
-  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 = []
@@ -12,16 +12,18 @@ export default function({ metadata, state, watchers }) {
       else queue.push(update)
     }
 
-    const statePromise = state(scope, user)
-    const qualifiedScope = isUUID(scope) ? scope : `${user || ''}/${scope}`
+    const statePromise = state(scope, user, domain)
+    const qualifiedScope = isUUID(scope) ? scope : `${domain || ''}/${user || ''}/${scope}`
 
     if (!watchers[qualifiedScope]) watchers[qualifiedScope] = []
     watchers[qualifiedScope].push(cb)
 
-    metadata(scope, user)
+    metadata(scope, user, domain)
       .then(async ({ ii }) => {
         fn({
           scope,
+          user,
+          domain,
           state: await statePromise,
           patch: null,
           ii
@@ -33,7 +35,7 @@ export default function({ metadata, state, watchers }) {
     return () => removeWatcher(qualifiedScope, cb)
   }
 
-  function watchResolution(path, callback, user) {
+  function watchResolution(path, callback, user, domain) {
     const id = path[0]
     const references = path.slice(1)
     let unwatchDeeper = () => {}
@@ -57,13 +59,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.25",
+  "version": "0.9.27",
   "description": "API for embedding applications in KnowLearning systems.",
   "main": "node.js",
   "browser": "browser.js",