mindvest-atlas 0.46.0 → 0.48.0

package/package.json

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

@@ -81,6 +81,17 @@ const OPS = {
   cursor: ['get_cursor', 0],
   'take-over': ['take_over', 0],
   ready: ['computer_ready', 0],
+  // WAIT ESPECIALLY. A sequence without it cannot pause for a page, which is
+  // most of what a real run of steps needs, and its absence made the documented
+  // example fail: `do "click ..." "wait 1500"` was refused as an unknown verb,
+  // which reads as do() being broken rather than a table missing a row.
+  wait: ['wait', 1],
+  copy: ['copy', 1],
+  region: ['region', 4],
+  'mouse-down': ['mouse_down', 0],
+  'mouse-up': ['mouse_up', 0],
+  'key-down': ['key_down', 1],
+  'key-up': ['key_up', 1],
 };
 // Which values are numbers. Passing "840" as a string to click() would move the
 // pointer nowhere and report success.

package/src/config.js

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

@@ -1434,16 +1434,43 @@ def do(*steps, **kw):
         try:
             fn(*args)
         except Exception as err:
-            raise RuntimeError("stopped at %s: %s (already did: %s)"
-                               % (name, err, ", ".join(did) or "nothing"))
+            # A LONG RUN HAS TO BE SAFE TO ATTEMPT, or caution is the right
+            # answer and nobody will attempt one. So a sequence that stops
+            # halfway hands back a PICTURE of where it stopped, not just the
+            # name of the step: the whole reason to fear a six-step run is not
+            # knowing what state it left behind, and this answers that in the
+            # same breath as the failure.
+            where = None
+            try:
+                shot = screen()
+                where = shot if isinstance(shot, str) else shot.get("path")
+            except Exception:
+                pass
+            raise RuntimeError(
+                "stopped at %s (step %d of %d): %s. Already did: %s.%s"
+                % (name, len(did) + 1, len(steps), err, ", ".join(did) or "nothing",
+                   (" The screen at that moment: %s" % where) if where else "")
+            )
         did.append(str(name))
     if not look:
         return {"did": did}
     if settle > 0:
         import time as _time
         _time.sleep(settle)
-    shot = screen()
+    # THE WORK SUCCEEDING AND THE LOOK FAILING ARE TWO DIFFERENT THINGS.
+    #
+    # Every step ran, and then the picture at the end could not be taken, and the
+    # whole call raised: to anybody reading, do() had failed, when in fact
+    # everything asked for had happened. That is how a working thing gets a
+    # reputation for being broken (owner, 2026-09-06: "it reports do() is not
+    # working"). The actions are reported as done, and the look reports itself.
     out = {"did": did}
+    try:
+        shot = screen()
+    except Exception as err:
+        out["screen"] = None
+        out["look_failed"] = str(err)
+        return out
     # DID ANYTHING ACTUALLY CHANGE? A picture that is byte-for-byte the last one
     # is a wasted look: the reader spends a turn opening it to find out nothing
     # happened, which is the slowest possible way to learn that. Said in words