mindvest-atlas 0.100.2 → 0.100.3

package/package.json

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

@@ -20,6 +20,7 @@ import { screenshotCommand } from './commands/screenshot.js';
 import { runCommand } from './commands/run.js';
 import { computerAccess } from './access.js';
 import { installCommand } from './commands/install.js';
+import { deviceCommand } from './commands/device.js';
 import { computerUseCommand } from './commands/computer-use.js';
 import { dashboardCommand } from './commands/dashboard.js';
 import { chatSearchCommand } from './commands/chat-search.js';
@@ -125,6 +126,10 @@ export async function main(rawArgs) {
       // environment under the Atlas folder; Studio's Libraries tab uses it too.
       case 'install':
         return await installCommand(withoutCommand(args));
+      // WHAT THIS COMPUTER HAS, so heavy work is sized to it (owner,
+      // 2026-10-17). Read here only; nothing is sent anywhere.
+      case 'device':
+        return await deviceCommand(withoutCommand(args));
       case 'run': {
         // A run on this computer needs a plan (or the free week): asked
         // before anything starts, never in the middle of one.

package/src/commands/device.js

@@ -0,0 +1,72 @@
+// `atlas device`: what this computer has, for sizing heavy work to it (owner,
+// 2026-10-17: "it first queries the user's device to see their resources: can
+// this computer run this algorithm, and optimize for it").
+//
+//   atlas device                 in words
+//   atlas device --json          the answer as JSON (the helper's device())
+//   atlas device --job <name>    a project's disk and Python (default: this folder)
+//   atlas device --path <dir>    the disk at that folder
+//
+// Read on this computer only: nothing is sent anywhere. The answer is the
+// helpers' own (helpers/atlas_env.js deviceAnswer, field for field the Python
+// helper's device()), so a script and an agent in a shell see the same thing.
+import fs from 'node:fs';
+import path from 'node:path';
+import { println } from '../util/ui.js';
+import { deviceAnswer } from '../helpers/atlas_env.js';
+import { ambientPython, envPython, librariesVenv, safeSlug, venvPython, workspaceRoot } from '../remote-control.js';
+
+/** The folder asked about: --path, else --job under the Atlas folder, else here. */
+export function deviceFolder(flags = {}, cwd = process.cwd()) {
+  if (typeof flags.path === 'string' && flags.path) return path.resolve(flags.path);
+  if (typeof flags.job === 'string' && flags.job) return path.join(workspaceRoot(), 'scripts', safeSlug(flags.job));
+  return cwd;
+}
+
+/** The Python a project there runs with: its own .venv, the computer's
+ *  libraries, else the one on PATH (the runner's own order). */
+export function devicePythonFor(dir) {
+  const own = venvPython(dir);
+  if (own) return [own];
+  const shared = envPython(librariesVenv());
+  if (fs.existsSync(shared)) return [shared];
+  return ambientPython();
+}
+
+const gbWords = (n) => (n === null || n === undefined ? 'unknown' : `${Number(n).toFixed(1)} GB`);
+
+/** The answer in words, for a person or an agent reading a terminal. */
+export function deviceWords(a) {
+  const lines = ['This computer'];
+  const cpu = a.cpu || {};
+  lines.push(`  Processor  ${cpu.model}, ${cpu.cores} cores${cpu.physical_cores ? ` (${cpu.physical_cores} physical)` : ''}`
+    + `${cpu.load_1m !== null && cpu.load_1m !== undefined ? `, load ${Number(cpu.load_1m).toFixed(1)}` : ''}`);
+  lines.push(`  Memory     ${gbWords(a.memory?.free_gb)} free of ${gbWords(a.memory?.total_gb)}`);
+  const gpus = a.gpus || [];
+  lines.push(`  Graphics   ${gpus.length ? gpus.map((g) => `${g.name}${g.memory_gb ? ` (${gbWords(g.memory_gb)}${g.unified ? ', shared with memory' : ''})` : ''}`).join('; ') : 'none found'}`);
+  lines.push(`  Disk       ${gbWords(a.disk?.free_gb)} free of ${gbWords(a.disk?.total_gb)} at ${a.disk?.path}`);
+  if (a.python) {
+    const libs = Object.entries(a.python.libraries || {});
+    const have = libs.filter(([, v]) => v).map(([k, v]) => `${k} ${v}`);
+    lines.push(`  Python     ${a.python.version} (${a.python.path})`);
+    lines.push(`  Libraries  ${have.length ? have.join(', ') : 'none of the heavy ones'}`);
+  } else {
+    lines.push('  Python     none found');
+  }
+  lines.push(`  Allowed    ${Math.round((a.allowed?.share ?? 0.6) * 100)}% of this computer${a.allowed?.set ? ' (set in Atlas Studio)' : ' (not set; Atlas Studio\'s default)'}`);
+  const ad = a.advice || {};
+  lines.push('');
+  lines.push(`Size work to: ${ad.workers} worker${ad.workers === 1 ? '' : 's'}, under ${gbWords(ad.memory_gb)} of memory, `
+    + `and stop if the disk has under ${gbWords(ad.disk_floor_gb)} free${ad.disk_ok ? '' : ' (it has: do not start)'}.`);
+  for (const n of a.notes || []) lines.push(`- ${n}`);
+  return lines.join('\n');
+}
+
+export async function deviceCommand(args) {
+  const flags = { ...(args.flags || {}) };
+  const where = deviceFolder(flags);
+  const a = deviceAnswer({ where, python: devicePythonFor(where), root: workspaceRoot() });
+  if (flags.json) println(JSON.stringify(a));
+  else println(deviceWords(a));
+  return 0;
+}

package/src/commands/remote-control.js

@@ -9,19 +9,20 @@
 // A job that could NOT run is reported too: silence is indistinguishable from
 // a schedule that quietly broke, which is the failure the record exists to make
 // visible.
-import { spawn, spawnSync } from 'node:child_process';
+import { spawn } from 'node:child_process';
 import { API, baseUrl } from '../config.js';
 import { requestJson, jobToken } from '../api/client.js';
 import { runStream } from '../util/stream-loop.js';
 import { computerAccess } from '../access.js';
 import { color, eprintln } from '../util/ui.js';
+import * as children from '../util/children.js';
 import {
   DEFAULT_TIMEOUT_MS, CHECKS_TIMEOUT_MS, checksCommand, claimRun, computerName, isPaused, jobEnv, listJobFiles, listRuns, machineId,
   osLabel, readJobFile, readJobTable, releaseRun, staleness, summarize, tail, workspace, workspaceRoot,
   takeRequests,
   takeActionCommands, writeActionReply, actionArgv, runAction, actionHandler, claimAsk, REPLIES_DIR, COMMANDS_DIR,
   writeCommand,
-  beatRunner,
+  beatRunner, forgetRunner, sweepActionTemp, releaseComputerClaim,
   setPaused, writeHelpers, askModel, listModels, chatModel, answerPermission, stopChat, chatState, chatUpdatedAt,
   createProject, ensureProjectFiles, listChats, readChat, deleteChat, appendChat,
   computerUseAllowed, listComputerSessions, readComputerActions, listComputerVideo, readComputerVideoPart,
@@ -86,28 +87,18 @@ async function report() {
 const running = new Map();
 
 /** Kill a run's whole process tree. On Windows a plain kill leaves the
- *  script's own children going; taskkill /T takes the tree. */
+ *  script's own children going; taskkill /T takes the tree. THE WHOLE GROUP
+ *  on macOS and Linux: runs start in a process group of their own (see
+ *  runOnce), so a script's children go with it instead of living on holding
+ *  its output open. One implementation for every child: util/children.js. */
 function killTree(child, hard = false) {
   if (!child || child.pid === undefined) return;
-  if (process.platform === 'win32') {
-    try { spawnSync('taskkill', ['/pid', String(child.pid), '/T', '/F'], { windowsHide: true }); return; } catch { /* fall through */ }
-  }
-  // THE WHOLE GROUP on macOS and Linux: runs start in a process group of their
-  // own (see runOnce), so a script's children go with it instead of living on
-  // holding its output open.
-  const pid = child.pid;
-  const signal = (sig) => {
-    try { process.kill(-pid, sig); return; } catch { /* no group: the child alone */ }
-    try { child.kill(sig); } catch { /* already gone */ }
-  };
-  if (hard) { signal('SIGKILL'); return; }
-  signal('SIGTERM');
-  setTimeout(() => {
-    try { process.kill(pid, 0); } catch { try { process.kill(-pid, 0); } catch { return; } }
-    signal('SIGKILL');
-  }, 3_000).unref();
+  children.killTree(child, { hard, tree: process.platform !== 'win32' });
 }
 
+/** The run slots this runner holds right now, so an exit gives them back. */
+const heldSlots = new Set();
+
 /** End every run this runner started (it is going away). */
 export function stopAllRuns() {
   for (const [, entry] of running) {
@@ -185,6 +176,9 @@ export function runOnce(argv, dir, env, timeoutMs, key = path.basename(dir)) {
     const child = spawn(argv[0], argv.slice(1), {
       cwd: dir, env, windowsHide: true, detached: process.platform !== 'win32',
     });
+    // On the runner's list: ended with the runner, and by the next start if
+    // the runner is killed outright.
+    children.track(child, { name: key, group: 'run', tree: process.platform !== 'win32' });
     const entry = { child, stopped: false };
     running.set(key, entry);
     starting.delete(key);
@@ -396,6 +390,9 @@ async function handleAsk(ask, root) {
           PYTHONPATH: [dir, process.env.PYTHONPATH].filter(Boolean).join(path.delimiter),
         },
       });
+      // It ends by itself (two minutes, or when nobody holds the computer);
+      // on the list so a runner that goes first takes it along.
+      children.track(child, { name: `watch:${path.basename(dir)}`, group: 'watch' });
       let buf = '';
       child.stdout.on('data', (d) => {
         buf += d;
@@ -701,7 +698,9 @@ async function runJob(job, root, timeoutMs) {
   // releaseRun, NOT itself: calling `release()` here (0.89.0 to 0.97.0) never
   // freed the slot, so every later run of the project on this runner was
   // turned away as "already running" until the runner restarted.
-  const release = () => { if (!released) { released = true; releaseRun(slot); } };
+  heldSlots.add(slot);
+  const release = () => { if (!released) { heldSlots.delete(slot); released = true; releaseRun(slot); } };
+  let computerSessionId = '';
   try {
 
   // Refreshed every run, so a job always has the supported way to reach a
@@ -722,6 +721,7 @@ async function runJob(job, root, timeoutMs) {
       ATLAS_COMPUTER_SESSION: new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19),
     }
     : {};
+  computerSessionId = computerEnv.ATLAS_COMPUTER_SESSION || '';
   const env = {
     ...process.env,
     // Secrets first (shared .env, then the job's own), so a job's own env can
@@ -780,6 +780,9 @@ async function runJob(job, root, timeoutMs) {
   } finally {
     release();
     if (isChecks) checksEndedAt.set(path.basename(dir), Date.now());
+    // And the COMPUTER, if this run took it (the Python runner always did):
+    // only the claim this run's own session holds, and only once it has ended.
+    if (computerSessionId) releaseComputerClaim(computerSessionId, root);
   }
 }
 
@@ -1179,14 +1182,24 @@ export async function remoteControlCommand(args) {
   // here and keep going whether or not the server can be reached. The stream
   // below adds one thing only: the web being able to see this computer and ask
   // it for something.
+  // NOTHING LEFT BEHIND (owner, 2026-10-17). What an earlier runner that was
+  // killed outright left running is ended first (only processes it recorded,
+  // still the same ones), and its scratch files with it.
+  const parentPid = takeParentPid();
+  children.useStateDir(childrenDir(root));
+  reportReaped(children.reapOrphans());
+  sweepActionTemp();
   const stopSchedule = startLocalSchedule(root, timeoutMs);
   const stopRequests = startLocalRequests(root, timeoutMs);
-  process.once('exit', () => { stopSchedule(); stopRequests(); stopAllRuns(); });
-  // Runs have process groups of their own, so a Ctrl-C or a stop from the app
-  // no longer reaches them by itself: the runner takes them down on its way.
-  for (const sig of ['SIGINT', 'SIGTERM']) {
-    process.once(sig, () => { stopAllRuns(); process.exit(0); });
+  const leave = onLeaving(root, [stopSchedule, stopRequests]);
+  process.once('exit', leave);
+  // Runs have process groups of their own, so a Ctrl-C, a closed terminal or a
+  // stop from the app no longer reaches them by itself: the runner takes them
+  // down on its way. Quick on purpose (Atlas Studio waits two seconds).
+  for (const sig of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
+    process.once(sig, () => { leave(); process.exit(0); });
   }
+  watchForParent(parentPid, leave);
   startAlertListener(root, timeoutMs);
   // Say at the start whether runs will start here: a plan or the free week
   // (the first ask is also what starts the week for somebody new).
@@ -1245,6 +1258,69 @@ export async function remoteControlCommand(args) {
   }
 }
 
+/** Where the runner keeps the list of what it started (util/children.js). */
+export const childrenDir = (root) => path.join(workspaceRoot(root), '.runner-children');
+
+/**
+ * The parent this runner should go with (ATLAS_PARENT_PID, which Atlas Studio
+ * sets), taken OUT of the environment so no run, action, watcher or other
+ * process this runner starts inherits it: only this runner acts on it.
+ */
+export function takeParentPid(env = process.env) {
+  const v = String(env[children.PARENT_ENV] || '').trim();
+  delete env[children.PARENT_ENV];
+  return v;
+}
+
+function reportReaped(r) {
+  for (const c of r.ended) eprintln(color.dim(`· ended ${c.name || 'a process'} (pid ${c.pid}) left by a runner that stopped`));
+}
+
+/**
+ * Everything a runner does on its way out, once: the clocks stopped, every
+ * run and child ended with its tree, its run slots and its heartbeat given
+ * back (only its own), its list removed. Synchronous: no network.
+ */
+export function onLeaving(root, stops = []) {
+  let left = false;
+  return () => {
+    if (left) return;
+    left = true;
+    for (const stop of stops) { try { stop(); } catch { /* going anyway */ } }
+    try { stopAllRuns(); } catch { /* going anyway */ }
+    try { children.killAll(); } catch { /* going anyway */ }
+    for (const slot of [...heldSlots]) { heldSlots.delete(slot); releaseRun(slot); }
+    forgetRunner(root);
+    children.forgetStateFile();
+  };
+}
+
+/**
+ * GO WITH THE PARENT. Atlas Studio starts this runner in a process group of its
+ * own; if Studio is force-quit nothing tells the runner, and it and its runs
+ * would carry on with nobody to show them. With a parent pid, this notices the
+ * parent is gone (two checks in a row, three seconds apart) and leaves. A
+ * closed stdout or stderr pipe asks at once, and is never on its own a reason
+ * to go. Without a parent pid (a person in a terminal) nothing changes.
+ */
+export function watchForParent(parentPid, leave, { intervalMs = 3_000, exit = (c) => process.exit(c) } = {}) {
+  if (!parentPid) return null;
+  const watch = children.watchParent(parentPid, (pid) => {
+    try { eprintln(color.dim(`● the app that started this (pid ${pid}) is gone; stopping`)); } catch { /* no one to tell */ }
+    leave();
+    exit(0);
+  }, { intervalMs });
+  if (!watch) return null;
+  for (const stream of [process.stdout, process.stderr]) {
+    stream.on('error', (err) => {
+      // A pipe nobody reads any more: ask about the parent now. The runner
+      // keeps going while the parent is alive (it stops nothing on a guess).
+      if (err && err.code === 'EPIPE') watch.checkNow();
+    });
+  }
+  return watch;
+}
+
 /** For the tests: the one road every run takes. */
 export const runJobForTests = (job, root, timeoutMs) => runJob(job, root, timeoutMs);
 

package/src/config.js

@@ -2,7 +2,7 @@
 import path from 'node:path';
 import os from 'node:os';
 
-export const VERSION = '0.100.2';
+export const VERSION = '0.100.3';
 export const DEFAULT_BASE_URL = 'https://atlasmcp.finmanagerai.com';
 export const DEFAULT_SCOPE = 'atlas broker';
 export const CLIENT_NAME = 'Atlas CLI';

package/src/dashboard-view.js

@@ -0,0 +1,111 @@
+// A project's dashboard.json, as the website is sent it (owner, 2026-10-17:
+// "a dashboard's file overflowed past 200 and the dashboard just stopped
+// working").
+//
+// WHAT BROKE: the relay's `read` sends no text file over 256 KB (MAX_VIEW_BYTES),
+// so once a long-running project's dashboard.json grew past that, every read
+// from the web answered "That file is too large to show here." The web's
+// dashboard keeps its last good draw on a failed read, so it simply stopped:
+// the numbers froze and nothing said why. A dashboard of a few hundred rows
+// with a dozen fields each, written with indent=2, is past 256 KB.
+//
+// NOW: dashboard.json is read here whole (up to 64 MB), every list in it is cut
+// to its newest DRAW_MAX rows (the helpers' order rule: newest last unless the
+// first row is dated after the last), and the answer is held under SEND_MAX by
+// halving the longest list again. What was cut rides in the JSON as
+// `__atlas_cut` [{list, shown, of}], which the website takes off the data and
+// hands its dashboard frame to say "Showing the newest 5,000 of 48,213". A
+// small file with short lists goes exactly as it is, byte for byte.
+//
+// The python runner does the same (read_job_file -> _dashboard_view), with the
+// helper's own functions.
+import fs from 'node:fs';
+import { cutList, dataLists } from './helpers/atlas_env.js';
+
+/** Rows of one list sent to be drawn. Above the helpers' 500, so a project
+ *  that keeps its window is never cut here. */
+export const DRAW_MAX = 5000;
+/** What one read of the dashboard's data may send. */
+export const SEND_MAX = 4 * 1024 * 1024;
+/** Past this the file is not even parsed. */
+export const READ_MAX = 64 * 1024 * 1024;
+/** The key the cut rides under, taken off by the website before drawing. */
+export const CUT_KEY = '__atlas_cut';
+
+const sizeWords = (n) => (n < 1024 * 1024 ? `${Math.round(n / 1024)} KB` : `${(n / (1024 * 1024)).toFixed(1)} MB`);
+
+function copyObjects(d, depth = 0) {
+  if (!d || typeof d !== 'object' || Array.isArray(d) || depth > 4) return d;
+  return Object.fromEntries(Object.entries(d).map(([k, v]) => [k, copyObjects(v, depth + 1)]));
+}
+
+/**
+ * The data with every list cut to its newest `max`, and what was cut:
+ * {data, cut: [{list, shown, of}]}. The caller's own object is not changed.
+ * A top-level list (not an object) is cut too, with nowhere to say so.
+ */
+export function capDashboardData(data, max = DRAW_MAX, sendMax = Infinity) {
+  if (Array.isArray(data)) {
+    const kept = cutList(data, max)[0];
+    return { data: kept, cut: kept.length < data.length ? [{ list: '', shown: kept.length, of: data.length }] : [] };
+  }
+  const out = copyObjects(data);
+  const of = {};
+  for (const [p, holder, k] of dataLists(out)) {
+    if (holder[k].length > max) {
+      of[p] = holder[k].length;
+      holder[k] = cutList(holder[k], max)[0];
+    }
+  }
+  // Still too big to send: the longest list again, by halves, never under 50.
+  let text = JSON.stringify(out);
+  while (text.length > sendMax) {
+    const lists = dataLists(out).filter(([, h, k]) => h[k].length > 50);
+    if (!lists.length) break;
+    const [p, h, k] = lists.reduce((a, b) => (b[1][b[2]].length > a[1][a[2]].length ? b : a));
+    if (!(p in of)) of[p] = h[k].length;
+    h[k] = cutList(h[k], Math.max(50, Math.floor(h[k].length / 2)))[0];
+    text = JSON.stringify(out);
+  }
+  const shown = Object.fromEntries(dataLists(out).map(([p, h, k]) => [p, h[k].length]));
+  return { data: out, cut: Object.keys(of).map((p) => ({ list: p, shown: shown[p] ?? 0, of: of[p] })) };
+}
+
+const kept = new Map();
+
+/**
+ * dashboard.json at `target` as the relay answers it: {ok, text} or {ok: false,
+ * error}. The same file, unchanged since the last read, is not parsed again.
+ */
+export function dashboardView(target, viewMax = 256 * 1024) {
+  let st;
+  try { st = fs.statSync(target); } catch { return { ok: false, error: 'That file could not be read.' }; }
+  if (st.size > READ_MAX) {
+    return { ok: false, error: `This dashboard's data is ${sizeWords(st.size)}, too large to draw. Ask the agent to keep less of it on the dashboard.` };
+  }
+  const stamp = `${st.mtimeMs}:${st.size}`;
+  const was = kept.get(target);
+  if (was && was.stamp === stamp) return was.answer;
+  let text;
+  try { text = fs.readFileSync(target, 'utf8'); } catch { return { ok: false, error: 'That file could not be read.' }; }
+  let parsed;
+  try { parsed = JSON.parse(text); } catch {
+    // Half written, or not JSON: as it is when small (the dashboard keeps its
+    // last good draw), a failed read when large.
+    return st.size <= viewMax ? { ok: true, text } : { ok: false, error: 'That file could not be read.' };
+  }
+  const { data, cut } = capDashboardData(parsed, DRAW_MAX, SEND_MAX - 4096);
+  let answer;
+  if (!cut.length && st.size <= viewMax) {
+    answer = { ok: true, text };
+  } else {
+    if (cut.length && data && typeof data === 'object' && !Array.isArray(data)) data[CUT_KEY] = cut;
+    const out = JSON.stringify(data);
+    answer = out.length > SEND_MAX
+      ? { ok: false, error: `This dashboard's data is ${sizeWords(st.size)}, too large to send to the web. Ask the agent to keep less of it on the dashboard.` }
+      : { ok: true, text: out };
+  }
+  kept.set(target, { stamp, answer });
+  if (kept.size > 50) kept.delete(kept.keys().next().value);
+  return answer;
+}