mindvest-atlas 0.65.0 → 0.67.0

package/package.json

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

package/src/config.js

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

@@ -53,6 +53,19 @@ export async function atlas(tool, params = {}) {
  *
  *     const verdict = await ask(`Is this headline about AAPL itself or the sector?\n${line}`);
  *
+ * IT IS A CHAT SESSION, NOT A TEXT BOX (owner, 2026-09-11). The model runs in
+ * this project's folder with everything the chat has: the files, the shell, the
+ * `atlas` command line, Atlas's own tools, the skills, and the computer when the
+ * switch is on. Ask it to open the broker and read a balance and it drives the
+ * screen; its last message is what you get back. Nobody is watching, so it never
+ * asks back: it decides. Say what shape you want the answer in.
+ *
+ *     const balance = await ask("Open the broker in Edge and read me the cash balance. Answer with the number only.");
+ *
+ * commands:true (the default) is that whole session; commands:false is pure
+ * judgement — twenty classifications — where the model answers from what it was
+ * given and runs nothing, faster and cheaper.
+ *
  * tools:true lets the model reach Atlas data while it answers; false is faster
  * for pure text. fresh:false keeps ONE conversation for this job (the model
  * starts up once, later questions can refer to earlier ones); fresh:true is for
@@ -71,7 +84,7 @@ export async function atlas(tool, params = {}) {
  * quietly answered by the default, because a script that asked for a specific
  * model and silently got another one is worse than one that stops.
  */
-export async function ask(prompt, { tools = true, fresh = false, timeoutMs = 600000, model = "" } = {}) {
+export async function ask(prompt, { tools = true, fresh = false, timeoutMs = 600000, model = "", commands = true } = {}) {
   const url = process.env.ATLAS_ASK_URL;
   const token = process.env.ATLAS_ASK_TOKEN;
   if (!url || !token) {
@@ -80,7 +93,7 @@ export async function ask(prompt, { tools = true, fresh = false, timeoutMs = 600
       "Connect a model in Atlas Studio, or do this step in code."
     );
   }
-  const body = { job: process.env.ATLAS_JOB || "", prompt: String(prompt), tools, fresh };
+  const body = { job: process.env.ATLAS_JOB || "", prompt: String(prompt), tools, fresh, commands: commands !== false };
   // Sent only when named, so a script that does not care keeps whatever is
   // connected rather than pinning itself to today's default.
   if (String(model || "").trim()) body.model = String(model).trim();
@@ -346,19 +359,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; });
@@ -392,6 +416,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

@@ -54,24 +54,32 @@ def atlas(tool, **params):
         raise RuntimeError("Atlas %s failed (%d): %s" % (tool, e.code, body))
 
 
-def ask(prompt, tools=True, fresh=False, timeout=600, model=""):
-    """Ask YOUR OWN model a question and get its answer back as text.
+def ask(prompt, tools=True, fresh=False, timeout=600, model="", commands=True):
+    """Ask YOUR OWN model, the way you would in the chat, and get its answer back.
 
-    For the steps only a model can do: reading a filing and pulling out the
-    guidance, judging whether a headline is about the company or its sector,
-    summarising what changed since yesterday. Everything else - fetching,
-    counting, comparing, placing orders - is faster and more reliable as plain
-    code, so use this for judgement, not for arithmetic.
-
-    It runs on this computer, through the model already connected in Atlas
-    Remote Control. The prompt never reaches Atlas.
+    IT IS A CHAT SESSION, NOT A TEXT BOX (owner, 2026-09-11). The model runs on
+    this computer, in this project's folder, with everything the chat has: the
+    files here, the shell, the `atlas` command line, Atlas's own tools, the
+    skills, and the computer when the switch is on. Ask it to open the broker
+    and read a balance and it will drive the screen; ask it to write and run
+    something and it will. Its last message is what you get back.
 
         verdict = ask("Is this headline about AAPL itself or the sector?\n" + line)
         if "itself" in verdict.lower():
             ...
+        balance = ask("Open the broker in Edge and read me the cash balance. "
+                      "Answer with the number only.")
+
+    Nobody is watching, so it never asks a question back: it decides. Say what
+    shape you want the answer in ("the number only", "one of: buy, sell, wait")
+    and that is what arrives.
+
+    commands=True (the default) is that whole session. commands=False is for
+    pure judgement - twenty headline classifications - where the model should
+    answer from what you gave it and run nothing; it is faster and cheaper.
 
     tools=True lets the model reach Atlas data while it answers; pass
-    tools=False for pure text work, which is faster.
+    tools=False for text work that needs none of it.
 
     fresh=False keeps ONE conversation for this job, so later questions can
     refer to earlier ones and the model starts up only once. Pass fresh=True
@@ -104,7 +112,7 @@ def ask(prompt, tools=True, fresh=False, timeout=600, model=""):
             "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)}
+            "tools": bool(tools), "fresh": bool(fresh), "commands": bool(commands)}
     # Sent only when named, so a script that does not care keeps whatever is
     # connected rather than pinning itself to today's default.
     if str(model or "").strip():