@naanlang/naan 1.0.16 → 1.2.0

package/frameworks/browser/ws_client.nlg

@@ -0,0 +1,124 @@
+/*
+ * ws_client.nlg
+ *
+ *     WebSocket client operations for the browser.
+ *
+ * column positioning:                          //                          //                      !
+ *
+ * Copyright (c) 2023 by Richard C. Zulch
+ *
+ */
+
+
+/*
+ * WebSocket
+ *
+ * Create a WebSocket client connection object using the existing HTTPS connection.
+ *
+ * Options:
+ *  {
+ *      host:       <string>                    // host:port
+ *      onopen:     <proc>(e)                   // connection has opened
+ *      onmessage:  <proc>(e, message)          // message received
+ *      onerror:    <proc>(e)                   // error occurred
+ *      onclose:    <proc>(e)                   // connection has closed
+ *  }
+ *
+ */
+
+closure WebSocket(options, local wsock) {
+    global(window)
+    wsock = new(object, this)
+    options = new(options) || { }
+    if !options.host
+        options.host = window.location.host
+
+    // connect
+    //
+    // Connect with the host if not already connected, returning a result tuple.
+    //
+    wsock.connect = closure connect(local pending) {
+        if wsock.ws
+            return (list(false, { open: true }))
+        wsock.ws = xnew(window.WebSocket, "ws://${options.host}")
+        pending = new(nonce)
+    
+        // onopen
+        // The WebSocket connection is now open.
+        wsock.ws.onopen = closure onopen(e, local spawner) {
+            pending.signal(list(false, { ok: true }))
+            options.onopen(e)
+        }
+
+        // onmessage
+        // A message was received from the worker via WebSockets.
+        wsock.ws.onmessage = closure onmessage(e, message) {
+            try {
+                message = new(JSONparse(e.data))
+            } catch {
+                debuglog("can't decode incoming ws message:", exception)
+                options.onerror(Error("can't decode incoming message:", exception))
+                return
+            }
+            options.onmessage(e, message)
+        }
+        
+        // onerror
+        // An error occurred on the WebSocket connection.
+        wsock.ws.onerror = closure onerror(e, local error) {
+            error = Error("websocket failed", e)
+            options.onerror(e, error)
+            pending.signal(list(error))                                     // ensure connect completes
+        }
+        
+        // onclose
+        // The WebSocket connection was closed.
+        wsock.ws.onclose = closure onclose(e) {
+            options.onclose(e, e.code, e.reason)
+            pending.signal(list(Error("connection closed")))                // ensure connect completes
+            wsock.ws = false
+        }
+        
+        pending.wait()
+    }
+  
+    // send
+    //
+    //     Send a message dictionary.
+    //
+    wsock.send = function send(message) {
+        wsock.ws.send(JSONstringify(message))
+    }
+        
+    // close
+    //
+    //     Close the connection.
+    //
+    wsock.close = function close(reason) {
+        if !reason
+            reason = 1000                                                   // normal close
+        wsock.ws.close(reason)
+    }
+
+    // finis
+
+    wsock
+};
+
+
+/*
+ * ws_clientInit
+ *
+ *     Initialize WebSocket client operations for browsers.
+ *
+ */
+
+function ws_clientInit(local manifest) {
+    manifest = `(WebSocket, ws_clientInit)
+
+    Naan.module.build(module.id, "ws_client", function(modobj, compobj) {
+        require("browser.nlg")
+        compobj.manifest = manifest
+        modobj.exports.WebSocket = WebSocket
+    })
+}();

package/frameworks/client/apiclient.nlg

@@ -2,174 +2,140 @@
  * apiclient.nlg
  * Naanlib/frameworks/client
  *
- *     Access to Nide API with HTTP client.
+ *     Access to Nide API with browser HTTP client.
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2017-2022 by Richard C. Zulch
+ * Copyright (c) 2017-2024 by Richard C. Zulch
  *
  */
 
 
 /*
- * MakeNideAPIclient
- *
- *     Make a DAS API client object for browsers. This client API handles a single project at a
- * time, from load() to close().
+ * NideAPIclient
  *
+ *     Make an API client object for browsers.
  *
  */
 
-closure MakeNideAPIclient(url, guid, local client) {
+closure NideAPIclient(url, guid, apiRequester, local client) {
+    global()
     client = new(object, this)
+    if !url.match(RegExp("^https?:\/\/", "i"))
+        url = "http://${url}"
     client.url = url
     client.guid = guid
     client.notifyAfter = 0
+    client.instanceID = UUID()                                              // our client's unique ID
 
-    // clientRequest() - general request routine
-
-    closure clientRequest(method, path, options, cbReq, local request) {
-        request = xnew(js.w.XMLHttpRequest)
-        request.addEventListener("load", function (event) {
-            cbReq(false, request, event)
-        })
-
-        request.addEventListener("error", function reqFailed(event, local errtext) {
-            if request.status == 0
-                errtext = "connectivity"
-            else
-                errtext = "request failed"
-            error = Error(errtext, {
-                status: request.status
-                method: method
-                path: path
-            })
-            cbReq(error, request, event)
-        })
+    // clientRequest() - append our guid to the headers
 
-        request.open(method, path)
-        if options.responseType
-            request.responseType = options.responseType
-        if options.contentType
-            request.setRequestHeader("Content-Type", options.contentType)
+    closure clientRequest(url, options) {
+        options = merge(options)
         if guid
-            request.setRequestHeader("x-naanlang-api-guid", guid)
-        request.send(options.putdata)
+            options.headers = [list("x-naanlang-api-guid", guid)]
+        apiRequester(url, options)
     }
 
     //
     // docs()
     //
 
-    client.docs = closure docs() {
-        clientRequest("GET", url.concat("/"), false, function (error, req, event) {
-            printline(req.responseText)
-        })
+    client.docs = closure docs(local error, content, extra) {
+        `(error, content, extra) = clientRequest(url.concat("/"))
+        printline(content)
     }
 
     //
     // status(callback, timeoutMS)
     //
 
-    client.status = closure status(cbStatus, timeoutms, local query, options, queued) {
-        options = new(dictionary)
-        options.timeout = timeoutms
-        options.after = client.notifyAfter
-        query = EncodeQuery("/status/?", options)
-        clientRequest("GET", url.concat(query), false, function (error, req, event) {
-            if (error || req.status != 200)
-                cbStatus()
-            else if (length(req.responseText) == 0)
-                cbStatus([])
-            else {
-                queued = new(JSONparse(req.responseText))
-                queued.forEach(function(item,index,array) {
-                    if client.notifyAfter < item.stamp
-                        client.notifyAfter = item.stamp
-                })
-                cbStatus(queued)
-            }
+    client.status = closure status(cbStatus, timeoutms, local query, error, content, extra, queued) {
+        query = EncodeQuery("/status/?", {
+            timeout: timeoutms
+            after: client.notifyAfter
         })
+        `(error, content, extra) = clientRequest(url.concat(query))
+        if (error || extra.status != 200)
+            cbStatus()
+        else if (length(content) == 0)
+            cbStatus([])
+        else {
+            queued = new(content)
+            queued.forEach(function(item, index, array) {
+                if client.notifyAfter < item.stamp
+                    client.notifyAfter = item.stamp
+            })
+            cbStatus(queued)
+        }
     }
 
     //
     // get
     //
 
-    client.get = closure get(path, cbRead) {
-        options.path = filepath
-        clientRequest("GET", url.concat("/", path), false, cbRead)
+    client.get = closure get(path, options, local error, content, extra) {
+        `(error, content, extra) = clientRequest(url.concat("/", path))
+        if !error && extra.status != 200
+            error = Error("readFile failed: ".concat(extra.status), {
+                    status: extra.status
+                })
+        if error
+            list(error)
+        else
+            list(error, content, extra)
     }
 
     //
-    // readFile(filepath, cbRead)
+    // readFile(filepath, options)
     //
 
-    client.readFile = closure readFile(filepath, cbRead, local query, options) {
-        options = new(dictionary)
-        options.path = filepath
-        query = EncodeQuery("/readfile/?", options)
-        clientRequest("GET", url.concat(query), false, cbRead)
+    client.readFile = closure readFile(filepath, options, local query, error, content, extra) {
+        query = EncodeQuery("/readfile/?", {
+            path: filepath
+        })
+        `(error, content, extra) = clientRequest(url.concat(query), options)
+        if !error && extra.status != 200
+            error = Error("readFile failed: ".concat(extra.status), {
+                    status: extra.status
+                })
+        if error
+            list(error)
+        else
+            list(error, content, extra)
     }
 
     //
     // psmRemote(options, data, callback)
     //
-    // Perform an operation and call back when done. If the communication works then the result is:
-    //      callback(false, (remote_error, remote_data)).
-    // Otherwise if communication failed then the result is:
-    //      callback(<error>).
+    // Perform an operation and call back when done.
 
-    client.psmRemote = closure psmRemote(options, data, callback, local query, method, reqOptions, error) {
+    client.psmRemote = closure psmRemote(options, data, callback, 
+        local query, reqOptions, error, content, extra) {
         query = EncodeQuery("/psm/?", options)
-        if data
-            method = "PUT"
-        else
-            method = "GET"
         reqOptions = {
             putdata: data
         }
-        if options.encoding == "binary" {
-            if data
-                reqOptions.contentType = "application/octet-stream"         // we are sending binary data
-            else
-                reqOptions.responseType = "arraybuffer"                     // we are requesting binary data
-        } else if options.encoding == "json" {
-            if data {
-                reqOptions.contentType = "application/json;charset=UTF-8"   // we are sending JSON
-                `(error, data) = JsonStringify(data)
-                if error
-                    return (callback(Error("psmRemote failed:", error)))
-                reqOptions.putdata = data
-            }
-            else
-                reqOptions.responseType = "application/json"                // we are requesting JSON
-        }
-        clientRequest(method, url.concat(query), reqOptions, function (error, req, event, local data) {
-            if !error && req.status != 200
-                error = Error("NodeFS request failed: ".concat(req.status), {
-                    status: req.status
-                    method: method
-                    query: query
-                    })
+        if !data
+            reqOptions.encoding = options.encoding                          // expected response format
+        else if options.encoding == "binary"
+            reqOptions.contentType = "application/octet-stream"             // we are sending binary data
+        else if options.encoding == "json" {
+            reqOptions.contentType = "application/json;charset=UTF-8"       // we are sending JSON
+            `(error, data) = JsonStringify(data)
             if error
-                callback(error)
-            else {
-                if req.getResponseHeader("content-type").startsWith("application/json")
-                    try {                                                   // attempt to decode JSON response
-                        data = new(JSONparse(req.responseText))
-                        if array(data) {
-                            data = totuple(data)
-                            error = data.0
-                            data = data.1 }
-                    } catch {
-                        if true
-                            data = req.responseText                         // just return text on failure
-                    }
-                else
-                    data = req.response                                     // e.g. when reading binary content
-                callback(error, data) }
-        })
+                return (callback(Error("psmRemote encoding failed:", error)))
+            reqOptions.putdata = data
+        }
+        `(error, content, extra) = clientRequest(url.concat(query), reqOptions)
+        if !error && extra.status != 200
+            error = Error("NodeFS request failed: ".concat(extra.status), {
+                    status: extra.status
+                })
+        if error
+            callback(error)
+        else
+            callback(error, content)
     }
 
     client
@@ -185,12 +151,12 @@ closure MakeNideAPIclient(url, guid, local client) {
 
 function apicInit(local manifest) {
 
-    manifest = `(MakeNideAPIclient, apicInit)
+    manifest = `(NideAPIclient, apicInit)
 
     Naan.module.build(module.id, "apiclient", function(modobj, compobj) {
         Naan.module.require("./client.nlg")
         compobj.manifest = manifest
-        modobj.exports.MakeNideAPIclient = MakeNideAPIclient
+        modobj.exports.NideAPIclient = NideAPIclient
     })
 
 } ();

package/frameworks/client/psm_client.nlg

@@ -6,7 +6,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2019-2022 by Richard C. Zulch
+ * Copyright (c) 2019-2024 by Richard C. Zulch
  *
  */
 
@@ -19,6 +19,7 @@
  */
 
 closure psmcFsView(api, rootpath, local view, pathmod) {
+    global(JSpath)
     view = new(object, this)
     view.api = api
     view.rootpath = rootpath
@@ -114,7 +115,7 @@ closure psmcFsView(api, rootpath, local view, pathmod) {
     // that a transient error will give a bad path, but that will be detected downstream.
 
     view.path = new(object, this)
-    view.path[".undefined"] = function path args {
+    view.path@[".undefined"] = function path args {
         if !pathmod
             pathInit()
         xapply(pathmod, args.0, args.-1)
@@ -154,6 +155,8 @@ closure psmcFsView(api, rootpath, local view, pathmod) {
     // Read a file at the specified path
     
     view.readFile = function readFile(path, options, callback) {
+        if !path
+            throw("psmcFsView.readFile: path is false")
         psmRemote(path, "readFile", options, false, callback)
     }
 
@@ -354,7 +357,9 @@ closure psmcFsView(api, rootpath, local view, pathmod) {
     // Tell the shell to open the specified file.
     
     view.shellOpen = function shellOpen(path, args, callback) {
-        psmRemote(path, "shellOpen", { args: args }, false, callback)
+        if args
+            args = { args: args }
+        psmRemote(path, "shellOpen", args, false, callback)
     }
 
     // grepLines
@@ -424,11 +429,14 @@ closure psmcFsView(api, rootpath, local view, pathmod) {
  *
  */
 
-closure psmcFsConnector(psm, nicc, local connClassID, connector, watch) {
+closure psmcFsConnector(psm, api, local connClassID, connector, watch) {
+    global()
     connClassID = "NodeFS"
     connector = new(object, this)
     connector.psm = psm
-    connector.api = nicc.api
+    connector.apis = {
+        HostFS: api
+    }
     connector.vault = psm.vault(connClassID)
     connector.label = "Naan-Server"
     watch = psm.watchable(connector)
@@ -563,7 +571,7 @@ closure psmcFsConnector(psm, nicc, local connClassID, connector, watch) {
     // listResources
     //
     // List saved resources in our database
-    connector.listResources = function listResources(local error, original) {
+    connector.listResources = function listResources(local error, output, original) {
         `(error, output) = connector.vault.listResources()
         if error
             return (list(error))                                            // can't access our saved resources
@@ -579,14 +587,14 @@ closure psmcFsConnector(psm, nicc, local connClassID, connector, watch) {
     connector.info = function info(resID, local info, error, creds) {
         info = {
             classID: connClassID
-            type: "remote filesystem"
-            services: ["NideFS", "NideHostAPI"]
+            type: "remote server"
+            services: ["NideFS", "NideHostAPI", "NideTerminal"]
         }
         if resID == "Host" {
             info.name = "Host"
             info.type = "host filesystem"
             info.locked = true
-            info.where = nicc.api.url
+            info.where = api.url
             info.access = "HostFS"
         } else {
             `(error, creds) = connector.vault.accessResource(resID)
@@ -620,14 +628,26 @@ closure psmcFsConnector(psm, nicc, local connClassID, connector, watch) {
         `(error, creds) = connector.access(resID)
         if !error {
             if creds == "HostFS"
-                api = connector.api
-            else
-                api = MakeNideAPIclient(creds.urlName, creds.authSecret)    // API to remote NodeJS filesystem
+                api = connector.apis[creds]
+            else {
+                api = connector.apis[creds.urlName]
+                if !api                                                     // get API to remote server
+                    connector.apis[creds.urlName] = api = NideAPIclient(creds.urlName, creds.authSecret)
+            }
         }
         if error
             list(error)
-        else if service == "NideExecutor"
-            require("../browser/terminals.nlg").TermHost(nicc.track, api, args.0, args.1)                       // host executor, args: (name, workerID)
+        else if service == "NideTerminal" {
+            if !App.nide.track
+                return (list(Error("NideTerminal not supported in this environment")))
+            list(false, App.nide.track.spawn(App.nide.registerRemote(api),
+                args.0,                                                     // terminal display name
+                args.1))                                                    // options:
+                    // {
+                    //      workerID: "NideServer"  -- for main thread; other strings for worker threads
+                    //      type: "My Remotes"      -- display name of terminal group; e.g. URL
+                    // }
+        }
         else if service == "NideHostAPI"
             list(false, api)                                                // connect to the Host API
         else if service == "NideFS" {
@@ -653,11 +673,12 @@ closure psmcFsConnector(psm, nicc, local connClassID, connector, watch) {
  *
  */
 
-function psmcMakeClientPSM(nicc, dbname, local importPSM) {
+function psmcMakeClientPSM(api, dbname, local importPSM) {
+    global(App)
     importPSM = require("../storage/psm.nlg")
     App.psm = importPSM.MakePSM(dbname).1
     if App.psm {
-        psmcFsConnector(App.psm, nicc)                                      // HostFS access
+        psmcFsConnector(App.psm, api)                                       // HostFS access
         require("../storage/dbt_pouch.nlg").DbConnector(App.psm)            // Pouch databases as filesystems
     }
     App.psm