mindvest-atlas 0.40.0 → 0.41.0

package/package.json

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

package/src/cli.js

@@ -17,6 +17,7 @@ import { updateCliCommand } from './commands/update-cli.js';
 import { screenshotCommand } from './commands/screenshot.js';
 import { runCommand } from './commands/run.js';
 import { computerUseCommand } from './commands/computer-use.js';
+import { dashboardCommand } from './commands/dashboard.js';
 import { remoteCheckCommand } from './commands/remote-check.js';
 import { shareCommand } from './commands/share.js';
 import { historicalContractCommand } from './commands/historical.js';
@@ -106,6 +107,11 @@ export async function main(rawArgs) {
       case 'computer-use':
       case 'computer':
         return computerUseCommand(withoutCommand(args));
+      // THE PROJECT'S OWN PAGE, which had the same gap: it existed in atlas_env
+      // and nowhere a shell agent could reach without writing the import by
+      // hand (owner, 2026-09-06).
+      case 'dashboard':
+        return dashboardCommand(withoutCommand(args));
       // Put the newest CLI on this machine.
       case 'update-cli':
       case 'self-update':

package/src/commands/computer-use.js

@@ -106,7 +106,7 @@ export function shellSession(root) {
 }
 
 /** Run one atlas_env call inside the project, and hand back what it said. */
-function runInProject(job, code, root) {
+export function runInProject(job, code, root) {
   const { dir } = workspace(job, root);
   if (!fs.existsSync(dir)) {
     eprintln(color.red(`There is no project called ${job} on this computer.`));

package/src/commands/dashboard.js

@@ -0,0 +1,83 @@
+// `atlas dashboard` — use this project's own page, from a shell.
+//
+// The same gap `atlas computer-use` filled, one road over: driving the
+// dashboard existed in atlas_env and nowhere else, so an agent in a chat could
+// only reach it by hand-writing the import (owner, 2026-09-06). And it has to
+// be in THIS CLI, because Atlas Remote Control bundles this one.
+//
+// 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.
+import { color, println, eprintln } from '../util/ui.js';
+import { runInProject } from './computer-use.js';
+
+const OPS = {
+  open: ['open', 0],
+  find: ['find', -1],
+  click: ['click', 2],
+  'double-click': ['doubleClick', 2],
+  move: ['move', 2],
+  scroll: ['scroll', 4],
+  type: ['type', 1],
+  key: ['key', -1],
+  shot: ['shot', 0],
+  check: ['check', 0],
+  close: ['close', 0],
+};
+const NUMERIC = new Set(['click', 'double-click', 'move', 'scroll']);
+
+const HELP = `atlas dashboard <command>
+
+  open [--phone] [--theme light]   draw this project's dashboard, ready to use
+  find "<selector>"                what is on it, and the middle of each
+  click <x> <y>                    also double-click
+  move <x> <y>
+  scroll <x> <y> <dx> <dy>
+  type "<text>"
+  key <name> [<name>...]
+  shot                             a picture, AND what is wrong with it in words
+  check                            all four views, each measured
+  close
+
+  --job <project>   which project (defaults to $ATLAS_JOB, which a chat sets)
+
+Coordinates are inside the dashboard, from its top left. Not the screen's.`;
+
+export function dashboardCommand(args) {
+  const flags = args.flags || {};
+  const rest = [...(args.positional || args._ || [])];
+  const sub = String(rest.shift() || '').trim().toLowerCase();
+  const job = String(flags.job || process.env.ATLAS_JOB || '').trim();
+
+  if (!sub || sub === 'help') { println(HELP); return 0; }
+  if (!OPS[sub]) {
+    eprintln(color.red(`There is no "${sub}" here.`));
+    println(HELP);
+    return 1;
+  }
+  if (!job) {
+    eprintln(color.red(`Which project? \`atlas dashboard ${sub} --job my-project\``));
+    return 1;
+  }
+  const [name, count] = OPS[sub];
+  if (count >= 0 && rest.length !== count) {
+    eprintln(color.red(`${sub} takes ${count} value${count === 1 ? '' : 's'}.`));
+    return 1;
+  }
+
+  let call;
+  if (sub === 'open') {
+    const theme = flags.theme === 'light' ? 'light' : 'dark';
+    call = `e.dashboard.open(phone=${flags.phone ? 'True' : 'False'}, theme=${JSON.stringify(theme)})`;
+  } else if (sub === 'find' && !rest.length) {
+    call = 'e.dashboard.find()';
+  } else {
+    const values = rest.map((v) => (NUMERIC.has(sub) ? Number(v) : v));
+    call = `e.dashboard.${name}(*json.loads(${JSON.stringify(JSON.stringify(values))}))`;
+  }
+  const code = 'import atlas_env as e, json\n'
+    + `out = ${call}\n`
+    + 'print(json.dumps(out, default=str, indent=2))\n';
+  return runInProject(job, code);
+}

package/src/config.js

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

@@ -1146,6 +1146,68 @@ def screen(path=None):
                     % (m["x"], m["y"])}
 
 
+def do(*steps, **kw):
+    """Do several things, then look ONCE. The fast loop.
+
+    THE SLOW PART IS NOT THE CLICKING. Every separate command is a process
+    start, a bridge call and a picture, and asking for the picture is its own
+    round trip on top: act, ask, look, decide, act. Five of those to press four
+    buttons you could already see (owner, 2026-09-06: "the iteration and fixing
+    is slow, it has to take a screenshot to verify, then do the action").
+
+    So say the whole sequence and get the result back with the picture already
+    taken:
+
+        do(("click", 820, 410, "Sign in"),
+           ("type", "someone@example.com"),
+           ("key", "tab"),
+           ("type", secret("PASSWORD")),
+           ("key", "enter"))
+        # -> {"did": [...], "screen": "...png", "x": 1920, "y": 0}
+
+    One look at the end, because that is the only moment the screen has settled
+    into something worth reading. Between the steps there is nothing to see that
+    you did not already know was coming.
+
+    `settle` waits before the picture, for a page that is still moving. Set
+    `look=False` when the next thing you do does not depend on what happened.
+    """
+    settle = float(kw.get("settle", 0.6))
+    look = kw.get("look", True)
+    did = []
+    for step in steps:
+        if not step:
+            continue
+        name, args = (step[0], list(step[1:])) if isinstance(step, (list, tuple)) else (step, [])
+        fn = globals().get(str(name))
+        if not callable(fn):
+            raise RuntimeError('There is no "%s" to do. Try screen, click, type, key, scroll, wait.' % name)
+        # STOPS AT THE FIRST REFUSAL, and says what had already happened. A
+        # sequence that carried on past a click that did not land would type a
+        # password into whatever had focus instead.
+        try:
+            fn(*args)
+        except Exception as err:
+            raise RuntimeError("stopped at %s: %s (already did: %s)"
+                               % (name, err, ", ".join(did) or "nothing"))
+        did.append(str(name))
+    if not look:
+        return {"did": did}
+    if settle > 0:
+        import time as _time
+        _time.sleep(settle)
+    shot = screen()
+    out = {"did": did}
+    # screen() answers a bare path on one monitor and a dict on several. Both
+    # travel, because the offset is the thing a reader needs next.
+    if isinstance(shot, dict):
+        out.update(shot)
+        out["screen"] = shot.get("path")
+    else:
+        out["screen"] = shot
+    return out
+
+
 def click(x, y, button="left", clicks=1, what=""):
     """Press something. SAY WHAT IT IS if you know.