mindvest-atlas 0.43.1 → 0.45.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindvest-atlas",
-  "version": "0.43.1",
+  "version": "0.45.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,7 +105,87 @@ 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. */
+/** What using the computer needs, and what it is called when you import it. */
+const NEEDED = [['pyautogui', 'pyautogui'], ['mss', 'mss'], ['Pillow', 'PIL']];
+
+/**
+ * Put what is missing into the interpreter that is ABOUT TO BE USED.
+ *
+ * Atlas installs these when the switch goes on, but into the ambient python,
+ * and a project with a venv of its own runs on that instead: the switch said
+ * ready and the run then found nothing. The interpreter here is the one the
+ * work will happen in, which is the only one worth checking.
+ *
+ * Best effort and quiet: a machine with no network or no pip is one that runs
+ * without it, and every call site already says what it cannot do.
+ */
+export function ensureDeps(python, cwd, env) {
+  const check = `import ${NEEDED.map(([, mod]) => mod).join(', ')}`;
+  const has = () => spawnSync(python[0], [...python.slice(1), '-c', check],
+    { cwd, env, stdio: 'ignore' }).status === 0;
+  if (has()) return true;
+  println(color.dim('  Getting this computer ready (one time)…'));
+  // --user is wrong inside a venv and right outside one, so ask the interpreter
+  // which it is in rather than guessing.
+  const inVenv = spawnSync(python[0],
+    [...python.slice(1), '-c', 'import sys; sys.exit(0 if sys.prefix != sys.base_prefix else 1)'],
+    { cwd, env, stdio: 'ignore' }).status === 0;
+  const args = ['-m', 'pip', 'install', '--quiet', ...(inVenv ? [] : ['--user'])];
+  spawnSync(python[0], [...python.slice(1), ...args, ...NEEDED.map(([name]) => name)],
+    { cwd, env, stdio: 'ignore', timeout: 300000 });
+  return has();
+}
+
 export function runInProject(job, code, root) {
   const { dir } = workspace(job, root);
   if (!fs.existsSync(dir)) {
@@ -116,6 +196,10 @@ export function runInProject(job, code, root) {
   const venv = venvPython(dir);
   const python = venv ? [String(venv)] : [...ambientPython()];
   const env = { ...process.env, ...jobEnv(dir), ATLAS_JOB: path.basename(dir) };
+  // BEFORE ANYTHING TRIES TO IMPORT THEM. Checked every time and installed only
+  // when something is missing, so the cost is one python start on a machine
+  // that is already set up.
+  ensureDeps(python, dir, env);
   // THE SAME HOLDER FOR EVERY COMMAND in this shell, and no process behind the
   // claim: each of these exits, and a claim needing a live process would be
   // gone before the next one ran.
@@ -161,6 +245,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 +300,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.1';
+export const VERSION = '0.45.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

@@ -1210,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.