mindvest-atlas 0.68.3 → 0.68.4

package/package.json

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

@@ -21,7 +21,7 @@
 // ONE IMPLEMENTATION, NOT TWO: every subcommand runs the SAME atlas_env function
 // a project's script would call, inside the project, so the switch, the claim,
 // the action log and standing back for a person are identically the same rules.
-import { spawnSync } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -285,6 +285,63 @@ export function runInProject(job, code, root) {
   return out.status === null ? 1 : out.status;
 }
 
+/**
+ * Start a watch that OUTLIVES this command.
+ *
+ * A watch runs for hours by design: it looks, decides how long to wait, and
+ * looks again. Run in the foreground, a shell agent that started one would sit
+ * there until it finished — one turn, held open, with nothing to show for it.
+ * The Python CLI has detached it since 2026-09-06; this runtime ran it inline,
+ * and this runtime is the one Atlas Studio bundles, so the blocking version is
+ * the one a chat actually got (owner, 2026-09-15).
+ *
+ * Detached, with no console and no pipes: what it does is visible in the watch
+ * window and the action log, which is where somebody watching already is.
+ */
+function startWatch(job, instruction, flags) {
+  if (!String(instruction || '').trim()) {
+    eprintln(color.red('Say what to watch for.'));
+    eprintln(color.dim('  atlas computer-use watch "when SPY breaks the opening range high, buy 1 call"'));
+    return 1;
+  }
+  const { dir } = workspace(job, undefined);
+  if (!fs.existsSync(dir)) {
+    eprintln(color.red(`There is no project called ${job} on this computer.`));
+    return 1;
+  }
+  try { ensureProjectFiles(dir); } catch { /* it may already be right */ }
+  const venv = venvPython(dir);
+  const python = venv ? [String(venv)] : [...ambientPython()];
+  const env = { ...process.env, ...jobEnv(dir), ATLAS_JOB: path.basename(dir) };
+  if (!env.ATLAS_ASK_URL || !env.ATLAS_ASK_TOKEN) {
+    const at = askAddress(undefined);
+    if (at) { env.ATLAS_ASK_URL = at.url; env.ATLAS_ASK_TOKEN = at.token; }
+  }
+  if (!env.ATLAS_COMPUTER_SESSION) env.ATLAS_COMPUTER_SESSION = shellSession(undefined);
+  env.PYTHONPATH = [dir, process.env.PYTHONPATH].filter(Boolean).join(path.delimiter);
+  ensureDeps(python, dir, env);
+  const kw = { every: Number(flags.every || 5) };
+  if (flags.most) kw.most = Number(flags.most);
+  if (flags.hours) kw.hours = Number(flags.hours);
+  const code = 'import atlas_env as e, json, sys\n'
+    + 'e.watch(json.loads(sys.argv[1]), **json.loads(sys.argv[2]))\n';
+  try {
+    const child = spawn(
+      python[0],
+      [...python.slice(1), '-c', code, JSON.stringify(String(instruction)), JSON.stringify(kw)],
+      { cwd: dir, env, stdio: 'ignore', detached: true, ...HIDDEN },
+    );
+    child.unref();
+  } catch (err) {
+    eprintln(color.red(`Could not start watching: ${err && err.message ? err.message : err}`));
+    return 1;
+  }
+  println(color.dim('Watching started. It looks, decides how long to wait, and looks again.'));
+  println(color.dim('  Follow it in the watch window, or: atlas computer-use screen'));
+  println(color.dim('  Stop ends it — the whole thing, wait included.'));
+  return 0;
+}
+
 export function computerUseCommand(args) {
   const flags = args.flags || {};
   const rest = [...(args.positional || args._ || [])];
@@ -351,6 +408,11 @@ export function computerUseCommand(args) {
     return out;
   }
 
+  // A WATCH FROM A CHAT MUST COME BACK: detached unless told otherwise.
+  if (sub === 'watch' && flags.background !== false) {
+    return startWatch(job, rest[0] || '', flags);
+  }
+
   // SEVERAL ACTIONS AND ONE PICTURE, in one process. The slow part was never
   // the clicking: it was a command and a look for every step, when four of them
   // were visible in the picture you already had.