mindvest-atlas 0.64.0 → 0.66.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindvest-atlas",
-  "version": "0.64.0",
+  "version": "0.66.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/dashboard.js

@@ -8,7 +8,10 @@
 // IT IS NOT THE COMPUTER. This drives the project's own window, so the real
 // pointer never moves, nothing is claimed, no switch is needed, and a click at
 // the wrong coordinates lands somewhere else in your own page rather than in
-// whatever was behind it.
+// whatever was behind it. That is the FIRST pass (styling, measured). `expand`
+// opens the SECOND: the dashboard in its own window on the real screen, in front
+// and in the picture, to be pressed with `atlas computer-use` so every tab and
+// button is seen to react (owner, 2026-09-10). `collapse` takes it down.
 import { color, println, eprintln } from '../util/ui.js';
 import { runInProject } from './computer-use.js';
 
@@ -24,6 +27,8 @@ const OPS = {
   shot: ['shot', 0],
   check: ['check', 0],
   close: ['close', 0],
+  expand: ['expand', 0],
+  collapse: ['collapse', 0],
 };
 const NUMERIC = new Set(['click', 'double-click', 'move', 'scroll']);
 
@@ -39,6 +44,9 @@ const HELP = `atlas dashboard <command>
   shot                             a picture, AND what is wrong with it in words
   check                            all four views, each measured
   close
+  expand                           its own window ON the screen, in front: then
+                                   press it with \`atlas computer-use\`
+  collapse                         take that window down
 
   --job <project>   which project (defaults to $ATLAS_JOB, which a chat sets)
 

package/src/commands/tools.js

@@ -42,7 +42,7 @@ const HELPER_FUNCTIONS = {
   atlas: 'atlas(tool, params)                  any cloud tool, as a call instead of a process',
   ask: 'ask(prompt)                          the model on this computer, with its own tools',
   mcp: 'mcp(server, tool, args)              a connected MCP server',
-  dashboard: "dashboard.open/find/click/type/shot  work this project's own page",
+  dashboard: "dashboard.open/find/click/shot/expand work this project's own page; expand = on the real screen",
   computer: 'computer: screen, click, type, key   see and use the whole machine',
   screen: 'screen(), click(x,y), type(text)     see and use the whole machine',
   click: 'click(x, y), double_click, drag      use the mouse on this computer',

package/src/config.js

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

@@ -324,6 +324,12 @@ export const dashboard = {
   /** All four views, each measured: computer and phone, dark and light. */
   check: async () => (await driveDashboard("check")).views || [],
   close: () => driveDashboard("close"),
+  /** The second pass: the dashboard in its own full-screen window ON the screen,
+   *  in front and in the picture, so it can be pressed with the real pointer
+   *  (computer.screen / computer.click). Answers with its bounds and whether
+   *  computer use is on. collapse() takes it down again. */
+  expand: () => driveDashboard("expand"),
+  collapse: () => driveDashboard("collapse"),
 };
 
 /**
@@ -340,19 +346,30 @@ export const dashboard = {
  *     await computer.type("hello");
  *     await computer.note("signing in");
  *
+ * ONE CALL IS ONE PYTHON. Each of those starts an interpreter, so a sequence of
+ * them pays that start-up per click and the run crawls (owner, 2026-09-10: "the
+ * slowness is the per command round trip"). Say the whole sequence instead and
+ * it is ONE start, with the picture already taken at the end:
+ *
+ *     await computer.do([["click", x, y, "Sign in"],
+ *                        ["type", "someone@example.com"],
+ *                        ["key", "tab"],
+ *                        ["type", secret("PASSWORD")],
+ *                        ["key", "enter"]]);
+ *
  * Off until the person turns it on, under This Computer in Atlas Studio. Read skills/computer-use before using any of it.
  */
-async function useComputer(op, args = []) {
+async function useComputer(op, args = [], kw = {}) {
   const { spawn } = await import("node:child_process");
   const dir = path.dirname(url_.fileURLToPath(import.meta.url));
   const py = process.env.ATLAS_PYTHON || (process.platform === "win32" ? "python" : "python3");
   const code =
     "import json,sys,atlas_env\n"
-    + "op=sys.argv[1]; args=json.loads(sys.argv[2])\n"
-    + "out=getattr(atlas_env,op)(*args)\n"
+    + "op=sys.argv[1]; args=json.loads(sys.argv[2]); kw=json.loads(sys.argv[3])\n"
+    + "out=getattr(atlas_env,op)(*args,**kw)\n"
     + "sys.stdout.write('\\n__ATLAS__'+json.dumps(out,default=str))\n";
   return await new Promise((done, fail) => {
-    const p = spawn(py, ["-c", code, op, JSON.stringify(args)], { cwd: dir });
+    const p = spawn(py, ["-c", code, op, JSON.stringify(args), JSON.stringify(kw || {})], { cwd: dir });
     let out = "", err = "";
     p.stdout.on("data", (d) => { out += d; });
     p.stderr.on("data", (d) => { err += d; });
@@ -386,6 +403,22 @@ export const computer = {
   region: (x, y, w, h) => useComputer("region", [x, y, w, h]),
   screens: () => useComputer("screens"),
   useScreen: (n) => useComputer("use_screen", [n]),
+  /**
+   * SEVERAL THINGS, ONE ROUND TRIP, ONE LOOK AT THE END. The fast loop, and the
+   * answer to a run that feels slow: every other call here starts its own
+   * Python, so five separate steps pay that five times before anything is even
+   * clicked (owner, 2026-09-10: "add option to batch command, this is better").
+   *
+   *     await computer.do([["click", 820, 410, "Sign in"], ["type", "hi"], ["key", "enter"]]);
+   *     // -> { did: [...], screen: "...png", changed: true, x: 1920, y: 0 }
+   *
+   * Each step is [name, ...args] with the same names the calls below use.
+   * Stops at the first refusal and says what had already happened, with a
+   * picture of where it stopped. `settle` is a CEILING in seconds (default 1.2)
+   * on waiting for the screen to stop moving, not a pause; `look: false` skips
+   * the picture when the next thing you do does not depend on it.
+   */
+  do: (steps, opts = {}) => useComputer("do", (steps || []).map((s) => (Array.isArray(s) ? s : [s])), opts),
   click: (x, y) => useComputer("click", [x, y]),
   doubleClick: (x, y) => useComputer("double_click", [x, y]),
   rightClick: (x, y) => useComputer("right_click", [x, y]),

package/src/helpers/atlas_env.py

@@ -395,6 +395,14 @@ class _Dashboard(object):
         atlas.dashboard.close()
 
     Coordinates are inside the dashboard, from its top left, not the screen's.
+
+    THAT IS THE FIRST PASS: styling, offscreen, measured. The second pass is
+    the real screen (owner, 2026-09-10: "use the user's computer and navigate
+    and press the buttons ... test the sensitivity"): once check() is clean,
+    expand() puts the dashboard in its own full-screen window IN FRONT and in
+    the picture, and you press its tabs and buttons with the real pointer
+    through screen()/click()/do(), reading `changed` after each. Then
+    collapse(). Computer view only; the phone reacts the same way.
     """
 
     @staticmethod
@@ -526,6 +534,28 @@ class _Dashboard(object):
         _log_action("dashboard_close")
         return out
 
+    def expand(self):
+        """The dashboard in its own full-screen window, ON THE SCREEN, in front.
+
+        For the second pass: pressing it with the real pointer. This is the one
+        Atlas window a run may photograph, so `screen()` will show it and
+        `windows(title)` will find it under this project's name. Answers with
+        where it sits (`bounds`, in desktop points, and that display's `scale`)
+        and `computer_use_on`, which says whether the real-screen pass is open
+        to you at all. LOOK before you click: the bounds are where to look, not
+        a coordinate to press.
+        """
+        out = self._call("expand", timeout=90)
+        _log_action("dashboard_expand", {"bounds": out.get("bounds"),
+                                         "computer_use_on": bool(out.get("computer_use_on"))})
+        return out
+
+    def collapse(self):
+        """Take the expanded window down again. Do this when the pass is done."""
+        out = self._call("collapse")
+        _log_action("dashboard_collapse")
+        return out
+
 
 dashboard = _Dashboard()