mindvest-atlas 0.63.0 → 0.65.0

package/package.json

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

@@ -27,7 +27,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import {
   workspace, workspaceRoot, venvPython, ambientPython, jobEnv, ensureProjectFiles,
-  computerUseAllowed, computerClaim, releaseComputerClaim,
+  computerUseAllowed, computerClaim, releaseComputerClaim, askAddress,
 } from '../remote-control.js';
 import { color, println, eprintln } from '../util/ui.js';
 
@@ -254,6 +254,14 @@ export function runInProject(job, code, root) {
   const venv = venvPython(dir);
   const python = venv ? [String(venv)] : [...ambientPython()];
   const env = { ...process.env, ...jobEnv(dir), ATLAS_JOB: path.basename(dir) };
+  // AND HOW TO REACH THE APP, when this shell was not started by it. Without
+  // these, ask(), screenshot() and every dashboard call inside the script refuse
+  // with "this has to run from inside Atlas" while Atlas is running (owner,
+  // 2026-09-10). Only filled when absent: a run Atlas started keeps its own.
+  if (!env.ATLAS_ASK_URL || !env.ATLAS_ASK_TOKEN) {
+    const at = askAddress(root);
+    if (at) { env.ATLAS_ASK_URL = at.url; env.ATLAS_ASK_TOKEN = at.token; }
+  }
   // BEFORE ANYTHING TRIES TO IMPORT THEM. Checked every time and installed only
   // when something is missing, so the cost is one python start on a machine
   // that is already set up.

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/run.js

@@ -24,7 +24,7 @@ import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import {
-  workspace, venvPython, ambientPython, jobEnv, ensureProjectFiles,
+  workspace, venvPython, ambientPython, jobEnv, ensureProjectFiles, askAddress,
 } from '../remote-control.js';
 import { color, println, eprintln } from '../util/ui.js';
 import { shellSession } from './computer-use.js';
@@ -86,11 +86,18 @@ export function runCommand(args) {
   // THE BRIDGE BACK TO ATLAS is inherited, never invented. These are handed to
   // a process Atlas starts, so an agent's own shell has them and a person's
   // ordinary terminal does not. Saying so beats a snippet that half works.
+  // FILLED IN WHEN THE APP IS RUNNING. It writes its loopback address down while
+  // it listens, so a shell Atlas did not start can still reach it. The note below
+  // is now only for the case that is actually true: Atlas is not running.
+  if (!env.ATLAS_ASK_URL || !env.ATLAS_ASK_TOKEN) {
+    const at = askAddress(flags.root);
+    if (at) { env.ATLAS_ASK_URL = at.url; env.ATLAS_ASK_TOKEN = at.token; }
+  }
   if (!env.ATLAS_ASK_URL || !env.ATLAS_ASK_TOKEN) {
     println(color.dim(
-      '  Note: this shell was not started by Atlas, so ask(), dashboard and '
-      + 'screenshot() will not work in it. Everything else will. Ask in a chat '
-      + 'if you need those.'));
+      '  Note: Atlas Studio is not running, so ask(), dashboard and screenshot() '
+      + 'will not work in this shell. Everything else will. Start Atlas Studio 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.

package/src/commands/screenshot.js

@@ -16,6 +16,7 @@
 // the project's own `screenshots/`, and prints the faults in words — because a
 // picture the agent cannot see is not a check.
 import { color, println, eprintln } from '../util/ui.js';
+import { askAddress } from '../remote-control.js';
 
 export async function screenshotCommand(args) {
   const flags = args.flags || {};
@@ -25,17 +26,20 @@ export async function screenshotCommand(args) {
     return 1;
   }
 
-  const url = process.env.ATLAS_ASK_URL;
-  const token = process.env.ATLAS_ASK_TOKEN;
+  // Atlas hands these to what it starts, and writes them down while it is
+  // running so a terminal it did not start can find them too.
+  const at = askAddress(flags.root);
+  const url = at?.url;
+  const token = at?.token;
   if (!url || !token) {
     // NOT a Local Mode check, whatever it used to say. These variables are
     // handed to a process Atlas starts — a script it runs, or an agent it
     // spawned. Their absence means this command is running somewhere Atlas did
     // not start it, and saying "turn Local Mode on" sent people to a switch
     // that was already on (owner, 2026-09-05).
-    eprintln(color.red('This has to run from inside Atlas. Atlas is what draws the page.'));
-    eprintln(color.dim('Ask for it in a chat, or call screenshot() from the project\'s script. '
-      + 'Run by hand in a terminal there is nothing to photograph.'));
+    eprintln(color.red('Atlas Studio is not running on this computer. Atlas is what draws the page.'));
+    eprintln(color.dim('Start Atlas Studio and try again, or ask for it in a chat. '
+      + 'With nothing running there is nothing to photograph.'));
     return 1;
   }
 

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.63.0';
+export const VERSION = '0.65.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"),
 };
 
 /**

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()
 

package/src/remote-control.js

@@ -39,6 +39,34 @@ export const ENTRIES = ['main.py', 'main.js', 'main.mjs'];
  */
 export const DEFAULT_TIMEOUT_MS = 1_800_000;
 
+/**
+ * HOW TO REACH A RUNNING ATLAS, from a shell it did not start.
+ *
+ * ATLAS_ASK_URL / ATLAS_ASK_TOKEN are handed to processes Atlas spawns. Anything
+ * else on the same machine had no way in at all: `atlas screenshot`, `atlas
+ * dashboard` and `atlas run --code` all refused with "this has to run from
+ * inside Atlas", with the app running the whole time and nothing the person
+ * could do about it (owner, 2026-09-10).
+ *
+ * The app writes its loopback address down while it is listening, so this is
+ * the same server those variables point at, on the same machine, for the same
+ * user. The environment still wins when it is set: a run Atlas started should
+ * talk to the Atlas that started it.
+ */
+export function askAddress(root) {
+  const url = process.env.ATLAS_ASK_URL;
+  const token = process.env.ATLAS_ASK_TOKEN;
+  if (url && token) return { url, token };
+  try {
+    const file = path.join(workspaceRoot(root), '.studio', 'ask-server.json');
+    const saved = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (saved?.url && saved?.token) return { url: String(saved.url), token: String(saved.token) };
+  } catch {
+    // Not running, or a different machine's home. The caller says so in words.
+  }
+  return null;
+}
+
 export function workspaceRoot(override) {
   const raw = override || process.env.ATLAS_LOCAL_DIR
     || process.env.ATLAS_LIBRARY_DIR   // what Studio sets