mindvest-atlas 0.31.0 → 0.35.0

package/package.json

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

@@ -87,7 +87,11 @@ const OPS = {
 const NUMERIC = new Set(['use-screen', 'click', 'double-click', 'right-click',
   'middle-click', 'triple-click', 'move', 'drag', 'scroll']);
 
-function session(root) {
+/** This shell's holding id, made once and remembered. Shared with `atlas run`
+ *  so everything typed at one prompt lands in ONE session: the log reads as a
+ *  session rather than a pile of one-action folders, and the claim names
+ *  something the watch view can find. */
+export function shellSession(root) {
   const file = path.join(workspaceRoot(root), SESSION_FILE);
   try {
     const got = JSON.parse(fs.readFileSync(file, 'utf8'));
@@ -115,7 +119,7 @@ function runInProject(job, code, root) {
   // 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.
-  env.ATLAS_COMPUTER_SESSION = session(root);
+  env.ATLAS_COMPUTER_SESSION = shellSession(root);
   env.ATLAS_COMPUTER_PID = '0';
   env.PYTHONPATH = [dir, process.env.PYTHONPATH].filter(Boolean).join(path.delimiter);
   const out = spawnSync(python[0], [...python.slice(1), '-c', code], {
@@ -155,7 +159,7 @@ export function computerUseCommand(args) {
 
   if (sub === 'stop') {
     // Given back by NAME, so one shell cannot release another's hold.
-    const released = releaseComputerClaim(session());
+    const released = releaseComputerClaim(shellSession());
     println(color.dim(released ? 'Gave the computer back.' : 'It was not yours to give back.'));
     return 0;
   }
@@ -168,7 +172,7 @@ export function computerUseCommand(args) {
       return 2;
     }
     const holder = computerClaim();
-    if (holder && String(holder.session) !== session()) {
+    if (holder && String(holder.session) !== shellSession()) {
       eprintln(color.red(`${holder.job || 'Something'} is using the computer right now.`));
       eprintln(color.dim('  There is one mouse, so it is one at a time.'));
       return 3;

package/src/commands/run.js

@@ -27,6 +27,7 @@ import {
   workspace, venvPython, ambientPython, jobEnv, ensureProjectFiles,
 } from '../remote-control.js';
 import { color, println, eprintln } from '../util/ui.js';
+import { shellSession } from './computer-use.js';
 
 export function runCommand(args) {
   const flags = args.flags || {};
@@ -92,6 +93,12 @@ export function runCommand(args) {
       + 'if you need those.'));
   }
   if (!env.ATLAS_JOB) env.ATLAS_JOB = path.basename(dir);
+  // ONE SESSION FOR THE WHOLE SHELL, the same one `atlas computer-use` uses.
+  // Without it every command became its own session of one action, and the
+  // claim named a session no folder matched, so the watch view showed "Nothing
+  // yet" beside a screen plainly being worked on.
+  if (!env.ATLAS_COMPUTER_SESSION) env.ATLAS_COMPUTER_SESSION = shellSession();
+  if (!env.ATLAS_COMPUTER_PID) env.ATLAS_COMPUTER_PID = '0';
   // PYTHONPATH as well as the working directory. Running with -c does not put
   // the script's folder on the path the way running a file does, and `import
   // atlas_env` is the entire reason somebody is here.

package/src/commands/tools.js

@@ -25,6 +25,8 @@ const LOCAL_COMMANDS = {
   'update-cli': 'atlas update-cli                          fetch the newest Atlas',
   whoami: 'atlas whoami                              who this computer is signed in as',
   run: 'atlas run --job <project> [--code "..."]   run a project, or one snippet, INSIDE it',
+  'computer-use': 'atlas computer-use start|screen|click|type|stop   see and use this computer',
+  computer: 'atlas computer-use start|screen|click|type|stop   see and use this computer',
 };
 
 // ── THE THIRD PLACE, which nothing here used to mention ────────────────────

package/src/config.js

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

@@ -518,7 +518,27 @@ _COMPUTER_OFF = (
 
 
 def _computer_on():
-    return os.environ.get("ATLAS_COMPUTER_USE", "") not in ("", "0", "false", "no")
+    """Is this computer allowed to be used, whoever is asking.
+
+    THE SWITCH IS THE FILE. The environment variable is a fast path the runner
+    sets when it starts a job, and reading ONLY that was wrong: a command typed
+    in a shell sets no such variable, so every one of them was refused with
+    "switched off" while the switch was plainly on, and the refusal was written
+    into the log where it read as a fault (owner, 2026-09-05).
+
+    The variable still wins when it is there, so a run started with computer use
+    withheld stays withheld whatever the file says afterwards.
+    """
+    said = os.environ.get("ATLAS_COMPUTER_USE", "")
+    if said:
+        return said not in ("0", "false", "no")
+    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", "settings.json"), encoding="utf-8") as fh:
+            return bool(_json.load(fh).get("computer_use"))
+    except Exception:
+        return False
 
 
 # ── ONE AT A TIME ───────────────────────────────────────────────────────────
@@ -763,6 +783,32 @@ def _gui():
             "turn Computer Use off and on and it will fetch what is missing. "
             "From a script's own environment: pip install pyautogui."
         )
+    # ── WHY CLICKS MISSED ───────────────────────────────────────────────
+    #
+    # Windows scales most displays (125% is the default on a lot of hardware),
+    # and a process that has not said otherwise is lied to about the screen:
+    # pyautogui PHOTOGRAPHS in physical pixels, 1920x1080, and CLICKS in scaled
+    # logical ones, 1536x864. So a coordinate read honestly off a screenshot
+    # lands at four fifths of the way to the target, every time, up and to the
+    # left. Nothing errors. The click just quietly hits the wrong thing, and an
+    # agent reading the next screenshot sees its press did nothing and tries
+    # again slightly differently (owner, 2026-09-05: "why is it struggling to
+    # click on buttons?").
+    #
+    # Declaring the process DPI-aware puts both in the same space, so what you
+    # measure is what you press. Per-monitor first, because two screens can be
+    # scaled differently; the older call is the fallback on Windows 8 and before.
+    if os.name == "nt":
+        try:
+            import ctypes
+            try:
+                ctypes.windll.shcore.SetProcessDpiAwareness(2)
+            except Exception:
+                ctypes.windll.user32.SetProcessDPIAware()
+        except Exception:
+            # Not fatal: it means coordinates may be scaled, which is what was
+            # happening before anyone noticed.
+            pass
     _p.FAILSAFE = True
     _p.PAUSE = 0.02
     return _p
@@ -884,9 +930,46 @@ def screens():
                             "primary": m["left"] == 0 and m["top"] == 0})
             return out
     except ImportError:
-        w, h = _gui().size()
-        # No mss: we can only honestly describe the one pyautogui can see.
-        return [{"index": 1, "x": 0, "y": 0, "width": int(w), "height": int(h), "primary": True}]
+        pass
+    # WITHOUT mss, WINDOWS CAN STILL COUNT ITS OWN MONITORS. Reporting one
+    # screen on a two-screen machine is not a smaller answer, it is a wrong one:
+    # the picker offers a choice that does not exist and use_screen(2) refuses a
+    # monitor that is plainly there (owner, 2026-09-05: "I have 2 screens
+    # actually, it should see 2 monitors"). EnumDisplayMonitors is in the
+    # standard library, so this needs nothing installed.
+    if os.name == "nt":
+        try:
+            import ctypes
+            from ctypes import wintypes
+            found = []
+
+            class RECT(ctypes.Structure):
+                _fields_ = [("left", ctypes.c_long), ("top", ctypes.c_long),
+                            ("right", ctypes.c_long), ("bottom", ctypes.c_long)]
+
+            proto = ctypes.WINFUNCTYPE(ctypes.c_int, ctypes.c_ulong, ctypes.c_ulong,
+                                       ctypes.POINTER(RECT), ctypes.c_double)
+
+            def each(_h, _dc, rect, _p):
+                r = rect.contents
+                found.append((r.left, r.top, r.right - r.left, r.bottom - r.top))
+                return 1
+
+            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]))
+                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)]
+        except Exception:
+            pass
+    w, h = _gui().size()
+    # One screen is all anything here can see. Said as the answer it is, and the
+    # guidance says mss is what widens it.
+    return [{"index": 1, "x": 0, "y": 0, "width": int(w), "height": int(h), "primary": True}]
 
 
 def _primary_index(mons):
@@ -910,6 +993,18 @@ def _primary_index(mons):
 _SESSION_SCREEN = {"index": None}
 
 
+def _chosen_screen():
+    """Which screen this computer has been told to work on, or None for any."""
+    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", "settings.json"), encoding="utf-8") as fh:
+            want = _json.load(fh).get("computer_screen")
+        return int(want) if want else None
+    except Exception:
+        return None
+
+
 def use_screen(index=None):
     """Work on this monitor, and only this one, for the rest of the run.
 
@@ -937,7 +1032,13 @@ def _current_screen():
     mons = screens()
     want = _SESSION_SCREEN["index"]
     if want is None:
-        want = _primary_index(mons)
+        # THE ONE THE PERSON CHOSE, if they chose one. Defaulting to the primary
+        # is right on one screen and wrong on three: somebody with a spare
+        # monitor for this wants work to happen there, and having to say
+        # use_screen() at the top of every run is a setting written out by hand
+        # every time (owner, 2026-09-05: "how do I select the screen instead of
+        # defaulting to screen one").
+        want = _chosen_screen() or _primary_index(mons)
         _SESSION_SCREEN["index"] = want
     return next((m for m in mons if m["index"] == want), mons[0] if mons else
                 {"index": 1, "x": 0, "y": 0, "width": 0, "height": 0, "primary": True})
@@ -1185,24 +1286,63 @@ def _in_the_atlas_window():
     return any(name in front for name in _ATLAS_WINDOWS) if front else False
 
 #: How far the pointer can drift before it was somebody's hand.
-_HUMAN_NUDGE_PX = 20
+#:
+#: Was 20, which is inside the distance an application moves the cursor by
+#: itself: a dialog opening, a control taking focus, a menu snapping shut. That
+#: made a run stand back for nobody (owner, 2026-09-05: "moving the mouse should
+#: not pause this"). A person reaching for a mouse moves it further than this in
+#: the first tenth of a second.
+_HUMAN_NUDGE_PX = 120
+#: And a position we recorded a while ago says nothing about who moved it since.
+#: Only a fresh one is evidence.
+_POINTER_FRESH_S = 20
 #: Where we last left it, so the next action can tell.
-_POINTER = {"at": None}
+_POINTER = {"at": None, "when": 0}
 
 
 def _note_pointer():
+    import time as _time
     try:
         pos = _gui().position()
         _POINTER["at"] = (int(pos[0]), int(pos[1]))
+        _POINTER["when"] = _time.time()
     except Exception:
         _POINTER["at"] = None
 
 
+def _pause_on_touch():
+    """Should a run stand back when the pointer moves on its own?
+
+    OFF BY DEFAULT (owner, 2026-09-05: "no need of mouse move for the human, I
+    can still operate this but no need"). It was asked for, built, tried, and
+    got in the way: a person can work alongside a run perfectly well, and the
+    cost of guessing wrong is a run that stops for nobody and needs a deliberate
+    take_over() to continue. The failsafe is still there for the case that
+    actually matters, which is wanting it to stop NOW: slam the pointer into a
+    corner and pyautogui aborts.
+    """
+    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", "settings.json"), encoding="utf-8") as fh:
+            return bool(_json.load(fh).get("computer_pause_on_touch"))
+    except Exception:
+        return False
+
+
 def _human_took_over():
     """Has somebody moved the pointer since we last touched it?"""
+    import time as _time
+    if not _pause_on_touch():
+        return False
     was = _POINTER["at"]
     if was is None:
         return False
+    # A position from minutes ago is not evidence of anything. Between two
+    # commands typed at a prompt the pointer belongs to whoever is at the desk,
+    # and that is not somebody interrupting a run.
+    if _time.time() - float(_POINTER.get("when") or 0) > _POINTER_FRESH_S:
+        return False
     try:
         pos = _gui().position()
     except Exception:
@@ -1279,14 +1419,14 @@ def _grab_frame(width=960, quality=42, monitor=1):
 
 
 def _watched_screen():
-    """The screen this run chose, read from what it did."""
+    """The screen this run chose, read from what it did, or the chosen default."""
     for row in reversed(_read_own_actions()):
         if row.get("action") == "use_screen" and row.get("monitor"):
             try:
                 return int(row["monitor"])
             except (TypeError, ValueError):
                 return 1
-    return 1
+    return _chosen_screen() or 1
 
 
 def _read_own_actions():