@naanlang/naan 1.4.4 → 1.6.0

package/frameworks/node/apiserver.nlg

@@ -6,11 +6,16 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2017-2024 by Richard C. Zulch
+ * Copyright (c) 2017-2026 by Richard C. Zulch
  *
  */
 
 
+// Globals
+
+serviceMod;;
+
+
 /*
  * APIServer
  *
@@ -25,18 +30,21 @@
  *      basePort:       <number>                // starting point for search
  *      gateway:        <string>                // websocket gateway URL
  *      statics:        [<string>, ...]         // search paths for static content
+ *      debug:          <boolean>               // verbose logging
  *  }
  *
  */
 
 closure APIServer(options, local server, chroot) {
-    global(App, JSpath, js, bodyParser, express, psmServerMod, workerMod)
+    global(App, serviceMod, JSpath, js, bodyParser, express, psmServerMod, workerMod)
     apisLoadLibs()
     server = new(object, this)
+    server.imp = App.imp
     server.app = express()
     server.guid = options.guid
     server.notifyq = []
     server.responseq = []
+    server.instanceID = UUID()
     options = merge({
         relpath: ""
         name: "NaanServer"
@@ -94,6 +102,7 @@ closure APIServer(options, local server, chroot) {
             return (result)
         }
         updatePort(port)
+
         if server.guid
             server.oururl = server.oururl.concat("?guid=", server.guid)
         App.api = server                                                    // used remotely by client/relaycon.nlg
@@ -107,6 +116,7 @@ closure APIServer(options, local server, chroot) {
             }
         } else                                                              // default is native websocket protocols
             server.ws = WebSocketServer(server)
+
         WesRelay(server)                                                    // registers as subsystem
         server.psm = psmServerMod.MakeServerPSM(server, options.name)
         `(error, hostfs) = server.psm.conns.NodeFS.connect("Host", "NideFS", list(""))
@@ -116,7 +126,9 @@ closure APIServer(options, local server, chroot) {
             return (list(error))
         }
         server.hostfs = hostfs
-        server.workco = workerMod.WorkerController(server)
+        server.workco = workerMod.WorkerController()
+        server.Register(server.workco.serverID, server.workco)
+
         list(false, port)
     }
 
@@ -431,15 +443,8 @@ closure WebSocketConn(wsgate, connID, local wsconn) {
     wsconn.msgin = closure msgin(message, local error) {
         if wsgate.guid && message.guid != wsgate.guid
             error = Error("unauthorized")
-        else if message.init {
-            if message.init.destID {
-                wsconn.relay = true
-                wsgate.subsystems.Relay.wsChangeDestID(conn, wsconn.info.destID, message.init.destID)
-            }
+        else if message.init
             wsconn.info = merge(wsconn.info, message.init)
-        }
-        else if message.respOp && wsgate.subsystems.Relay
-            wsgate.subsystems.Relay.wsReceive(message, wsconn)          // with respOp, must be a relay
         else if message.clientID && wsgate.subsystems[message.serverID]
             wsgate.subsystems[message.serverID].wsReceive(message, wsconn)
         else
@@ -510,11 +515,11 @@ closure WebSocketServer(server, local websocks) {
             websocks.subsystems[serverID].wsOpen(conn)                      // notify of our openings
     })
 
-    server.wss.on("error", function(error) {
+    websocks.wss.on("error", function(error) {
         ErrorDebuglog(Error("WebSocketServer: connection error", error))
     })
 
-    server.wss.on("close", function() {
+    websocks.wss.on("close", function() {
         debuglog("WebSocketServer has closed")
         websocks.closed = true                                              // note that we are closed
     })
@@ -557,37 +562,31 @@ closure WesCon(server, websocks, socket, request, local wescon) {
         destID: UUID()
         address: new(socket._socket.address())
     }
+    
+    wescon.impconn = server.imp.responder(function(data) {
+        if wescon.closed
+            return
+        socket.send(JSONstringify(data)),
+        list(false, { sent: true })
+    }, {
+        secret: server.guid
+        label: "api-client"
+    })
 
     // on message
     //
     // Incoming data.
     //
-    socket.on("message", closure onmessage(text, local message, error) {
-        try {
-            message = new(js.g.JSON.parse(text))
-            if server.guid && message.guid != server.guid
-                error = Error("unauthorized")
-            else if message.init {
-                if message.init.destID {
-                    wescon.relay = true
-                    websocks.subsystems.Relay.wsChangeDestID(wescon, wescon.info.destID, message.init.destID)
-                }
-                wescon.info = merge(wescon.info, message.init)
-            }
-            else if message.respOp && websocks.subsystems.Relay
-                websocks.subsystems.Relay.wsReceive(message, wescon)        // with respOp, must be a relay
-            else if message.clientID && websocks.subsystems[message.serverID]
-                websocks.subsystems[message.serverID].wsReceive(message, wescon)
-            else
-                error = Error("can't route message")
-        } catch {
-            if true
-                error = Error("can't decode message JSON", exception)
+    socket.on("message", closure(text, local error, message) {
+        `(error, message) = JsonParse(text)
+        if !error {
+            message = new(message)
+            if wescon.impconn.dispatch(message)
+                return
         }
-        if error
-            socket.send(JSONstringify([error]))
+        debuglog("socket message:", text)
     })
-        
+
     // on error
     //
     // Error has occurred on this connection.
@@ -607,222 +606,15 @@ closure WesCon(server, websocks, socket, request, local wescon) {
             code: code
             reason: reason
         }
+        wescon.impconn.destroy()
         websocks.closeConn(wescon)
     })
-    
-    // send
-    //
-    // Send a dictionary, which must have a clientID defined.
-    //
-    wescon.send = function send(message) {
-        if !message.clientID || !message.serverID
-            throw("Wescon.send: client and server IDs required")
-        if wescon.closed
-            list(Error("Socket connection closed", wescon.closed))
-        socket.send(JSONstringify(message)),
-        [false, {ok: true}]
-    }
 
     // finis
     wescon
 };
 
 
-/*
- * WesRelay
- *
- *     Web socket relay controller. This allows apiserver clients to discover each other and connect
- * for remote evaluation, etc. A source connection makes a request of a destination connection, and
- * the response is routed back to the original connection.
- *
- * This uses the following message fields for the requesting source:
- *     guid:            security token
- *     clientID:        defined by the source, this string defines where replies should be sent
- *     serverID:        "Relay"
- *     destID:          the destination connection
- *     endServerID:     the serverID to use at the destination
- * The message is modified with a virtual clientID to send to the destination, and then changed back
- * for return to the requester.
- *
- * To discover the available destination connections a source should use:
- *     clientID:        requester
- *     serverID:        "Relay"
- *     relayOp:         "getdests"
- * which returns:
- *     relayOp:         "destlist"
- *     destinations: [
- *          destID:     guid for the connection
- *          address:    socket port / family / ip address
- *          name:       <string>
- *          workerID:   id of destination worker
- *     ]
- * New and closed destinations are sent asynchronously to each source:
- *     relayOp:         "opened" / "closed"
- *     info: {
- *          destID:     guid for the connection
- *          address:    socket port / family / ip address
- *          name:       <string>
- *          workerID:   id of destination worker
- *      }
- *
- */
-
-closure WesRelay(server, local welay) {
-    global()
-    welay = new(object, this)
-    welay.serverID = "Relay"                                                // our serverID as a subsystem
-    welay.destIDs = { }                                                     // destination conns index
-    welay.virtualIDs = { }                                                  // virtual clientID index
-    welay.links = new(weakmap)                                              // source and dest connections
-    server.Register(welay.serverID, welay)
-    
-    // getVirtualID
-    // Return the virtual clientID for a requesting source/clientID and destination.
-    function getVirtualID(sconn, clientID, dconn, local sdict, ddict, vid) {
-        sdict = welay.links[sconn]
-        if !sdict
-            welay.links[sconn] = sdict = {
-                virtualIDs: { }
-            }
-        ddict = welay.links[dconn]
-        if !ddict
-            welay.links[dconn] = ddict = {
-                virtualIDs: { }
-            }
-        vid = ddict.virtualIDs[clientID]
-        if !vid {
-            sdict.virtualIDs[clientID] = vid = UUID()
-            welay.virtualIDs[vid] = {
-                sconn: sconn
-                dconn: dconn
-                clientID: clientID
-            }
-        }
-        vid
-    }
-
-    // addConnection
-    // Record a new connection as a possible destination.
-    function addConnection(conn) {
-        welay.destIDs[conn.info.destID] = conn
-    }
-
-    // removeConnection
-    // Cleanup for a closed connection, be it source or destination or both.
-    function removeConnection(conn, local vid, cdict, did, dconn) {
-        welay.links[conn] = undefined
-        for `(vid, cdict) in welay.virtualIDs
-            if cdict.sconn === conn || cdict.dconn === conn
-                welay.virtualIDs[vid] = undefined
-        for `(did, dconn) in welay.destIDs
-            if dconn === conn
-                welay.destIDs[did] = undefined
-    }
-    
-    // destList
-    // Make an array of destination connections, excluding the specified one.
-    //
-    welay.destList = function destList(conn, local output, did, dconn) {
-        output = []
-        for `(did, dconn) in welay.destIDs
-            if dconn !== conn && dconn.relay
-                output.push(dconn.info)
-        output
-    }
-
-    // wsReceive
-    //
-    //     Process a message from the websocket API.
-    //
-    welay.wsReceive = function wsReceive(message, sconn, local dconn, error, cdict) {
-        if message.relayOp == "getdests" {                                  // get destination list
-            message.relayOp = "destlist"
-            message.destinations = destList(sconn)
-            sconn.send(message)
-            return
-        }
-        else if message.destID && message.endServerID {                     // request from a source 
-            dconn = welay.destIDs[message.destID]
-            if !dconn
-                error = Error("destID or endServerID invalid", message.relayOp)
-            else {
-                message.serverID = message.endServerID
-                message.clientID = getVirtualID(sconn, message.clientID, dconn)
-                message.endServerID = undefined
-                message.destID = undefined
-                dconn.send(message)
-                return
-            }
-        }
-        else {                                                              // response from a destination
-            cdict = welay.virtualIDs[message.clientID]
-            dconn = cdict.sconn                                             // this is original source
-            if !cdict || !dconn
-                error = Error("cannot route reply", message.relayOp)
-            else {
-                message.endServerID = message.serverID
-                message.serverID = welay.serverID
-                message.clientID = cdict.clientID
-                message.destID = dconn.info.destID
-                dconn.send(message)
-                return
-            }
-        }
-        sconn.send({
-            serverID: message.serverID
-            clientID: message.clientID
-            respOp: "error"
-            payload: [error]
-        })
-    }
-
-    // wsOpen
-    //
-    //     Note that a new connection was opened.
-    //
-    welay.wsOpen = function wsOpen(conn) {
-        addConnection(conn)
-    }
-
-    // wsClose
-    //
-    //     Note that an existing connection was closed.
-    //
-    welay.wsClose = function wsClose(conn, local destID, sconn) {
-        removeConnection(conn)
-        if conn.relay
-            for `(destID, sconn) in welay.destIDs
-                sconn.send({
-                    serverID: welay.serverID
-                    clientID: "*"
-                    relayOp: "closed"
-                    info: conn.info
-                })
-    }
-
-    // wsChangeDestID
-    //
-    //     The destID has changed (via the client init message.)
-    //
-    welay.wsChangeDestID = function wsChangeDestID(conn, prevID, newID, local destID, sconn) {
-        welay.destIDs[prevID] = undefined
-        welay.destIDs[newID] = conn
-        conn.info.destID = newID
-        for `(destID, sconn) in welay.destIDs
-            if destID != newID
-                sconn.send({
-                    serverID: welay.serverID
-                    clientID: "*"
-                    relayOp: "opened"
-                    info: conn.info
-                })
-    }
-
-    // finis
-    welay
-};
-
-
 /*
  * ApisInit
  *
@@ -840,7 +632,7 @@ function apisLoadLibs() {
 };
 
 function ApisInit(local manifest) {
-    manifest = `(APIServer, WebSocketGatewayServer, WebSocketConn, WebSocketServer, WesCon, WesRelay,
+    manifest = `(APIServer, WebSocketGatewayServer, WebSocketConn, WebSocketServer, WesCon,
         apisLoadLibs, ApisInit)
 
     Naan.module.build(module.id, "apiserver", function(modobj, compobj) {
@@ -851,4 +643,5 @@ function ApisInit(local manifest) {
     require("./filesystem.nlg")
     psmServerMod = require("./psm_server.nlg")
     workerMod = require("./worker.nlg")
+    serviceMod = require("naanlib:frameworks/service/imp.nlg")
 }();

package/frameworks/node/filesystem.nlg

@@ -6,7 +6,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2017-2022 by Richard C. Zulch
+ * Copyright (c) 2017-2026 by Richard C. Zulch
  *
  */
 
@@ -977,16 +977,41 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
     //
     // shellOpen
     //
-    // Execute the MacOS open utility, returning a standard tuple: `(error, result)
+    // Execute the platform's open utility, returning a standard tuple: `(error, result) which opens
+    // the specified path as a browser URL or invokes a shell script. This is used by the NaaN build
+    // system's "run" function.
+    //     The args option has a dictionary that can override the "runner" utility and set arguments
+    // for specific platform(s):
+    //  {
+    //      darwin: {
+    //          runner: "open"                  // default for platforms not mentioned
+    //          // args: ["--args", <prog arg>] // program arguments if desired
+    //      }
+    //      linux / android: {
+    //          runner: "bash"                  // for <path>.sh or <path>.tool
+    //          runner: "xdg-open"              // all other types
+    //      }
+    //  }
     //
-    files.shellOpen = closure shellOpen(path, args, callback) {
+    files.shellOpen = closure shellOpen(path, args, callback, local platform, runner) {
         if !callback
             return (syncAdapter(shellOpen, path, args))
-        if args
-            args = [path].concat("--args", args)                            // only add target args if specified
+        platform = js.g.process.platform
+        runner = args[platform].runner
+        if runner
+            { }                                                             // explicit runner
+        else if platform == "linux" || platform == "android" {
+            if RegExp("[.]((sh)|(tool))$").test(path)
+                runner = "bash"                                             // execute scripts
+            else
+                runner = "xdg-open"                                         // "open" other things
+        } else
+            runner = "open"                                                 // default runner
+        if args[platform]
+            args = [path].concat(args[platform])                            // has custom args
         else
             args = [path]
-        nodecp.execFile("open",
+        nodecp.execFile(runner,
             args,                                                           // command line args to open
             { },                                                            // execution options
             function(err, stdout, stderr) {
@@ -1041,6 +1066,8 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
         cmdargs.push(options.pattern)
         cmdargs.push(JSpath.resolve(rootpath, localpath))
         execOptions = { cmdargs: cmdargs }
+        if js.g.process.platform == "win32"                                 // to make "-i" work on Windows
+            execOptions.spawnops = { env: merge(js.g.process.env, { LC_ALL: 'en_US.UTF-8' }) }
         result = []
         lineRE = RegExp("([^:]*):([0-9]+):(.*)$")                           // <path>:<line-number>:<matching-text-line>
         if integer(options.maxCount)
@@ -1075,7 +1102,7 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
     // has completed. Options are:
     //  {
     //      cmdargs:            -- array of string arguments to the command (see below)
-    //      execops:            -- optional exec options like cwd
+    //      spawnops:           -- optional spawn options like cwd
     //      errproc:            -- callback for stderr output lines, or false
     //      errLE:              -- string or RegExp for stderr line ending
     //      outproc:            -- optional callback for stdout output lines
@@ -1100,7 +1127,7 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
     //
 
     files.execLines = closure execLines(cmdname, options, callback, 
-        local output, execops, spawn, linerErr, linerOut) {
+        local output, spawnops, spawn, linerErr, linerOut) {
         if !callback
             return (syncAdapter(execLines, cmdname, options))
         if !string(cmdname) || cmdname == ""
@@ -1109,11 +1136,11 @@ closure Filesystem(rootpath, local files, badCreatePathRegEx) {
             output = options.output
         else
             output = {}
-        if options.execops
-            execops = options.execops
+        if options.spawnops
+            spawnops = options.spawnops
         else
-            execops = { }
-        spawn = nodecp.spawn(cmdname, options.cmdargs, execops)
+            spawnops = { }
+        spawn = nodecp.spawn(cmdname, options.cmdargs, spawnops)
 
         // completed
         // execute callback only once

package/frameworks/node/gitter.nlg

@@ -6,7 +6,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2020-2021 by Richard C. Zulch
+ * Copyright (c) 2020-2025 by Richard C. Zulch
  *
  */
 
@@ -56,7 +56,7 @@ closure Gitter(fs, local gitt) {
             asyncResult(callback, false, gitt.roots[repopath])
         execOptions = {
             cmdargs: ["rev-parse", "--show-toplevel"]
-            execops: {
+            spawnops: {
                 cwd: repopath
             }
             outLE: "\x00"                                                   // lines delimited by nulls
@@ -117,7 +117,7 @@ closure Gitter(fs, local gitt) {
         repopath = fs.path.resolve(fs.rootpath, repopath)
         execOptions = {
             cmdargs: ["log", "-z", "--pretty=format:%H|%an|%ae|%aI|%B"]
-            execops: {
+            spawnops: {
                 cwd: repopath
             }
             outLE: "\x00"                                                   // lines delimited by nulls
@@ -168,10 +168,12 @@ closure Gitter(fs, local gitt) {
         if !string(repopath)
             return (asyncResult(callback, Error("invalid path:", repopath)))
         repopath = fs.path.resolve(fs.rootpath, repopath)
-        bridge = bridgePath(repopath)
+		bridge = fs.path.normalize(bridgePath(repopath))                    // ensure it works for our FS
+		if bridge == "."
+		    bridge = ""                                                     // no bridge in this case
         execOptions = {
             cmdargs: ["status", "-z", "--porcelain"]
-            execops: {
+            spawnops: {
                 cwd: repopath
             }
             outLE: "\x00"                                                   // lines delimited by nulls
@@ -219,13 +221,13 @@ closure Gitter(fs, local gitt) {
         repopath = fs.path.resolve(fs.rootpath, repopath)
         execOptions = {
             cmdargs: ["show", options.hash.concat(":", bridgePath(repopath), gitPath(options.pathspec))]
-            execops: {
+            spawnops: {
                 cwd: repopath
             }
         }
         nodecp.execFile("git",
             execOptions.cmdargs,
-            execOptions.execops,
+            execOptions.spawnops,
             function(err, stdout, stderr) {
                 if err
                     callback(Error("git failed", err, stderr))

package/frameworks/node/http_request.nlg

@@ -5,7 +5,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2024-2025 by Richard C. Zulch
+ * Copyright (c) 2024-2026 by Richard C. Zulch
  *
  */
 
@@ -19,8 +19,9 @@
  *  {
  *      method:         <string>                // HTTP method (defaults to GET)
  *      headers:        <dictionary>            // key/data pairs
- *      putdata:        <data>                  // data to put
+ *      putdata:        <data>                  // data to put, either string or JSON
  *      json:           <boolean>               // ignore content-type of return and decode JSON
+ *      debug:          <boolean>               // log errors and status results
  *  }
  *
  * The return is a result tuple comprising:
@@ -34,13 +35,31 @@
  */
 
 closure HttpRequest(url, options,
-    local pending, chunks, params, request) {
+    local host, pending, chunks, params, request, headers, putdata) {
     global(js, nodeHttp)
+    try {
+        host = xnew(js.g.URL, url).host
+        if host.length < 3
+            return (Error("httpRequest: host empty"))
+    } catch {
+        return (Error("httpRequest:", exception))
+    }
     pending = new(nonce)
     chunks = []
+    headers = new(options.headers || [])                                    // modifiable copy or false
+    headers.push(list("Host", host))
+    putdata = options.putdata
+    if putdata {
+        if !string(putdata) {
+            putdata = JSONstringify(putdata)
+            headers.push(list('Content-Type', 'application/json'))
+        }
+        // set explicit content-length to avoid default chunked encoding
+        headers.push(list('Content-Length', putdata.length))
+    }
     params = {
         method: options.method || undefined
-        headers: options.headers || undefined
+        headers: headers || undefined
     }
     request = nodeHttp.request(url, params, closure (response) {
         response.on("data", function (chunk) {
@@ -49,7 +68,12 @@ closure HttpRequest(url, options,
         response.on("end", function (local content, error) {
             content = js.g.Buffer.concat(chunks)
             if response.statusCode < 200 || response.statusCode >= 299 {    // 299 is "cancelled"
-                debuglog("httpRequest status:", url, response.statusCode, "message:", content)
+                if options.debug {
+                    debuglog("httpRequest status:", url, response.statusCode, "message:", response.statusMessage)
+                    if string(putdata)
+                        putdata = putdata.substr(0,250)
+                    debuglog("httpRequest putdata:", putdata)
+                }
                 pending.signal(list(Error("httpRequest statusCode:", url, response.statusCode, {
                     status: response.statusCode
                 }), false, { status: response.statusCode }))
@@ -63,23 +87,20 @@ closure HttpRequest(url, options,
             else
                 error = Error("httpRequest terminated prematurely:", url, response.statusCode)
             pending.signal(list(error, content, {
-                headers: response.headers
+                headers: new(response.headers)
                 status: response.statusCode
                 contentType: response.headers["content-type"]
             }))
         })
     })
     request.on("error", function hre(error) {
-        debuglog("httpRequest error:", url, "error:", error)
+        if options.debug
+            debuglog("httpRequest error:", url, "error:", error)
         error = Error("httpRequest failed:", url, error)
         pending.signal(list(error))
     })
-    if options.putdata {
-        if string(options.putdata)
-            request.write(options.putdata)
-        else
-            request.write(JSONstringify(options.putdata))
-    }
+    if putdata
+        request.write(putdata)
     request.end()
     pending.wait()
 };

package/frameworks/node/https_request.nlg

@@ -5,7 +5,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2021-2024 by Richard C. Zulch
+ * Copyright (c) 2021-2026 by Richard C. Zulch
  *
  */
 
@@ -123,12 +123,17 @@ closure httpsApiReqOnce(url, options,
             else
                 content = js.g.Buffer.concat(chunks)
             if response.statusCode < 200 || response.statusCode >= 299 {    // 299 is "cancelled"
-                if options.debug
+                if options.debug {
+                    content = content.toString()
                     debuglog("HttpsApiRequest status:", url, response.statusCode, "message:", content)
+                    if string(putdata)
+                        putdata = putdata.substr(0,250)
+                    debuglog("HttpsApiRequest putdata:", putdata)
+                }
                 pending.signal(list(Error("HttpsApiRequest statusCode:", url, response.statusCode, {
                     status: response.statusCode
                 }), false, {
-                    headers: response.headers
+                    headers: new(response.headers)
                     status: response.statusCode
                 }))
                 return

package/frameworks/node/node.nlg

@@ -124,6 +124,7 @@ function nodrInit(local manifest) {
         throw("module frameworks/node cannot be used from a browser")
     Naan.module.build(module.id, "node", function(modobj, compobj) {
         require("../common/").LiveImport()
+        commonWatching = require("../common/watching.nlg")
         compobj.manifest = manifest
         function nodrReload() {
             nodecp = js.r("child_process")
@@ -139,5 +140,6 @@ function nodrInit(local manifest) {
         module.reload = nodrReload
         module.exports.NaanlangDir = NaanlangDir
         module.exports.NaanlangRC = NaanlangRC
+        module.exports.NodeStreamLiner = NodeStreamLiner
     })
 } ();