mindvest-atlas 0.43.0 → 0.44.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindvest-atlas",
-  "version": "0.43.0",
+  "version": "0.44.0",
   "description": "Atlas CLI \u2014 OAuth login, tool calls, and live alert/flow streaming for the Atlas trading API",
   "type": "module",
   "bin": {

package/src/commands/computer-use.js

@@ -105,6 +105,55 @@ export function shellSession(root) {
   return made;
 }
 
+/**
+ * Ask the session's live process to do it. null when there is none.
+ *
+ * THE FAST PATH, and never the only one. Spawning python per action pays for a
+ * start and pyautogui's imports every time, which on Windows is most of a
+ * second for work that takes twenty milliseconds. One process stays up for the
+ * session and this talks to it.
+ *
+ * Nothing here throws: an unreachable server is an absence, not an error, and
+ * every caller falls back to spawning. A machine where this cannot run is
+ * slower and never broken.
+ */
+export function askServer(job, op, args, root) {
+  const { dir } = workspace(job || '', root);
+  const session = process.env.ATLAS_COMPUTER_SESSION || shellSession(root);
+  const note = path.join(dir, '.computer-use', session, 'serve.json');
+  let port;
+  let token;
+  try {
+    const n = JSON.parse(fs.readFileSync(note, 'utf8'));
+    port = Number(n.port);
+    token = String(n.token);
+  } catch {
+    return null;
+  }
+  // A synchronous ask, because this command has nothing else to do until the
+  // answer comes and the caller is a plain exit code.
+  const body = JSON.stringify({ token, op, args: args || [], kwargs: {} });
+  const out = spawnSync(process.execPath, ['-e', `
+    const net = require('node:net');
+    const s = net.connect(${port}, '127.0.0.1');
+    let got = '';
+    s.setTimeout(120000, () => { s.destroy(); process.exit(3); });
+    s.on('connect', () => s.write(process.argv[1] + '\n'));
+    s.on('data', (d) => { got += d; if (got.includes('\n')) { process.stdout.write(got); s.end(); } });
+    s.on('error', () => process.exit(3));
+  `, body], { encoding: 'utf8' });
+  if (out.status !== 0 || !out.stdout) {
+    // A note pointing at a port nobody answers is what a crash leaves behind.
+    try { fs.rmSync(note, { force: true }); } catch { /* it may be gone */ }
+    return null;
+  }
+  try {
+    return JSON.parse(out.stdout.trim().split('\n').pop());
+  } catch {
+    return null;
+  }
+}
+
 /** Run one atlas_env call inside the project, and hand back what it said. */
 export function runInProject(job, code, root) {
   const { dir } = workspace(job, root);
@@ -161,6 +210,9 @@ export function computerUseCommand(args) {
   }
 
   if (sub === 'stop') {
+    // The live process goes with the computer: leaving it up would hold
+    // pyautogui and a port for a session that is over.
+    askServer(job, '_bye');
     // Given back by NAME, so one shell cannot release another's hold.
     const released = releaseComputerClaim(shellSession());
     println(color.dim(released ? 'Gave the computer back.' : 'It was not yours to give back.'));
@@ -213,6 +265,16 @@ export function computerUseCommand(args) {
     return 1;
   }
   const values = rest.map((v) => (NUMERIC.has(sub) ? Number(v) : v));
+  // THE LIVE PROCESS FIRST: same function, same rules, without a python start.
+  const answer = askServer(job, name, values);
+  if (answer) {
+    if (answer.ok) {
+      println(JSON.stringify(answer.out, null, 2));
+      return 0;
+    }
+    eprintln(color.red(String(answer.error || 'That did not work.')));
+    return 1;
+  }
   // JSON rather than pasting: the text may hold quotes, and a snippet built by
   // pasting is a snippet that breaks on somebody's password.
   const code = 'import atlas_env as e, json\n'

package/src/config.js

@@ -2,7 +2,7 @@
 import path from 'node:path';
 import os from 'node:os';
 
-export const VERSION = '0.43.0';
+export const VERSION = '0.44.0';
 export const DEFAULT_BASE_URL = 'https://atlasmcp.finmanagerai.com';
 export const DEFAULT_SCOPE = 'atlas broker';
 export const CLIENT_NAME = 'Atlas CLI';

package/src/helpers/atlas_env.py

@@ -1172,9 +1172,30 @@ def screen(path=None):
                 _tools.to_png(shot.rgb, shot.size, output=out)
             return out
         except ImportError:
-            # One screen is all pyautogui can offer, and it is the primary.
-            # Say which was taken rather than letting a two-monitor desk assume.
-            _gui().screenshot().save(out)
+            # WITHOUT mss, STILL THE RIGHT SCREEN. This used to photograph the
+            # whole primary display whatever use_screen had said, and then the
+            # log recorded "Looked at screen 2" beside a picture of screen 1
+            # (owner, 2026-09-06: "the screener and screenshot not taking the
+            # right"). A picture that lies about which screen it is of is worse
+            # than no picture: everything measured on it is measured on the
+            # wrong desk.
+            #
+            # pyautogui can grab a REGION of the virtual desktop, which is all
+            # this ever needed. Nothing about it requires mss; mss is only
+            # faster.
+            try:
+                shot = _gui().screenshot(region=(int(m["x"]), int(m["y"]),
+                                                 int(m["width"]), int(m["height"])))
+            except Exception as err:
+                # Some platforms cannot reach a monitor left of the origin, where
+                # x is negative. Say so rather than handing back the primary and
+                # letting every coordinate read off it be wrong.
+                raise RuntimeError(
+                    "Could not photograph screen %s on this computer (%s). Install "
+                    "mss for multi-screen capture, or use_screen(%s) to work on "
+                    "the main one." % (m["index"], err, _primary_index(screens()))
+                )
+            shot.save(out)
             return out
     out = _do("screen", take, {"monitor": m["index"]})
     # A BARE PATH ON A SINGLE SCREEN, because that is what it has always been and
@@ -1189,6 +1210,136 @@ def screen(path=None):
                     % (m["x"], m["y"])}
 
 
+# ── STAYING ALIVE BETWEEN COMMANDS ──────────────────────────────────────────
+#
+# WHERE THE TIME ACTUALLY WENT. Working the computer from a shell is one process
+# per action, and the process is the expensive part: python starts, imports
+# pyautogui (which pulls in Pillow, pyscreeze and mouseinfo), does something
+# that takes twenty milliseconds, and exits. On Windows that is most of a second
+# for every click (owner, 2026-09-06: the iteration cycle of doing a command,
+# checking, going back).
+#
+# So one process stays up for the session and everything else talks to it. The
+# imports are paid once; an action becomes a message.
+#
+# IT IS ALWAYS OPTIONAL. Every caller falls back to spawning a process the old
+# way when there is nothing listening, so a machine where this cannot run is
+# slower and never broken.
+#
+# A TOKEN, BECAUSE IT IS A PORT. Bound to 127.0.0.1 only, but any other program
+# on the machine can reach that, and what is on the other end moves the mouse
+# and types. The token is written beside the port in a file only this user can
+# read, and a request without it is refused.
+SERVE_IDLE_S = 900
+
+
+def _serve_note():
+    return os.path.join(_session_dir(), "serve.json")
+
+
+def serve(idle_s=SERVE_IDLE_S):
+    """Stay up and do what is asked, so a run stops paying start-up per click.
+
+    Ends by itself after a quarter of an hour with nothing to do, so a forgotten
+    one cannot sit holding the computer for ever.
+    """
+    import json as _json
+    import socket
+    import threading
+    import time as _time
+
+    srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    srv.bind(("127.0.0.1", 0))
+    srv.listen(16)
+    port = srv.getsockname()[1]
+    token = base64_token()
+    note = {"port": port, "token": token, "pid": os.getpid(), "at": _time.time()}
+    try:
+        with open(_serve_note(), "w", encoding="utf-8") as fh:
+            _json.dump(note, fh)
+        try:
+            os.chmod(_serve_note(), 0o600)
+        except OSError:
+            pass
+    except OSError:
+        return
+
+    # WARM BEFORE THE FIRST REQUEST, which is the entire point: importing on the
+    # first click would just move the wait rather than remove it.
+    try:
+        _gui()
+    except Exception:
+        pass
+
+    last = [_time.time()]
+
+    def reap():
+        while True:
+            _time.sleep(5)
+            if _time.time() - last[0] > idle_s:
+                try:
+                    os.remove(_serve_note())
+                except OSError:
+                    pass
+                os._exit(0)
+
+    threading.Thread(target=reap, daemon=True).start()
+
+    while True:
+        try:
+            conn, _ = srv.accept()
+        except OSError:
+            return
+        try:
+            conn.settimeout(300)
+            raw = b""
+            while not raw.endswith(b"\n"):
+                chunk = conn.recv(65536)
+                if not chunk:
+                    break
+                raw += chunk
+            req = _json.loads(raw.decode("utf-8") or "{}")
+            if req.get("token") != token:
+                reply = {"ok": False, "error": "not for you"}
+            elif req.get("op") == "_bye":
+                conn.sendall((_json.dumps({"ok": True}) + "\n").encode("utf-8"))
+                conn.close()
+                try:
+                    os.remove(_serve_note())
+                except OSError:
+                    pass
+                os._exit(0)
+            else:
+                last[0] = _time.time()
+                fn = globals().get(str(req.get("op")))
+                if not callable(fn):
+                    reply = {"ok": False, "error": 'no "%s" here' % req.get("op")}
+                else:
+                    try:
+                        out = fn(*(req.get("args") or []), **(req.get("kwargs") or {}))
+                        reply = {"ok": True, "out": out}
+                    except Exception as err:
+                        # The MESSAGE, not a traceback: the caller prints this to
+                        # somebody, and every refusal here is written to say
+                        # what to do next.
+                        reply = {"ok": False, "error": str(err)}
+            conn.sendall((_json.dumps(reply, default=str) + "\n").encode("utf-8"))
+        except Exception:
+            # One bad connection is not a reason to stop serving the rest.
+            pass
+        finally:
+            try:
+                conn.close()
+            except Exception:
+                pass
+
+
+def base64_token():
+    import base64
+    return base64.urlsafe_b64encode(os.urandom(18)).decode("ascii").rstrip("=")
+
+
 def _screen_changed(path):
     """True when this picture differs from the one before it.