@naanlang/naan 1.6.0 → 1.7.0

package/frameworks/client/apiclient.nlg

@@ -19,7 +19,7 @@ serviceMod;;
 /*
  * APIClient
  *
- * Make an API client object.
+ * Make an API client object. If you want websockets, and you do, call connect() on the object.
  *
  * Options:
  *  {
@@ -46,18 +46,20 @@ closure APIClient(imp, options, local client, url, guid) {
     client.requester = clirRequester()
 
     //
-    // wsopen
+    // connect
     //
 
-    client.wsopen = function wsopen(error) {
-        if !client.wesc {
+    client.connect = function connect(error) {
+        if !client.wesc
             client.wesc = WebSocketClient(options, imp)
-            `(error) = client.wesc.connect()
-            if error
-                ErrorDebuglog("APIClient: cannot connect to", url)
+        `(error) = client.wesc.connect()
+        if error {
+            ErrorDebuglog("APIClient: cannot connect to", url, error)
+            return (list(error))
         }
+        client.serverID = client.wesc.serverID                              // serverID
+        list(false, { connected: true })
     }
-    wsopen()
 
     // clientRequest() - append our guid to the headers
 
@@ -178,10 +180,12 @@ closure APIClient(imp, options, local client, url, guid) {
     // Close down the client and release all resources.
     //
     client.destroy = closure destroy() {
-        debuglog("client destroy websocket")
+        debuglog("API client destroyed")                                    // ### not pretty, but uncommon
         client.wesc.destroy()
         client.wesc = false
     }
+    
+    // finis
 
     client
 };
@@ -197,25 +201,38 @@ closure APIClient(imp, options, local client, url, guid) {
  *  {
  *      url:            <string>                // hostname or URL of the remote server
  *      guid:           <string>                // shared secret for access to remote server
- *      instanceID:     <string>                // UUID for our client; can be persisted by caller
  *  }
  *
  */
 
-closure WebSocketClient(options, imp, local wesc, ws) {
+closure WebSocketClient(options, imp, local wesc, ws, pending) {
     global(js)
     wesc = new(object, this)
 
+    // reconnect
+    //
+    // Attempt to reconnect if needed, returning false on success or an error tuple otherwise.
+    //
+    function reconnect() {
+        if !ws || wesc.fatal || pending {
+            connect()                                                       // try to connect
+            if wesc.fatal
+                return (list(wesc.fatal))
+        }
+        false
+    }
+
     // connect
     //
     // Establish a websocket connection with the host.
     //
-    wesc.connect = closure connect(local url, pending) {
-        if ws && !wesc.fatal
-            return(list(false, { connected: true }))
-        if wesc.fatal
-            debuglog("WebSocketClient reopen")
-        wesc.fatal = false
+    wesc.connect = closure connect(local url, result) {
+        if ws {
+            if pending
+                return (pending.wait())                                     // connect in process
+            if !wesc.fatal
+                return(list(false, { connected: true }))                    // already open
+        }
         try {
             url = xnew(js.w.URL, options.url)
         } catch {
@@ -226,27 +243,35 @@ closure WebSocketClient(options, imp, local wesc, ws) {
         else
             url.protocol = "ws:"
         ws = xnew(js.w.WebSocket, url.href)
+        if wesc.fatal
+            debuglog("WebSocketClient reopen")                              // ### not pretty to see this
+        wesc.fatal = false
         pending = new(nonce)
-    
+
         // onopen
         // The WebSocket connection is now open.
-        ws.onopen = function onopen(e, local error) {
+        ws.onopen = function onopen(e) {
+            if wesc.impconn {
+                result = wesc.impconn.reopen()
+                pending.signal(result)
+                return
+            }
             wesc.impconn = imp.requester(function(data) {
-                if wesc.fatal                                               // raw send function
-                    return (list(wesc.fatal))
+                if !pending && reconnect()                                  // !pending means not opening/reopening
+                    return                                                  // failed to reconnect
                 ws.send(js.w.JSON.stringify(data))
                 list(false, { sent: true })
             }, {
                 secret: options.guid
                 label: "api-server"
-                wesc: wesc
             })
-            if error
-                pending.signal(list(error))
-            else
+            wesc.impconn.addEventListener("active", function (event, info) {
+                wesc.serverID = info.destID                                 // serverID we connected to
                 pending.signal(list(false, { ok: true }))
+                pending = false
+            })
         }
-    
+
         // onmessage
         // A message was received via WebSockets.
         ws.onmessage = function onmessage(e, local error, message) {
@@ -256,9 +281,11 @@ closure WebSocketClient(options, imp, local wesc, ws) {
                 if wesc.impconn.dispatch(message)
                     return
             }
-            debuglog("socket message:", e.data)
+            pending.signal(list(Error("incompatible responder")))
+            pending = false
+            debuglog("socket message:", e.data)                             // unexpected incoming data
         }
-    
+
         // onerror
         // An error occurred on the WebSocket connection.
         // This can happen in normal operation when the connection times out.
@@ -266,35 +293,34 @@ closure WebSocketClient(options, imp, local wesc, ws) {
             if !wesc.fatal
                 wesc.fatal = Error("websocket failed", e)
             pending.signal(list(wesc.fatal))
+            pending = false
         }
         
         // onclose
         // The WebSocket connection was closed.
         ws.onclose = function onclose(e) {
             // if e.code != 1000 && e.code != 1001 && e.code != 1005 && e.code != 1006
-                debuglog("WebSocketClient: closed:", e.code, e.reason)
+                debuglog("WebSocketClient: closed:", e.code, e.reason)      // ### not pretty to see this
             ws = false
             if !wesc.fatal
                 wesc.fatal = Error("websocket closed", e.code, e.reason)
             pending.signal(list(wesc.fatal))
-            wesc.impconn.close({
-                code: e.code
-                reason: e.reason
-            })
-            wesc.impconn = false
+            pending = false
         }
 
-        pending.wait()
+        result = pending.wait(10000, list(Error("IMP connection timeout")))
+        pending = false
+        result
     }
-    
+
     // close
     //
     // Close the connection, but can be opened again with connect().
     //
     wesc.close = function close() {
-        if !ws
-            return
-        ws.close(1000)                                                      // 1000: normal close
+        if ws
+            ws.close(1000)                                                  // 1000: normal close
+        ws = false
     }
     
     // destroy
@@ -303,23 +329,27 @@ closure WebSocketClient(options, imp, local wesc, ws) {
     //
     wesc.destroy = function destroy() {
         close()
+        wesc.impconn.destroy()
+        wesc.impconn = false
     }
 
     // send
     //
-    // Send a message.
+    // Send a message, returning result tuple.
     //
     wesc.send = closure send(data) {
-        if wesc.fatal
-            return (wesc.fatal)
+        if reconnect()
+            return                                                          // failed to reconnect
         wesc.impconn.send(data)
     }
 
     // sendRaw
     //
-    // Send a message with reconnect but no routing.
+    // Send a message with reconnect but no routing. Returns a result tuple.
     //
     wesc.sendRaw = closure sendRaw(data) {
+        if reconnect()
+            return                                                          // failed to reconnect
         ws.send(data)
     }
 

package/frameworks/client/psm_client.nlg

@@ -634,18 +634,14 @@ closure psmcFsConnector(psm, api, local connClassID, connector, watch) {
             else {
                 api = connector.apis[creds.urlName]
                 if !api {                                                   // create API to remote server
-                    connector.apis[creds.urlName] = api = APIClient({
+                    api = APIClient(App.imp, {
                         url: creds.urlName
                         guid: creds.authSecret
-                        instanceID: creds.instanceID
                     })
-                    if creds.instanceID != api.instanceID {                 // update our client instanceID
-                        creds.instanceID = api.instanceID
-                        `(error) = connector.vault.updateResource(resID, creds)
-                    }
-                }
-            }
-        }
+                    `(error) = api.connect()
+                    if !error
+                        connector.apis[creds.urlName] = api
+                } } }
         if error
             list(error)
         else if service == "NideTerminal" {
@@ -653,11 +649,11 @@ closure psmcFsConnector(psm, api, local connClassID, connector, watch) {
                 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
-                    // }
+                merge(args.1, {
+                    serverID: api.serverID                                  // server we found
+                    // workerID: "NideServer"  -- for main thread; other strings for worker threads
+                    // type: "My Remotes"      -- display name of terminal group; e.g. URL
+                })))                                                    // options:
         }
         else if service == "NideHostAPI"
             list(false, api)                                                // connect to the Host API

package/frameworks/common/common.nlg

@@ -247,6 +247,8 @@ macro LoadComponentOnDemand(functionKeys, componentPath, local modobj, key) {
 macro LiveExport() {
     global()
     closure (exporterMod, local importList) {
+        if !exporterMod
+            return (false)                                                  // no module (e.g. build time)
         importList = []
         //
         // LiveImport

package/frameworks/node/apiserver.nlg

@@ -126,7 +126,6 @@ closure APIServer(options, local server, chroot) {
             return (list(error))
         }
         server.hostfs = hostfs
-        server.workco = workerMod.WorkerController()
         server.Register(server.workco.serverID, server.workco)
 
         list(false, port)

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()
+        require("../common/events.nlg")
         commonWatching = require("../common/watching.nlg")
         compobj.manifest = manifest
         function nodrReload() {

package/frameworks/node/pty.nlg

@@ -102,8 +102,9 @@ closure ptyManagerMain(local ptym, pty) {
     //
     // Close the pty manager, killing any open spawned processes.
     //
-    ptym.close = closure close() {
-        // ### kill any open spawned processes
+    ptym.close = closure close(local worker) {
+        for worker in ptym.workers
+            worker.kill()
     }
 
     // spawn
@@ -111,14 +112,16 @@ closure ptyManagerMain(local ptym, pty) {
     // Spawn a new pty process, returning a result tuple. If executable is omitted then a shell is
     // spawned.
     // 
-    // options:
+    // options: (all optional)
     //  {
-    //      workerGUID: <string>                // if specified, kills pty process when worker terminates
+    //      cwd:        <string>                // current working directory
+    //      env:        <string>                // environment
+    //      raw:        <boolean>               // enable raw mode with ioctls
     //  }
     // 
     //
     ptym.spawn = closure spawn(executable, args, notify, options,
-        local ptySpawned, ptypro) {
+        local error, ptySpawned, ptypro) {
 
         if !executable {
             if os.platform() == "win32"
@@ -136,6 +139,10 @@ closure ptyManagerMain(local ptym, pty) {
             env: js.g.process.env
         }, options)
 
+        `(error) = open()                                                   // ensure we're open
+        if error
+            return (list(error))
+
         ptySpawned = pty.spawn(executable, args, {                          // spawn the pty process
             name: options.name
             cols: options.cols
@@ -147,7 +154,6 @@ closure ptyManagerMain(local ptym, pty) {
         ptypro = ptyProcess(ptySpawned, notify)
         ptym.workers.push({                                                 // track all pty processes
             pid: ptySpawned.pid
-            workerGUID: options.workerGUID || undefined
             ptySpawned: ptySpawned
         })
 
@@ -160,19 +166,6 @@ closure ptyManagerMain(local ptym, pty) {
             ptypro.killed(event)
         })
 
-        if options.workerGUID
-            WorkerController().watcher.watch(
-                function(action, worker, local ptydex) {                    // worker-owner of pty process died
-                    if action == "terminated" {
-                        ptydex = ptym.workers.findIndex(function(item) {
-                            options.workerGUID == item.workerGUID
-                        })
-                        if ptydex >= 0 {
-                            ptySpawned.kill()
-                            ptym.workers.splice(ptydex)
-                        }
-                    }
-                })
         list(false, ptypro)
     }
 
@@ -238,7 +231,14 @@ closure ptyProcess(ptySpawned, notify, local ptyp) {
     // Kill the spawned process.
     //
     ptyp.kill = closure kill(signame) {
-        ptySpawned.kill(signame)
+        if signame
+            ptySpawned.kill(signame)                                        // use caller signal
+        else {
+            ptySpawned.kill("SIGTERM")                                      // SIGTERM/SIGKILL sequence
+            sleep(1000)
+            if ptySpawned
+                ptySpawned.kill("SIGKILL")
+        }
     }
 
     // finis
@@ -268,7 +268,7 @@ closure ptyManagerWorker(local ptyw, mainContext, mainPty) {
         }
 
         if !mainContext {
-            `(error, main) = require("naanlib:frameworks/running/mainthread.nlg").MainThread()
+            `(error, main) = require("naanlib:frameworks/running/remote_req.nlg").MainThread()
             if !error
                 `(error, mainContext) = main.context()
             if error

package/frameworks/node/shell.nlg

@@ -6,7 +6,7 @@
  *
  * column positioning:                          //                          //                      !
  *
- * Copyright (c) 2024-2025 by Richard C. Zulch
+ * Copyright (c) 2024-2026 by Richard C. Zulch
  *
  */
 
@@ -28,7 +28,7 @@
  */
 
 closure ShellConnect(options, local shob, error, fs, xparser, shelly) {
-    global(js, compress)
+    global(js, compress, App)
     shob = new(object, this)
 
     // readline
@@ -78,6 +78,26 @@ closure ShellConnect(options, local shob, error, fs, xparser, shelly) {
         pending.wait()
     }
 
+    // pty
+    //
+    // Execute a shell command in a PTY terminal with optional current-working-directory.
+    //
+    shob.pty = closure pty(cmd, args, cwd, local exec, error, options, ptyp) {
+        exec = App.exec
+        if !exec
+            `(error, exec) = App.workerNub.execProxy()
+        if !error {
+            options = { input:"keyboard", output:"display", raw:true }
+            if cwd
+                options.spawn = { cwd: cwd }
+            `(error, ptyp) = exec.subprocess(cmd, args, options)
+        }
+        if ptyp
+            list(false, ptyp)
+        else
+            exec(cmd, args, cwd)
+    }
+
     // shellparser
     // intercept command-line parsing and look for a !shell escape
     function shellparser(source, grammar, operators, local token, text) {
@@ -89,7 +109,10 @@ closure ShellConnect(options, local shob, error, fs, xparser, shelly) {
                 atom: `;;
                 loc: tuple(0, text.length)
             })
-            exec("bash", ["-c", text], js.d)                                // default directory: js.d
+            if text == "\n"
+                pty()
+            else
+                exec("bash", ["-c", text], js.d)                            // default directory: js.d
 	    }
         else {
             source.tokenpush(token)