mindvest-atlas 0.44.0 → 0.46.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindvest-atlas",
-  "version": "0.44.0",
+  "version": "0.46.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

@@ -155,6 +155,37 @@ export function askServer(job, op, args, root) {
 }
 
 /** 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)) {
@@ -165,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.

package/src/config.js

@@ -2,7 +2,7 @@
 import path from 'node:path';
 import os from 'node:os';
 
-export const VERSION = '0.44.0';
+export const VERSION = '0.46.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

@@ -843,6 +843,27 @@ def _do(action, fn, detail=None, points=()):
     if holder:
         _log_action(action, detail, ok=False, error="in use by %s" % (holder.get("job") or "another project"))
         raise RuntimeError(_busy(holder))
+    # AND NEVER ON ATLAS'S OWN STRIP. It is excluded from screen capture, so it
+    # is never in a picture, and it is still a window that takes clicks: a
+    # position read off a picture that happens to be under it presses Stop and
+    # ends the run, which then has no idea what it pressed (owner, 2026-09-06:
+    # "the agent should be careful so it does not stop itself").
+    #
+    # Atlas keeps the strip off the screen a run is working on where it can, and
+    # puts none up at all on a single screen. This is the second line: a refusal
+    # that holds whatever the placement decided, and on any machine whose window
+    # titles cannot be read.
+    if action in _ACTS_ON_A_WINDOW:
+        for point in points:
+            if _on_the_strip(*point):
+                _log_action(action, detail, ok=False, error="on the Atlas strip")
+                raise RuntimeError(
+                    "(%s, %s) is under the Atlas strip, which is the bar showing "
+                    "what this run is doing. It is not in the picture because it "
+                    "is excluded from capture, and pressing it would stop this "
+                    "run. Whatever you meant to click is elsewhere: look again."
+                    % (point[0], point[1])
+                )
     # NOT INSIDE ATLAS UNLESS SOMEBODY SAID SO. Checked at the moment of acting
     # rather than when the window was focused: what matters is where the click
     # lands, and the front window can change between the two.
@@ -1653,6 +1674,31 @@ def _front_window():
         return ""
 
 
+def _on_the_strip(x, y):
+    """Is this point under Atlas's own driving strip?
+
+    The strip writes where it is, because nothing else can see it: it is
+    excluded from capture, so a picture never shows it and no amount of looking
+    would find it.
+    """
+    import json as _json
+    root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    try:
+        with open(os.path.join(root, ".studio", "strip.json"), encoding="utf-8") as fh:
+            box = _json.load(fh)
+        # A note left by a strip that has gone is not a no-go area for ever.
+        import time as _time
+        if _time.time() - float(box.get("at") or 0) > 120:
+            return False
+        # A little margin: a click at the very edge of it is still a click
+        # somebody did not mean to make there.
+        pad = 6
+        return (int(box["x"]) - pad <= int(x) <= int(box["x"]) + int(box["width"]) + pad
+                and int(box["y"]) - pad <= int(y) <= int(box["y"]) + int(box["height"]) + pad)
+    except Exception:
+        return False
+
+
 def _in_the_atlas_window():
     front = _front_window().lower()
     return any(name in front for name in _ATLAS_WINDOWS) if front else False