mindvest-atlas 0.68.2 → 0.68.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindvest-atlas",
-  "version": "0.68.2",
+  "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/cli.js

@@ -24,6 +24,14 @@ import { remoteCheckCommand } from './commands/remote-check.js';
 import { shareCommand } from './commands/share.js';
 import { historicalContractCommand } from './commands/historical.js';
 import { callCommand } from './commands/call.js';
+// WITHOUT THESE, `atlas --version` PRINTED THE BARE NUMBER AND NOTHING ELSE.
+// They were called but never imported, and the call sits inside a try/catch
+// that swallows anything — so the ReferenceError was invisible and the detail
+// this exists to show (which atlas answered, what else is installed) never
+// appeared. That is the confusion it was written to end: owner, 2026-09-04,
+// "the atlas.cmd does not update on reinstalling, also the mindvest-atlas is
+// using a different version — this is confusing."
+import { installedClis, whichAtlas, versionDetailLines } from './cli-installs.js';
 
 /**
  * Say which Atlas answered and what else is installed.

package/src/commands/alerts.js

@@ -14,6 +14,7 @@ import { runStream } from '../util/stream-loop.js';
 import { formatAlert } from '../util/format.js';
 import { color, println, eprintln, prettyJson } from '../util/ui.js';
 import { requestJson } from '../api/client.js';
+import { moved } from './moved.js';
 import * as background from '../util/background.js';
 
 // Names the slot, the claim file and the log, and it is the command's own name
@@ -29,24 +30,6 @@ function sanitizeFilename(name) {
 // ── list / delete ────────────────────────────────────────────────────────────
 const callTool = (name, body) => requestJson(API.tool(name), { method: 'POST', body: body || {} });
 
-async function listAlerts(flags) {
-  const data = await callTool('List-Alerts', {
-    ...(flags.all ? { active_only: false } : {}),
-    ...(flags.symbol ? { symbol: String(flags.symbol).toUpperCase() } : {}),
-  });
-  if (flags.json) { println(prettyJson(data)); return 0; }
-  const list = (data && (data.alerts || data.data)) || (Array.isArray(data) ? data : []);
-  if (!list.length) { println(color.dim('No alerts.')); return 0; }
-  for (const a of list) {
-    const state = a.is_active === false ? color.dim('off') : color.green('on');
-    println(`${state}  ${color.bold(a.name || '(unnamed)')}  ${color.dim([a.symbol, a.alert_type].filter(Boolean).join(' · '))}`);
-    println(color.dim(`     ${a.id}`));
-  }
-  println('');
-  println(color.dim('Switch one off:  atlas alerts delete --id <id>'));
-  println(color.dim('Delete for good: atlas alerts delete --id <id> --purge'));
-  return 0;
-}
 
 /** The shape of every event on the feed, as JSON Schema, so a script or a
  *  model can read it once and rely on it. Alerts and trades share it. */
@@ -56,32 +39,6 @@ async function schema() {
   return 0;
 }
 
-async function deleteAlerts(args) {
-  const flags = args.flags;
-  // --id may repeat; extra positionals after the verb are ids too, so
-  // `atlas alerts delete a b c` does what it looks like it does.
-  const fromFlags = flags.id === undefined ? [] : (Array.isArray(flags.id) ? flags.id : [flags.id]);
-  const ids = [...fromFlags, ...(args._ || []).slice(1)]
-    .map((x) => String(x || '').trim())
-    .filter((x) => x && x !== 'true');
-  if (!ids.length) {
-    eprintln(color.red('Which alert? --id <id> (repeat for several), or list them: atlas alerts list'));
-    return 1;
-  }
-  const purge = !!flags.purge;
-  const data = await callTool('Delete-Alert', {
-    alert_ids: ids, purge,
-  });
-  if (data && data.error) { eprintln(color.red(String(data.error))); return 1; }
-  if (flags.json) { println(prettyJson(data)); return 0; }
-  println(data.message || (purge ? 'Deleted.' : 'Switched off.'));
-  // A purge that kept some says why, and the message already names them; this
-  // points at the way through rather than leaving the user to guess.
-  if (data.kept && Object.keys(data.kept).length) {
-    println(color.dim('Repoint those setups, or drop --purge to just switch the alert off.'));
-  }
-  return 0;
-}
 
 export async function alertsCommand(args) {
   const flags = args.flags;
@@ -92,8 +49,13 @@ export async function alertsCommand(args) {
   // (owner, 2026-09-12: "it's hard to manage spoiled alerts without a
   // something to delete them").
   const verb = String((args._ && args._[0]) || '').toLowerCase();
-  if (verb === 'list' || verb === 'ls') return await listAlerts(flags);
-  if (verb === 'delete' || verb === 'rm' || verb === 'off') return await deleteAlerts(args);
+  // ONE NAME PER CAPABILITY. These wrapped a single tool each; the generic path
+  // reaches it by name. See commands/moved.js.
+  const rest = { _: (args._ || []).slice(1), flags };
+  if (verb === 'list' || verb === 'ls') return await moved(`alerts ${verb}`, 'list-alerts', rest);
+  if (verb === 'delete' || verb === 'rm' || verb === 'off') return await moved(`alerts ${verb}`, 'delete-alert', rest);
+  // KEPT: there is no tool behind these two. `schema` reads a public route, and
+  // a bare `atlas alerts` is the live feed — a stream is not a tool call.
   if (verb === 'schema') return await schema();
   if (flags.stop) return background.stop(SLOT);
   if (flags.detach) return background.detach(SLOT);

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,48 @@ 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.
+  //
+  //   atlas computer-use do "click 820 410" "type hello" "key enter"
+  //
+  // This is the batching every skill tells a model to use, and it was missing
+  // here — from the runtime Atlas Studio bundles — so a model in a chat that
+  // followed the instructions was told `There is no "do" here` (owner,
+  // 2026-09-15: "see if we can unify things instead of diverging").
+  if (sub === 'do') {
+    if (!rest.length) {
+      eprintln(color.red('What should it do? e.g. do "click 820 410" "type hello"'));
+      return 1;
+    }
+    const steps = [];
+    for (const raw of rest) {
+      const bits = String(raw).split(/\s+/).filter(Boolean);
+      if (!bits.length) continue;
+      const verb = bits[0].toLowerCase();
+      if (!OPS[verb]) {
+        eprintln(color.red(`There is no "${verb}" to do.`));
+        return 1;
+      }
+      const [name] = OPS[verb];
+      // A quoted phrase is one value: `type "hello there"` means two words
+      // typed, not a word typed twice.
+      const vals = (verb === 'type' || verb === 'note' || verb === 'find')
+        ? (bits.length > 1 ? [bits.slice(1).join(' ')] : [])
+        : bits.slice(1).map((v) => (NUMERIC.has(verb) ? Number(v) : v));
+      steps.push([name, ...vals]);
+    }
+    const code = 'import atlas_env as e, json\n'
+      + `print(json.dumps(e.do(*[tuple(s) for s in json.loads(${JSON.stringify(JSON.stringify(steps))})]), default=str, indent=2))\n`;
+    return runInProject(job, code);
+  }
+
   if (!OPS[sub]) {
     eprintln(color.red(`There is no "${sub}" here.`));
     println(HELP);

package/src/commands/moved.js

@@ -0,0 +1,32 @@
+// A VERB THAT ONLY WRAPPED A TOOL, kept working while it goes.
+//
+// Owner, 2026-09-15: "scan through all my mcp, cli, api and see if we can unify
+// things instead of diverging ... I have divergence because now I have too much
+// commands."
+//
+// Most `atlas alerts <verb>` and `atlas signals <verb>` subcommands did one
+// thing: call a single tool and print a table. The generic path reaches every
+// tool by name already — `atlas list-alerts`, `atlas signal-take` — against the
+// live catalogue, which is the one road that cannot drift because nobody
+// maintains it. A second spelling is what made the surface feel large, and it
+// was worse than redundant: eight Trade-* and Signal-* tools never got a verb,
+// so an agent that learned the verbs concluded closing a trade was impossible.
+//
+// So the verbs forward, once, with a line saying where they went. They are
+// removed in a later release; this is here so nobody's script breaks on the day
+// they update.
+import { color, eprintln } from '../util/ui.js';
+import { callCommand } from './call.js';
+
+// An ES import binding cannot be replaced from outside, so the forward goes
+// through this object: a test can swap `forwardTo.call` and assert WHERE a verb
+// went without a network round trip. The Python twin patches the module
+// attribute for the same reason.
+export const forwardTo = { call: callCommand };
+
+export async function moved(verb, slug, args) {
+  eprintln(color.dim(
+    `atlas ${verb} is now atlas ${slug} — same thing, one name. This forwards for now.`,
+  ));
+  return await forwardTo.call(slug, args);
+}

package/src/commands/signals.js

@@ -13,6 +13,7 @@
 import { API } from '../config.js';
 import { requestJson } from '../api/client.js';
 import { color, println, eprintln, prettyJson } from '../util/ui.js';
+import { moved } from './moved.js';
 
 const HELP = `${color.bold('atlas signals')} — plays: your groups, the board, and what they have made
 
@@ -140,39 +141,22 @@ export async function signalsCommand(args) {
   const groupId = flags.group || flags['group-id'] || flags.id;
 
   switch (sub) {
-    case 'groups': {
-      const data = await callTool('Signal-Groups', {});
-      if (failed(data)) return printFailure(data);
-      if (json) { println(prettyJson(data)); return 0; }
-      const list = data.groups || data.data || [];
-      if (!list.length) { println(color.dim('No groups yet. The community board is always there: atlas signals plays --board community')); return 0; }
-      for (const g of list) {
-        const bits = [g.role, g.visibility, g.signal_count != null ? `${g.signal_count} plays` : null].filter(Boolean);
-        println(`${color.bold(g.name || '(unnamed)')}  ${color.dim(bits.join(' · '))}`);
-        println(color.dim(`  ${g.id}`));
-      }
-      return 0;
-    }
-    case 'plays':
-    case 'list': {
-      const body = {};
-      if (flags.board) body.board = String(flags.board);
-      if (flags.group) body.group_id = String(flags.group);
-      if (flags.days !== undefined) body.days = num(flags.days);
-      if (flags.limit !== undefined) body.limit = num(flags.limit);
-      const data = await callTool('Signal-List', body);
-      if (failed(data)) return printFailure(data);
-      if (json) { println(prettyJson(data)); return 0; }
-      const list = rows(data.plays || data.signals || data);
-      if (!list.length) { println(color.dim('Nothing on that board in that window.')); return 0; }
-      for (const s of list) {
-        const p = s.payload || s;
-        const what = [p.side, p.symbol, p.strike ? `$${p.strike}` : null, (p.option_type || '').toUpperCase() || null,
-          p.expiration_date || p.expiry || null].filter(Boolean).join(' ');
-        println(`${color.bold(what || '(play)')}  ${color.dim(s.status || '')}`);
-        println(color.dim(`  ${s.id}${s.posted_at ? '  ' + s.posted_at : ''}`));
-      }
-      return 0;
+    // ONE NAME PER CAPABILITY (owner, 2026-09-15). Each of these wrapped a
+    // single tool and printed a table; the generic path reaches every tool by
+    // name against the live catalogue, including the eight Signal-*/Trade-*
+    // tools that never got a verb here. `post` stays — its --link/--with-*
+    // grammar for a second leg is not something a flag schema can express.
+    case 'groups': case 'plays': case 'list': case 'show': case 'take':
+    case 'performance': case 'perf': case 'delete': case 'rm':
+    case 'discover': case 'follow': case 'schema': {
+      const MOVED = {
+        groups: 'signal-groups', plays: 'signal-list', list: 'signal-list',
+        show: 'signal-show', take: 'signal-take',
+        performance: 'signal-group-performance', perf: 'signal-group-performance',
+        delete: 'signal-group-delete', rm: 'signal-group-delete',
+        discover: 'signal-discover', follow: 'signal-follow', schema: 'signal-schema',
+      };
+      return await moved(`signals ${sub}`, MOVED[sub], { _: (args._ || []).slice(1), flags });
     }
     case 'post': {
       const leg = legFrom(flags, '', null);
@@ -203,97 +187,6 @@ export async function signalsCommand(args) {
       println(data.message || (link ? 'Posted both, linked.' : 'Posted.'));
       return 0;
     }
-    case 'show': {
-      const id = flags.id || flags.play || flags.signal;
-      if (!id) { eprintln(color.red('Which play? --id <play-id>')); return 1; }
-      const data = await callTool('Signal-Show', { signal_id: String(id) });
-      if (failed(data)) return printFailure(data);
-      println(prettyJson(data));
-      return 0;
-    }
-    case 'take': {
-      const id = flags.id || flags.play || flags.signal;
-      if (!id) { eprintln(color.red('Which play? --id <play-id>')); return 1; }
-      const body = { signal_id: String(id) };
-      if (flags.contracts !== undefined) body.contracts = num(flags.contracts);
-      if (flags.account) body.account_id = String(flags.account);
-      const data = await callTool('Signal-Take', body);
-      if (failed(data)) return printFailure(data);
-      println(json ? prettyJson(data) : (data.message || 'Taken.'));
-      return 0;
-    }
-    case 'performance':
-    case 'perf': {
-      if (!groupId) { eprintln(color.red('Which group? --group <id>  (atlas signals groups)')); return 1; }
-      const data = await callTool('Signal-Group-Performance', {
-        group_id: String(groupId), mine: !!flags.mine,
-      });
-      if (failed(data)) return printFailure(data);
-      if (json) { println(prettyJson(data)); return 0; }
-      const t = data.totals || {};
-      const name = data.display_name || data.name || 'this group';
-      const whose = data.whose === 'mine' ? 'your own trades' : "the author's record";
-      println(`${color.bold(name)} ${color.dim('— ' + whose)}`);
-      println(`  Closed trades  ${(data.rows || []).length}`);
-      println(`  Win rate       ${t.win_rate ?? 0}%  ${color.dim(`(${t.win_count ?? 0} up, ${t.loss_count ?? 0} down)`)}`);
-      println(`  Total          ${money(t.total_pnl)}  ${color.dim(`${t.total_pnl_pct ?? 0}%`)}`);
-      if (data.viewer_has_rows && data.whose !== 'mine') {
-        println(color.dim('  You have taken plays here too: add --mine for your own numbers.'));
-      }
-      return 0;
-    }
-    case 'delete':
-    case 'rm': {
-      if (!groupId) { eprintln(color.red('Which group? --group <id>  (atlas signals groups)')); return 1; }
-      const stop = !!(flags['stop-subscribers'] || flags.stop);
-      const data = await callTool('Signal-Group-Delete', {
-        group_id: String(groupId), stop_subscribers: stop,
-      });
-      if (failed(data)) {
-        // THE REFUSAL WITH AN ANSWER. People are subscribed: say how many, say
-        // what stopping them costs them, and print the line that does it —
-        // rather than an error that names a screen this person is not looking at.
-        if (data.code === 'has_subscribers') {
-          const n = Number(data.subscriber_count) || 1;
-          eprintln(color.yellow(`${n} ${n === 1 ? 'person is' : 'people are'} subscribed to this group.`));
-          eprintln(color.dim('Deleting stops their billing at once, so there is no next payment, and they'
-            + ' lose the rest of the month they paid for. Anything they already traded is theirs.'));
-          eprintln('');
-          eprintln('  ' + color.cyan(`atlas signals delete --group ${groupId} --stop-subscribers`));
-          return 1;
-        }
-        return printFailure(data);
-      }
-      println(json ? prettyJson(data) : (data.message || 'Group deleted.'));
-      return 0;
-    }
-    case 'discover': {
-      const data = await callTool('Signal-Discover', {});
-      if (failed(data)) return printFailure(data);
-      if (json) { println(prettyJson(data)); return 0; }
-      const list = data.groups || [];
-      if (!list.length) { println(color.dim('No public groups yet.')); return 0; }
-      for (const g of list) {
-        println(`${color.bold(g.name || '(unnamed)')}  ${color.dim([g.owner_label, `${g.follower_count ?? 0} following`].filter(Boolean).join(' · '))}`);
-        println(color.dim(`  ${g.id}`));
-      }
-      return 0;
-    }
-    case 'follow': {
-      if (!groupId) { eprintln(color.red('Which group? --group <id>')); return 1; }
-      const data = await callTool('Signal-Follow', {
-        group_id: String(groupId), follow: flags.off ? false : flags.follow !== false,
-      });
-      if (failed(data)) return printFailure(data);
-      println(json ? prettyJson(data) : (data.message || 'Done.'));
-      return 0;
-    }
-    case 'schema': {
-      const data = await callTool('Signal-Schema', {});
-      if (failed(data)) return printFailure(data);
-      println(typeof data === 'string' ? data : prettyJson(data));
-      return 0;
-    }
     default:
       eprintln(color.red(`Unknown: atlas signals ${sub}`));
       println(HELP);

package/src/util/help.js

@@ -28,17 +28,12 @@ export function printRootHelp() {
   println('        [--no-greeks] [--json]');
   println();
   println(c.bold('PLAYS (SIGNALS)'));
-  println('  signals groups                                     Groups you post to, and the ones you follow');
-  println('  signals plays [--board community|private]          The plays [--days N] [--limit N]');
-  println('  signals performance --group <id> [--mine]          A group\'s closed trades and win rate');
-  println('  signals delete --group <id> [--stop-subscribers]   Delete a group (stops subscriptions first)');
-  println('  signals take --id <play> [--contracts N]           Place a play in your account');
-  println('  signals <discover|follow|show|schema>              ' + c.dim('atlas signals help for all of it'));
+  println('  signals post --symbol SPY ...                      Post a play (--link oco|oeo for a second leg)');
+  println('  signal-groups · signal-list · signal-take          ' + c.dim('every Signal-* and Trade-* tool, by name'));
   println();
   println(c.bold('STREAMS'));
-  println('  alerts list [--all] [--symbol SPY]                 Your alerts, with their ids');
   println('  alerts schema                                      The shape of every feed event (JSON Schema)');
-  println('  alerts delete --id <id> [--id <id2>] [--purge]     Switch alerts off, or delete for good');
+  println('  list-alerts · delete-alert --alert-ids <id>        ' + c.dim('your alerts, and clearing spoiled ones'));
   println('  alerts [--symbol SPY] [--name greek_exposure]      Live alert feed (SSE)');
   println('         [--save-charts <dir>] [--no-chart] [--json]');
   println('         [--detach] [--stop]                        Stream in the background, or stop it');
@@ -64,14 +59,12 @@ export function printRootHelp() {
   println(c.dim('  atlas options-chain --symbol SPY --expiration 2026-06-20'));
   println(c.dim('  atlas historical-contract --symbol NVDA --expiry 2026-07-13 --strike 205 --side call --from 2026-07-06 --to 2026-07-10'));
   println(c.dim('  atlas update-alert --alert-id <id> --updates.is-active true   # nested via a dotted flag'));
-  println(c.dim('  atlas create-task --name "Close SPY 3:55" --instruction "Close my SPY position" --schedule-times 15:55'));
-  println(c.dim('  atlas run-task --task-id <id>'));
   println(c.dim('  atlas workflow-create --name "GEX signal" --schedule "30 9 * * 1-5" --tools Stock-Quote --instruction "…"'));
   println(c.dim('  atlas workflow-create --name "FOMC day" --run-once-at "2026-09-17 14:00" --tools Stock-Quote --instruction "…"   # once, at specific dates/times; --trigger-source manual = Run now only'));
   println(c.dim('  atlas alerts --symbol SPY --name greek_exposure --save-charts ./charts'));
   println(c.dim('  atlas flow stream --symbol NVDA'));
-  println(c.dim('  atlas signals performance --group <id>'));
-  println(c.dim('  atlas signals delete --group <id> --stop-subscribers'));
+  println(c.dim('  atlas signal-group-performance --group-id <id>'));
+  println(c.dim('  atlas signal-group-delete --group-id <id> --stop-subscribers'));
 }
 
 // Parse the `Args:` block of a tool docstring into { paramName: description }.