mindvest-atlas 0.50.3 → 0.52.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindvest-atlas",
-  "version": "0.50.3",
+  "version": "0.52.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-installs.js

@@ -41,7 +41,7 @@ function versionIn(text) {
 }
 
 /**
- * Where Atlas Remote Control keeps the copy it manages for itself.
+ * Where Atlas Studio keeps the copy it manages for itself.
  *
  * It fetches its own CLI so Local Mode works on a machine with nothing
  * installed. That copy is a THIRD version to be out of step with the other two,
@@ -102,12 +102,12 @@ export function installedClis() {
     }
   }
 
-  // The copy Atlas Remote Control manages for itself.
+  // The copy Atlas Studio manages for itself.
   const studio = studioCliDir();
   try {
     const pkg = JSON.parse(fs.readFileSync(path.join(studio, 'package.json'), 'utf8'));
     rows.push({
-      kind: 'Atlas Remote Control', version: pkg.version || '', where: studio,
+      kind: 'Atlas Studio', version: pkg.version || '', where: studio,
       note: 'the app updates this one itself',
     });
   } catch { /* the app has not fetched one */ }

package/src/cli.js

@@ -101,7 +101,7 @@ export async function main(rawArgs) {
       case 'run':
         return runCommand(withoutCommand(args));
       // SEEING AND USING THIS COMPUTER, from a shell. It existed only in the
-      // Python package, and Atlas Remote Control bundles THIS one, so the app
+      // Python package, and Atlas Studio bundles THIS one, so the app
       // answered "Unknown command or tool: computer-use" on the very machine
       // the command was written for (owner, 2026-09-05).
       case 'computer-use':

package/src/commands/computer-use.js

@@ -7,7 +7,7 @@
 // The agent in a chat is a SHELL agent. Computer use lived only inside project
 // scripts, so it reasoned its way to the truth and then to a wall.
 //
-// AND THIS IS THE COPY THAT ACTUALLY RUNS. Atlas Remote Control bundles the
+// AND THIS IS THE COPY THAT ACTUALLY RUNS. Atlas Studio bundles the
 // NODE CLI, so a version of this that existed only in the Python package was a
 // command the app rejected: "Unknown command or tool: computer-use", on the one
 // machine it was written for.
@@ -103,6 +103,10 @@ const OPS = {
   'hide-consoles': ['hide_consoles', 0],
   // ── A JOB THAT IS MOSTLY WAITING ──────────────────────────────────────
   watch: ['watch', 1],
+  // ── A BROWSER IS AN APPLICATION, NOT A WALL OF PIXELS ─────────────────
+  browser: ['browser', 0],
+  'go-to': ['go_to', 1],
+  'find-on-page': ['find_on_page', 1],
   // ── ONE CALL FOR WHAT USED TO BE FOUR ─────────────────────────────────
   'scroll-x': ['scroll_x', 1],
   'shift-scroll': ['shift_scroll', 1],
@@ -311,7 +315,7 @@ export function computerUseCommand(args) {
   if (sub === 'start') {
     if (!computerUseAllowed()) {
       eprintln(color.red('Using the computer is switched off.'));
-      eprintln(color.dim('  Open Atlas Remote Control > This Computer and turn on '
+      eprintln(color.dim('  Open Atlas Studio > This Computer and turn on '
         + '"Let an agent use this computer", then run this again.'));
       return 2;
     }
@@ -321,7 +325,7 @@ export function computerUseCommand(args) {
       eprintln(color.dim('  There is one mouse, so it is one at a time.'));
       return 3;
     }
-    // TAKING IT IS WHAT OPENS THE WATCH VIEW. Atlas Remote Control watches the
+    // TAKING IT IS WHAT OPENS THE WATCH VIEW. Atlas Studio watches the
     // claim, so there is nothing to ask it: the moment this lands, the strip
     // goes up and the screen appears. One signal, not two that can disagree.
     const code = 'import atlas_env as e, json\n'
@@ -331,7 +335,7 @@ export function computerUseCommand(args) {
     const out = runInProject(job, code);
     if (out === 0) {
       println('');
-      println(color.dim('Watching opened in Atlas Remote Control. Now use it:'));
+      println(color.dim('Watching opened in Atlas Studio. Now use it:'));
       println(color.dim('  atlas computer-use screen'));
       println(color.dim('  atlas computer-use click <x> <y>'));
       println(color.dim('  atlas computer-use stop   when you are done'));

package/src/commands/dashboard.js

@@ -3,7 +3,7 @@
 // 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.
+// be in THIS CLI, because Atlas Studio 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

package/src/commands/remote-control.js

@@ -245,7 +245,7 @@ async function handleAsk(ask, root) {
     const argv = Array.isArray(py) ? [...py] : [String(py)];
     // THE PROJECT'S OWN atlas_env, which both runners write, so nothing extra
     // has to be installed for this to work. It used to import the Python CLI
-    // package, which Atlas Remote Control never installs: live watching would
+    // package, which Atlas Studio never installs: live watching would
     // have failed on every machine running the app.
     const { dir } = workspace(ask.job || '', root);
     try { ensureProjectFiles(dir); } catch { /* it may already be right */ }
@@ -334,7 +334,7 @@ async function handleAsk(ask, root) {
   if (ask.op === 'command') {
     // A button, a switch or a form in the job's own dashboard, pressed from
     // anywhere that draws it. It lands as a file for the script to read — the
-    // same file Atlas Remote Control writes when the press happens in the app,
+    // same file Atlas Studio writes when the press happens in the app,
     // so one button means one thing wherever it is pressed.
     return answer(ask.request_id, writeCommand(ask.job || '', ask.name || '', ask.payload, root));
   }

package/src/commands/screenshot.js

@@ -65,7 +65,7 @@ export async function screenshotCommand(args) {
         return 1;
       }
     } catch (err) {
-      eprintln(color.red(`Could not reach Atlas Remote Control: ${err.message}`));
+      eprintln(color.red(`Could not reach Atlas Studio: ${err.message}`));
       return 1;
     }
 

package/src/config.js

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

@@ -64,7 +64,7 @@ export async function ask(prompt, { tools = true, fresh = false, timeoutMs = 600
   if (!url || !token) {
     throw new Error(
       "No model is connected on this computer, so this script cannot ask one. " +
-      "Connect a model in Atlas Remote Control, or do this step in code."
+      "Connect a model in Atlas Studio, or do this step in code."
     );
   }
   const res = await fetch(url, {
@@ -127,7 +127,7 @@ async function driveDashboard(op, body = {}) {
   const token = process.env.ATLAS_ASK_TOKEN || "";
   if (!url || !token) {
     throw new Error(
-      "The dashboard can only be driven from Atlas Remote Control, which is "
+      "The dashboard can only be driven from Atlas Studio, which is "
       + "what draws it. Run this project from the app.",
     );
   }
@@ -183,8 +183,7 @@ export const dashboard = {
  *     await computer.type("hello");
  *     await computer.note("signing in");
  *
- * Off until the person turns it on, under This Computer in Atlas Remote
- * Control. Read skills/computer-use before using any of it.
+ * 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 = []) {
   const { spawn } = await import("node:child_process");
@@ -256,12 +255,12 @@ export const computer = {
  * Stop cleanly when a secret has not been filled in yet.
  *
  * Names what is missing and nothing else: a blank key is the owner's to fill in
- * Atlas Remote Control, not something a script should work around.
+ * Atlas Studio, not something a script should work around.
  */
 export function require_(...names) {
   const missing = names.filter((n) => !process.env[n]);
   if (missing.length) {
-    console.log(`Missing: ${missing.join(", ")}. Add the value in Atlas Remote Control, then run again.`);
+    console.log(`Missing: ${missing.join(", ")}. Add the value in Atlas Studio, then run again.`);
     process.exit(2);
   }
 }

package/src/helpers/atlas_env.py

@@ -101,7 +101,7 @@ def ask(prompt, tools=True, fresh=False, timeout=600, model=""):
     if not url or not token:
         raise RuntimeError(
             "No model is connected on this computer, so this script cannot ask one. "
-            "Connect a model in Atlas Remote Control, or do this step in code."
+            "Connect a model in Atlas Studio, or do this step in code."
         )
     body = {"job": os.environ.get("ATLAS_JOB", ""), "prompt": str(prompt),
             "tools": bool(tools), "fresh": bool(fresh)}
@@ -284,7 +284,7 @@ class _Dashboard(object):
         token = os.environ.get("ATLAS_ASK_TOKEN", "")
         if not url or not token:
             raise RuntimeError(
-                "The dashboard can only be driven from Atlas Remote Control, "
+                "The dashboard can only be driven from Atlas Studio, "
                 "which is what draws it. Run this project from the app."
             )
         job = os.path.basename(os.path.dirname(os.path.abspath(__file__)))
@@ -441,11 +441,11 @@ def require(*names):
     """Stop cleanly when a secret has not been filled in yet.
 
     Names what is missing and nothing else: a blank key is the owner's to fill
-    in Atlas Remote Control, not something a script should work around.
+    in Atlas Studio, not something a script should work around.
     """
     missing = [n for n in names if not os.environ.get(n)]
     if missing:
-        print("Missing: %s. Add the value in Atlas Remote Control, then run again."
+        print("Missing: %s. Add the value in Atlas Studio, then run again."
               % ", ".join(missing))
         sys.exit(2)
 
@@ -497,7 +497,7 @@ def record_trade(symbol, quantity, entry_price, exit_price, opened_at, closed_at
 #
 # Seeing the screen, moving the mouse, typing. Everything a person can do at
 # this machine, which is exactly why it is OFF until somebody says otherwise:
-# Atlas Remote Control > This Computer > "Let an agent use this computer". The
+# Atlas Studio > This Computer > "Let an agent use this computer". The
 # switch sets ATLAS_COMPUTER_USE for the run; without it every call here refuses
 # and SAYS SO, and the refusal is written down like any other action.
 #
@@ -512,7 +512,7 @@ def record_trade(symbol, quantity, entry_price, exit_price, opened_at, closed_at
 # a password is a credential store nobody meant to make.
 
 _COMPUTER_OFF = (
-    "Using the computer is switched off. Open Atlas Remote Control > This "
+    "Using the computer is switched off. Open Atlas Studio > This "
     "Computer and turn on \"Let an agent use this computer\", then run this again."
 )
 
@@ -746,12 +746,12 @@ def computer_ready():
         import pyautogui  # noqa: F401
     except ImportError:
         # TWO READERS, TWO ANSWERS. A person should never be sent to a shell:
-        # Atlas Remote Control fetches this when the switch goes on. An agent
+        # Atlas Studio fetches this when the switch goes on. An agent
         # reading the same line HAS a shell, and if this project keeps its own
         # venv that is the only place the package can go.
-        return ("This project cannot use the computer yet. In Atlas Remote "
-                "Control, turn Computer Use off and on and it will fetch what "
-                "is missing. From a script's own environment: pip install pyautogui.")
+        return ("This project cannot use the computer yet. In Atlas Studio, turn "
+                "Computer Use off and on and it will fetch what is missing. From "
+                "a script's own environment: pip install pyautogui.")
     if os_name() == "mac":
         # There is no way to ASK macOS whether permission was granted; the tell
         # is that a capture comes back with nothing in it. Cheap to check once.
@@ -779,7 +779,7 @@ def _gui():
         import pyautogui as _p
     except ImportError:
         raise RuntimeError(
-            "This project cannot use the computer yet. In Atlas Remote Control, "
+            "This project cannot use the computer yet. In Atlas Studio, "
             "turn Computer Use off and on and it will fetch what is missing. "
             "From a script's own environment: pip install pyautogui."
         )
@@ -868,9 +868,9 @@ def _do(action, fn, detail=None, points=()):
     # rather than when the window was focused: what matters is where the click
     # lands, and the front window can change between the two.
     if action in _ACTS_ON_A_WINDOW and not _MAY_USE_ATLAS["ok"] and _in_the_atlas_window():
-        _log_action(action, detail, ok=False, error="inside Atlas Remote Control")
+        _log_action(action, detail, ok=False, error="inside Atlas Studio")
         raise RuntimeError(
-            "Atlas Remote Control is the window in front, and this run has not "
+            "Atlas Studio is the window in front, and this run has not "
             "been asked to work inside it. Typing there means talking to another "
             "agent, which is not something to start on your own. If the person "
             "asked for it, call use_atlas_app() first; otherwise bring the right "
@@ -1965,7 +1965,7 @@ def _one_window(title):
     got = hit[0]
     if not _MAY_USE_ATLAS["ok"] and _is_atlas_title(str(getattr(got, "title", ""))):
         raise RuntimeError(
-            '"%s" is Atlas Remote Control, which is showing the person what this '
+            '"%s" is Atlas Studio, which is showing the person what this '
             "run is doing. Touching its window is not something to decide on your "
             "own: if they asked for it, call use_atlas_app() first." % got.title
         )
@@ -1976,7 +1976,7 @@ def _one_window(title):
 #:
 #: The title of a console window is the command line of the program in it until
 #: something sets one. So "C:\...\python3.11.exe" is machinery, and so is
-#: "C:\...\Atlas Remote Control.exe" — which a list of interpreter names would
+#: "C:\...\Atlas Studio.exe" — which a list of interpreter names would
 #: have walked straight past, and that one was the window sitting over the
 #: owner's chart (owner, 2026-09-06: "screen for any console interpreter and
 #: let's stick with background processes for all of it").
@@ -2483,6 +2483,108 @@ def watch(instruction, every=5, most=200, hours=8, look=True):
             "waits": waits, "varied": len(set(waits)) > 1}
 
 
+#: How a browser names itself at the end of its window title. Used to work out
+#: WHICH one is in front, because the keys differ in a couple of places and
+#: guessing wrong sends a keystroke somewhere nobody is looking.
+_BROWSERS = (
+    ("Google Chrome", "chrome"), ("Microsoft Edge", "edge"), ("Mozilla Firefox", "firefox"),
+    ("Firefox", "firefox"), ("Brave", "brave"), ("Safari", "safari"),
+    ("Opera", "opera"), ("Vivaldi", "vivaldi"), ("Chromium", "chromium"),
+)
+
+
+def browser():
+    """Which browser is on screen, and what its window is called.
+
+        {"name": "edge", "title": "SPY — TradingView and 3 more pages — Microsoft Edge"}
+
+    None when there is no browser window. Worth asking once at the start: a
+    browser is not a wall of pixels, it is an application with an address bar
+    and a find bar, and knowing you are in one changes what the fast move is.
+    """
+    def go():
+        try:
+            wins = _all_windows()
+        except Exception:
+            return None
+        for w in wins:
+            title = str(getattr(w, "title", "") or "")
+            for label, name in _BROWSERS:
+                if title.rstrip().endswith(label) or (" - " + label) in title or (" — " + label) in title:
+                    return {"name": name, "title": title[:200]}
+        return None
+    return _do("browser", go, {})
+
+
+def _chord():
+    """ctrl on Windows and Linux, command on a Mac. The one difference that
+    matters for every browser key there is."""
+    import sys as _sys
+    return "command" if _sys.platform == "darwin" else "ctrl"
+
+
+def go_to(url, window=""):
+    """Go straight to an address. The fastest move a browser offers.
+
+        go_to("https://www.tradingview.com/chart/?symbol=SPY")
+
+    Bring the browser forward, focus the address bar, replace what is in it,
+    press Enter, and wait for the page to settle. One call for what is otherwise
+    five, and none of it involves finding anything by eye.
+
+    NAVIGATING BY ADDRESS BEATS CLICKING THROUGH A SITE, every time. A menu path
+    is four clicks that each have to land, on a layout that moves; an address is
+    one thing that is either right or wrong and says which.
+    """
+    def go():
+        g = _gui()
+        if window:
+            focus_window(window)
+        else:
+            b = browser()
+            if b:
+                focus_window(b["name"])
+        mod = _chord()
+        g.hotkey(mod, "l")          # the address bar, everywhere
+        g.hotkey(mod, "a")          # and everything in it, so this replaces
+        g.write(str(url), interval=0.01)
+        g.press("enter")
+    out = _do("go_to", go, {"url": str(url)[:200]})
+    # A page is not there when Enter is pressed. Wait for it to start AND stop,
+    # which is what the settle does, rather than a sleep somebody guessed.
+    _settle(6.0)
+    return out
+
+
+def find_on_page(text, next_times=0):
+    """Find text on the page and leave the view on it.
+
+        find_on_page("Opening Range")
+
+    ctrl+F, type, Enter, Escape — the browser scrolls to the match and the find
+    bar closes, leaving the page where the thing is. That is a way to REACH
+    something without knowing where it is on screen, which is the expensive kind
+    of knowing.
+
+    `next_times` presses Enter again for the second, third match.
+
+    It cannot tell you whether it found anything: the browser says so in its own
+    find bar, which is gone by the time you look. Take a picture after.
+    """
+    def go():
+        g = _gui()
+        mod = _chord()
+        g.hotkey(mod, "f")
+        g.write(str(text), interval=0.01)
+        g.press("enter")
+        for _ in range(max(0, int(next_times))):
+            g.press("enter")
+        g.press("escape")
+    out = _do("find_on_page", go, {"text": len(str(text))})
+    _settle(1.5)
+    return out
+
+
 def scroll_x(amount, x=None, y=None):
     """Scroll SIDEWAYS. Positive goes right, negative left.
 
@@ -2641,7 +2743,7 @@ _HANDOVER = {"to_human": False, "why": ""}
 
 # ── DRIVING ATLAS ITSELF ────────────────────────────────────────────────────
 #
-# Atlas Remote Control is a window like any other, so a run that can use the
+# Atlas Studio is a window like any other, so a run that can use the
 # computer can use it: open a project, press Run, fix a setting somebody asked
 # about. That is fine and it is useful.
 #
@@ -2652,6 +2754,11 @@ _HANDOVER = {"to_human": False, "why": ""}
 #
 # So: acting inside the Atlas window needs saying so once. Looking never does,
 # and neither does anything in any other window.
+#: BOTH NAMES, and the old one stays. The app was renamed from Atlas Remote
+#: Control to Atlas Studio, and a machine running the previous build has a window
+#: still called the old thing — dropping it would quietly turn off the guard that
+#: keeps a run from typing into Atlas's own chat, on exactly the installs that
+#: have not updated yet.
 _ATLAS_WINDOWS = ("atlas remote control", "atlas studio")
 _MAY_USE_ATLAS = {"ok": os.environ.get("ATLAS_MAY_DRIVE_APP", "") == "1"}
 #: The ones that CHANGE something. Moving the pointer and looking do not.
@@ -2665,7 +2772,7 @@ _ACTS_ON_A_WINDOW = (
 
 
 def use_atlas_app(allowed=True):
-    """Say the person asked you to work inside Atlas Remote Control itself.
+    """Say the person asked you to work inside Atlas Studio itself.
 
     Only when they actually did. Deciding for yourself that it would be handy is
     the thing this exists to stop, and the first place a run wanders to is the
@@ -2944,8 +3051,8 @@ def stream_frames(send=None, fps=3, width=1920, quality=58, max_s=120):
         frame = _grab_frame(width, quality, _watched_screen())
         if frame is None:
             send({"kind": "error", "message": (
-                "This computer is not set up to be watched yet. Open Atlas Remote "
-                "Control on it, go to Computer Use, and turn the switch off and on: "
+                "This computer is not set up to be watched yet. Open Atlas Studio "
+                "on it, go to Computer Use, and turn the switch off and on: "
                 "it fetches what is missing.")})
             return
         mark = hashlib.md5(frame).digest()

package/src/remote-control.js

@@ -1022,7 +1022,7 @@ export function readJobFile(job, rel, root) {
  * This half had NO command path at all: `writeCommand` did not exist and the
  * relay had no `command` op, so a custom button pressed from the WEB reached a
  * machine running this CLI and vanished, while the same button pressed in the
- * app worked (Atlas Remote Control writes the file itself). One button, two
+ * app worked (Atlas Studio writes the file itself). One button, two
  * answers, depending on where you pressed it (owner, 2026-09-04: "the agent can
  * wire buttons that read or write local — the web can do this too, it's either
  * or"). Mirrors python/atlas_cli/remote_control.py.
@@ -1511,7 +1511,7 @@ const STARTER_README = (name) => [
   'must stay up says `"mode": "listen"` in atlas.json and the runner keeps it',
   'alive.', '',
   'Nothing here is stored on Atlas servers. The schedule runs on this computer,',
-  'while Atlas Remote Control is open.', '',
+  'while Atlas Studio is open.', '',
 ].join('\n');
 
 const STARTER_MAIN = (name) => [