mindvest-atlas 0.98.0 → 0.99.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindvest-atlas",
-  "version": "0.98.0",
+  "version": "0.99.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/remote-control.js

@@ -283,6 +283,8 @@ async function handleAsk(ask, root) {
   // results are read like any file (op 'read' on checks.json and checks/).
   if (ask.op === 'checks') return answer(ask.request_id, startChecks({ ...ask, why: 'web' }, root));
   if (ask.op === 'checks_auto') return answer(ask.request_id, setCheckAuto(ask, root));
+  // Pause, resume or delete one check (owner, 2026-10-15), in checks/settings.json.
+  if (ask.op === 'checks_state') return answer(ask.request_id, setCheckState(ask, root));
   // ── Sharing a project ────────────────────────────────────────────────
   // Not awaited: a pack, an upload and a download are seconds to minutes on a
   // home connection, and the ask loop has the run queue, the schedule and every
@@ -1045,6 +1047,7 @@ export function checksTick(root, nowMs = Date.now(), spawn = spawnJob) {
     if (!fs.existsSync(path.join(dir, 'checks.py'))) continue;
     const when = checksWhen(dir);
     const prints = projectPrints(dir);
+    const off = checksOff(dir);
     let s = checksSeen.get(slug);
     if (!s) { checksSeen.set(slug, { at: nowMs, ...prints, filesAt: 0, dataAt: 0, fixed: new Set() }); continue; }
     const busy = running.has(`${slug}:checks`) || starting.has(`${slug}:checks`) || nowMs - (checksEndedAt.get(slug) ?? 0) < 30_000;
@@ -1056,6 +1059,11 @@ export function checksTick(root, nowMs = Date.now(), spawn = spawnJob) {
     else if (when.files && s.filesAt && nowMs - s.filesAt >= SETTLE_MS) why = 'files';
     else if (when.data && s.dataAt && nowMs - s.dataAt >= SETTLE_MS) why = 'data';
     s.at = nowMs;
+    const results = readJsonFile(path.join(dir, 'checks.json'));
+    const rows = Array.isArray(results?.checks) ? results.checks : [];
+    // EVERY CHECK PAUSED OR DELETED: nothing to run by itself (atlas_env would
+    // skip each one anyway, after fetching its data for nothing).
+    if (why && rows.length && rows.every((c) => off.has(String(c?.id)))) { s.filesAt = 0; s.dataAt = 0; continue; }
     if (why) {
       s.filesAt = 0; s.dataAt = 0;
       const r = startChecks({ job: slug, why }, root, spawn);
@@ -1063,9 +1071,9 @@ export function checksTick(root, nowMs = Date.now(), spawn = spawnJob) {
       continue;
     }
     // A FIX THAT NOTHING HAS RUN SINCE: that check again, fresh.
-    const results = readJsonFile(path.join(dir, 'checks.json'));
     const fixes = readJsonFile(path.join(dir, 'checks', 'resolutions.json'));
-    for (const c of Array.isArray(results?.checks) ? results.checks : []) {
+    for (const c of rows) {
+      if (off.has(String(c?.id))) continue;
       const f = fixes && fixes[c?.id];
       if (!f || f.ok === false || c.status === 'pass' || s.fixed.has(`${c.id}@${f.at}`)) continue;
       if (Date.parse(f.at) <= Date.parse(c.ran_at || '')) continue;
@@ -1225,7 +1233,11 @@ export function startChecks(ask, root, spawn = spawnJob) {
   const job = String(ask?.job || '');
   const { dir } = workspace(job, root);
   if (!job || !fs.existsSync(path.join(dir, 'checks.py'))) return { ok: false, error: 'This project has no checks yet.' };
-  const only = (Array.isArray(ask.only) ? ask.only : []).map(String).filter((x) => /^[A-Za-z0-9_-]{1,80}$/.test(x));
+  const asked = (Array.isArray(ask.only) ? ask.only : []).map(String).filter((x) => /^[A-Za-z0-9_-]{1,80}$/.test(x));
+  // A paused or deleted check is never run, not even when named.
+  const off = checksOff(dir);
+  const only = asked.filter((x) => !off.has(x));
+  if (asked.length && !only.length) return { ok: false, error: 'That check is paused. Resume it to run it.' };
   const replay = /^\d{8}-\d{6}$/.test(String(ask.replay || '')) ? String(ask.replay) : '';
   // What started it, for the run's history line (a word, or nothing).
   const why = /^[a-z]{1,20}$/.test(String(ask.why || '')) ? String(ask.why) : '';
@@ -1264,6 +1276,59 @@ export function cleanAssume(raw) {
   return Object.keys(out).length ? JSON.stringify(out) : '';
 }
 
+/** The checks the person paused or deleted (checks/settings.json), by id. */
+export function checksOff(dir) {
+  const d = readJsonFile(path.join(dir, 'checks', 'settings.json')) || {};
+  const paused = d.paused && typeof d.paused === 'object' ? d.paused : {};
+  const deleted = d.deleted && typeof d.deleted === 'object' ? d.deleted : {};
+  return new Set([...Object.keys(paused).filter((k) => paused[k]), ...Object.keys(deleted)]);
+}
+
+/**
+ * PAUSE, RESUME OR DELETE ONE CHECK (owner, 2026-10-15: "I can pause and
+ * delete checks ... a button to pause checks so it never runs"), from the web
+ * or a phone. checks/settings.json, which Atlas Studio writes the same way
+ * and atlas_env reads at every run: a paused check never runs; a deleted one
+ * also leaves the results and is not written back.
+ */
+export function setCheckState(ask, root) {
+  const id = String(ask?.id || '');
+  const action = String(ask?.action || '');
+  if (!/^[A-Za-z0-9_-]{1,80}$/.test(id)) return { ok: false, error: 'That is not a check.' };
+  if (!['pause', 'resume', 'delete'].includes(action)) return { ok: false, error: 'Pause, resume or delete.' };
+  const { dir } = workspace(String(ask?.job || ''), root);
+  if (!fs.existsSync(dir)) return { ok: false, error: 'There is no such project on this computer.' };
+  const file = path.join(dir, 'checks', 'settings.json');
+  const d = readJsonFile(file) || {};
+  const paused = d.paused && typeof d.paused === 'object' ? d.paused : {};
+  const deleted = d.deleted && typeof d.deleted === 'object' ? d.deleted : {};
+  if (action === 'pause') paused[id] = true;
+  else delete paused[id];
+  if (action === 'delete') {
+    deleted[id] = new Date().toISOString();
+    if (d.auto_resolve && typeof d.auto_resolve === 'object') delete d.auto_resolve[id];
+  }
+  d.paused = paused;
+  d.deleted = deleted;
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(`${file}.tmp`, JSON.stringify(d, null, 2));
+    fs.renameSync(`${file}.tmp`, file);
+  } catch {
+    return { ok: false, error: 'That could not be saved.' };
+  }
+  if (action === 'delete') {
+    // Its row leaves the results; its history stays (the person's record).
+    const res = path.join(dir, 'checks.json');
+    const r = readJsonFile(res);
+    if (r && Array.isArray(r.checks) && r.checks.some((c) => c?.id === id)) {
+      r.checks = r.checks.filter((c) => c?.id !== id);
+      try { fs.writeFileSync(`${res}.tmp`, JSON.stringify(r, null, 2)); fs.renameSync(`${res}.tmp`, res); } catch { /* the settings already hide it */ }
+    }
+  }
+  return { ok: true };
+}
+
 /** One check's auto-resolve switch, in checks/settings.json (Atlas Studio reads it too). */
 export function setCheckAuto(ask, root) {
   const id = String(ask?.id || '');

package/src/config.js

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

@@ -1030,6 +1030,23 @@ def _read_json(path, default):
         return default
 
 
+def _check_id(value):
+    return "".join(c if c.isalnum() or c in "-_" else "-" for c in str(value))[:80] or "check"
+
+
+def _checks_off():
+    """THE CHECKS THE PERSON PAUSED OR DELETED (owner, 2026-10-15: "a button to
+    pause checks so it never runs"). Kept in checks/settings.json beside the
+    auto-fix switches, by Atlas Studio, the web (through the runner) and
+    restore_check(). A paused or deleted check never runs: wants() says no and
+    result() keeps nothing, whatever started the run (its schedule, a change,
+    Run all, an agent building)."""
+    d = _read_json(os.path.join(_checks_dir(), "checks", "settings.json"), {})
+    paused = d.get("paused") if isinstance(d.get("paused"), dict) else {}
+    deleted = d.get("deleted") if isinstance(d.get("deleted"), dict) else {}
+    return {str(k) for k, v in paused.items() if v} | {str(k) for k in deleted}
+
+
 def _library_versions():
     try:
         from importlib import metadata as _md
@@ -1069,6 +1086,8 @@ class _CheckRun:
         # per check): what assume() handed out, per check, in order.
         self._assumed = {}
         self._mine_cache = None
+        # Paused or deleted by the person: never run, never recorded.
+        self.off = _checks_off()
         self._watch_the_end()
         # THE ONE MODEL THAT RUNS THESE CHECKS (owner, 2026-10-15: "what model
         # performed the test"): the project's atlas.json "checks": {"model"},
@@ -1302,7 +1321,10 @@ class _CheckRun:
 
     # ── results ──
     def wants(self, check_id):
-        """False for a check this run was not asked for (Recheck of one)."""
+        """False for a check this run was not asked for (Recheck of one), and
+        for one the person paused or deleted."""
+        if _check_id(check_id) in self.off:
+            return False
         return not self.only or check_id in self.only
 
     def result(self, check_id, status, title, summary="", fixed=None, report=None,
@@ -1316,7 +1338,11 @@ class _CheckRun:
         agent is asked when the person presses Resolve."""
         import time as _time
         status = status if status in _CHECK_STATUSES else "warn"
-        cid = "".join(c if c.isalnum() or c in "-_" else "-" for c in str(check_id))[:80] or "check"
+        cid = _check_id(check_id)
+        # Paused or deleted: nothing of it is kept, even from a checks.py that
+        # did not ask wants() first.
+        if cid in self.off:
+            return
         report_rel = None
         if report:
             text = str(report)
@@ -1583,6 +1609,18 @@ def checks():
     return _CheckRun()
 
 
+def restore_check(check_id):
+    """Bring back a check the person deleted (or paused), ONLY when they ask
+    for it back: it runs again from the next run."""
+    cid = _check_id(check_id)
+    path = os.path.join(_checks_dir(), "checks", "settings.json")
+    data = _read_json(path, {})
+    for key in ("paused", "deleted"):
+        if isinstance(data.get(key), dict):
+            data[key].pop(cid, None)
+    _write_json(path, data)
+
+
 def progress(step="", done=None, total=None, message="", **extra):
     """Say where you are, so the dashboard can draw it.
 

package/src/remote-control.js

@@ -689,16 +689,20 @@ export function checksCommand(dir) {
 
 /**
  * When a project's checks run by themselves: atlas.json "checks": {"schedule":
- * "30 8 * * 1-5", "on": ["files", "data"]} (local time, like Atlas Studio).
+ * "30 8 * * 1-5", "on": ["files", "data"], "timezone": "America/New_York"}.
  */
 export function checksWhen(dir) {
-  const c = readManifest(dir).checks;
+  const m = readManifest(dir);
+  const c = m.checks;
   const o = c && typeof c === 'object' ? c : {};
   const expr = typeof o.schedule === 'string' ? o.schedule.trim() : '';
   const cron = expr ? parseCron(expr) : null;
   const on = Array.isArray(o.on) ? o.on.map(String) : [];
+  // The zone it is read in: the checks' own, else the project's, else UTC like
+  // every schedule (Atlas Studio and the web say it in these words too).
+  const tz = [o.timezone, m.timezone].find((z) => typeof z === 'string' && z.trim()) || '';
   return {
-    schedule: cron ? { expr, lines: [{ kind: 'cron', cron, text: expr }], tz: '', error: null, cron } : null,
+    schedule: cron ? { expr, lines: [{ kind: 'cron', cron, text: expr }], tz: String(tz).trim(), error: null, cron } : null,
     files: on.includes('files'),
     data: on.includes('data'),
   };
@@ -1448,12 +1452,53 @@ export function readJobTable(job, rel, root) {
   }
 }
 
+/**
+ * A PDF, Word or PowerPoint file goes to the web as its bytes, like a picture
+ * (owner, 2026-10-15: "pdf file support, word docs ... for everything"): the
+ * website draws it (its components/files/DocView.tsx). Read as text it was a
+ * screenful of bytes, or refused past the text ceiling. Nothing else is sent
+ * as bytes: a .doc or a zip is not drawn there, so it is not carried.
+ */
+export const DOC_TYPES = {
+  '.pdf': 'application/pdf',
+  '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  '.docm': 'application/vnd.ms-word.document.macroEnabled.12',
+  '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  '.pptm': 'application/vnd.ms-powerpoint.presentation.macroEnabled.12',
+  '.ppsx': 'application/vnd.openxmlformats-officedocument.presentationml.slideshow',
+};
+
+/** The relay's ceiling for a document: a picture's. Atlas's server holds it too. */
+export const MAX_DOC_BYTES = MAX_IMAGE_BYTES;
+
+/** The content type for a document's name, or '' if it is not one. */
+export function docType(name) {
+  const n = String(name).toLowerCase();
+  const dot = n.lastIndexOf('.');
+  return dot >= 0 ? (DOC_TYPES[n.slice(dot)] || '') : '';
+}
+
+/** "12.4 MB", the website's words (lib/doc-view.ts sizeWords). */
+function sizeWords(bytes) {
+  if (bytes < 1024) return `${bytes} bytes`;
+  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
 export function readJobFile(job, rel, root) {
   const where = jobTarget(job, rel, root);
   if (!where.ok) return where;
   const { target } = where;
   const mime = imageType(path.basename(target));
+  const doc = docType(path.basename(target));
   try {
+    if (doc) {
+      const size = fs.statSync(target).size;
+      // Worded as the website's viewer words it, which tells it apart from a
+      // computer from before (that one refused a document as too long a text).
+      if (size > MAX_DOC_BYTES) return { ok: false, error: `This file is ${sizeWords(size)}, too large to show here.` };
+      return { ok: true, mime: doc, b64: fs.readFileSync(target).toString('base64') };
+    }
     if (fs.statSync(target).size > (mime ? MAX_IMAGE_BYTES : MAX_VIEW_BYTES)) {
       return { ok: false, error: 'That file is too large to show here.' };
     }