mindvest-atlas 0.35.0 → 0.40.0

package/package.json

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

package/src/config.js

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

@@ -923,12 +923,18 @@ def screens():
     try:
         import mss as _mss
         with _mss.mss() as sct:
-            out = []
-            for i, m in enumerate(sct.monitors[1:], start=1):
-                out.append({"index": i, "x": m["left"], "y": m["top"],
-                            "width": m["width"], "height": m["height"],
-                            "primary": m["left"] == 0 and m["top"] == 0})
-            return out
+            # LEFT TO RIGHT, ALWAYS. The number has to mean the same monitor
+            # every time it is said, and it was not: this path took whatever
+            # order the OS gave, the fallback below sorted top-to-bottom, and
+            # the app's picker used a third. So screen 1 could be the RIGHT-hand
+            # monitor, a run bound itself to it, and a click on the left one was
+            # refused for being "not on screen 1" (owner, 2026-09-05). Left to
+            # right is also how people say it.
+            mons = sorted(sct.monitors[1:], key=lambda m: (m["left"], m["top"]))
+            return [{"index": i, "x": m["left"], "y": m["top"],
+                     "width": m["width"], "height": m["height"],
+                     "primary": m["left"] == 0 and m["top"] == 0}
+                    for i, m in enumerate(mons, start=1)]
     except ImportError:
         pass
     # WITHOUT mss, WINDOWS CAN STILL COUNT ITS OWN MONITORS. Reporting one
@@ -957,10 +963,9 @@ def screens():
 
             ctypes.windll.user32.EnumDisplayMonitors(0, 0, proto(each), 0)
             if found:
-                # In the order Windows reports them, with the one at the origin
-                # named primary: the same convention mss uses, so a number means
-                # the same monitor whichever path answered.
-                found.sort(key=lambda m: (m[1], m[0]))
+                # The SAME order as the mss path above: left to right, so a
+                # number means the same monitor whichever one answered.
+                found.sort(key=lambda m: (m[0], m[1]))
                 return [{"index": i, "x": x, "y": y, "width": w, "height": h,
                          "primary": x == 0 and y == 0}
                         for i, (x, y, w, h) in enumerate(found, start=1)]
@@ -1058,6 +1063,26 @@ def _on_screen(x, y):
     inside = (m["x"] <= int(x) < m["x"] + m["width"]) and (m["y"] <= int(y) < m["y"] + m["height"])
     if inside:
         return
+    # THE COMMONEST WAY TO BE WRONG HERE IS ALSO THE EASIEST TO FIX FOR YOU.
+    #
+    # A picture of screen 2 is an image 1920 wide whose top left is 0,0, but the
+    # pointer lives on the whole desktop, where that same corner is 1920,0. So a
+    # position read honestly off the picture lands one screen to the left, and
+    # on a two-monitor desk that is EVERY click (owner, 2026-09-05: "it
+    # struggles for mouse click on multiple screen"). Saying "not on screen 2"
+    # is true and leaves you to work out why.
+    #
+    # If adding this screen's origin would have put the point on it, that is
+    # what happened, so say the number that works.
+    shifted_x, shifted_y = int(x) + m["x"], int(y) + m["y"]
+    if (m["x"] <= shifted_x < m["x"] + m["width"]) and (m["y"] <= shifted_y < m["y"] + m["height"]):
+        raise RuntimeError(
+            "(%s, %s) reads like a position measured INSIDE the picture of "
+            "screen %s, but clicks land on the whole desktop, where that screen "
+            "starts at x %s, y %s. Use (%s, %s) instead: add the screen's origin "
+            "to anything you read off its picture. screen() reports that origin."
+            % (x, y, m["index"], m["x"], m["y"], shifted_x, shifted_y)
+        )
     raise RuntimeError(
         "(%s, %s) is not on screen %s, which is what this run is working on "
         "(it covers x %s..%s, y %s..%s). Call use_screen() to move to another "
@@ -1073,6 +1098,20 @@ def screen(path=None):
     was is written into the log, so a replay never leaves you wondering what you
     are looking at.
 
+    WHAT COMES BACK IS THE PATH, and on a multi-screen machine also where that
+    screen STARTS:
+
+        {"path": "...png", "screen": 2, "x": 1920, "y": 0,
+         "note": "add x 1920, y 0 to positions you read off this picture"}
+
+    That matters and it is the easiest thing here to get wrong. The picture is
+    an image whose top left is 0,0; the pointer lives on the whole desktop,
+    where that same corner may be 1920,0. A position read straight off the
+    picture and clicked lands one screen to the left, and on a two-monitor desk
+    that is EVERY click. Add the origin.
+
+    On a single screen the origin is 0,0 and this is just the path, as before.
+
     Not dashboard.shot(): that one draws this project's DASHBOARD in a frame. Two
     things called screenshot, one of them the whole desktop, is a mistake
     somebody makes once with a real click.
@@ -1094,21 +1133,48 @@ def screen(path=None):
             # Say which was taken rather than letting a two-monitor desk assume.
             _gui().screenshot().save(out)
             return out
-    return _do("screen", take, {"monitor": m["index"]})
+    out = _do("screen", take, {"monitor": m["index"]})
+    # A BARE PATH ON A SINGLE SCREEN, because that is what it has always been and
+    # nothing about one monitor needs explaining. Where there is more than one,
+    # the offset travels WITH the picture rather than waiting to be asked for:
+    # the moment it is needed is the moment the picture is read.
+    if not m.get("x") and not m.get("y"):
+        return out
+    return {"path": out, "screen": m["index"], "x": m["x"], "y": m["y"],
+            "width": m["width"], "height": m["height"],
+            "note": "add x %s, y %s to positions you read off this picture"
+                    % (m["x"], m["y"])}
+
+
+def click(x, y, button="left", clicks=1, what=""):
+    """Press something. SAY WHAT IT IS if you know.
 
+        click(*sign_in, what="Sign in")
 
-def click(x, y, button="left", clicks=1):
+    "Clicked at 3724, 17" tells somebody reading it back nothing at all: they
+    cannot look up what was at those coordinates on a screen that has since
+    changed (owner, 2026-09-05: "not just clicked 3724 17, say what it did
+    too"). You know what you are pressing, because you just read it off the
+    screen or out of find(); the log is the only place that knowledge can
+    survive the click.
+    """
     return _do("click", lambda: _gui().click(x=x, y=y, button=button, clicks=clicks),
-               {"x": x, "y": y, "button": button, "clicks": clicks}, points=[(x, y)])
+               {"x": x, "y": y, "button": button, "clicks": clicks,
+                "what": str(what)[:80], "screen": _SESSION_SCREEN["index"]},
+               points=[(x, y)])
 
 
-def double_click(x, y):
-    return _do("double_click", lambda: _gui().doubleClick(x=x, y=y), {"x": x, "y": y},
+def double_click(x, y, what=""):
+    return _do("double_click", lambda: _gui().doubleClick(x=x, y=y),
+               {"x": x, "y": y, "what": str(what)[:80],
+                "screen": _SESSION_SCREEN["index"]},
                points=[(x, y)])
 
 
-def right_click(x, y):
-    return _do("right_click", lambda: _gui().rightClick(x=x, y=y), {"x": x, "y": y},
+def right_click(x, y, what=""):
+    return _do("right_click", lambda: _gui().rightClick(x=x, y=y),
+               {"x": x, "y": y, "what": str(what)[:80],
+                "screen": _SESSION_SCREEN["index"]},
                points=[(x, y)])
 
 
@@ -1382,7 +1448,7 @@ def note(text):
     return _log_action("note", {"text": str(text)[:500]})
 
 
-def _grab_frame(width=960, quality=42, monitor=1):
+def _grab_frame(width=1920, quality=58, monitor=1):
     """One JPEG of a screen, downscaled. None when this machine cannot.
 
     mss where it exists because it is much faster and this runs a few times a
@@ -1406,13 +1472,29 @@ def _grab_frame(width=960, quality=42, monitor=1):
     try:
         import io as _io
         if img.width > width:
-            # Downscaled BEFORE encoding: half the pixels is half the work in
-            # the encoder as well as on the wire, and nobody watching needs to
-            # read the text. They need to see what is happening.
+            # Downscaled BEFORE encoding: fewer pixels is less work in the
+            # encoder as well as on the wire.
+            #
+            # 1920 IS NO DOWNSCALE AT ALL on an ordinary screen, which is the
+            # point. Anything smaller is sharpened here and then UPSCALED by a
+            # browser window wider than it, which puts the blur back after we
+            # paid to avoid it (owner, 2026-09-05: "the web is still blurred").
+            # This branch now only runs on a screen bigger than 1920.
+            #
+            # The filter matters as much as the size: the default resample is
+            # fine for enlarging and mushy for shrinking, which is all this does.
             height = max(1, int(img.height * (float(width) / img.width)))
-            img = img.resize((width, height))
+            try:
+                from PIL import Image as _I
+                img = img.resize((width, height), _I.LANCZOS)
+            except Exception:
+                img = img.resize((width, height))
         buf = _io.BytesIO()
-        img.convert("RGB").save(buf, format="JPEG", quality=quality, optimize=False)
+        # subsampling=0 keeps colour at full resolution. JPEG throws away three
+        # quarters of it by default, which is invisible on a photograph and is
+        # exactly what turns coloured text on a screen to mush.
+        img.convert("RGB").save(buf, format="JPEG", quality=quality,
+                                subsampling=0, optimize=False)
         return buf.getvalue()
     except Exception:
         return None
@@ -1448,7 +1530,7 @@ def _read_own_actions():
     return rows
 
 
-def stream_frames(send=None, fps=3, width=960, quality=42, max_s=120):
+def stream_frames(send=None, fps=3, width=1920, quality=58, max_s=120):
     """Send frames while a run is driving this computer. Returns when it stops.
 
     WATCHING IS GATED ON DRIVING. Frames go only while somebody holds the