mindvest-atlas 0.4.2 → 0.5.0

package/package.json

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

@@ -14,6 +14,7 @@ import { alertsCommand } from './commands/alerts.js';
 import { flowCommand } from './commands/flow.js';
 import { remoteControlCommand } from './commands/remote-control.js';
 import { updateCliCommand } from './commands/update-cli.js';
+import { remoteCheckCommand } from './commands/remote-check.js';
 import { historicalContractCommand } from './commands/historical.js';
 import { callCommand } from './commands/call.js';
 
@@ -50,6 +51,9 @@ export async function main(rawArgs) {
       case 'alerts': return await alertsCommand(withoutCommand(args));
       case 'flow': return await flowCommand(withoutCommand(args));
       // Long-lived: hold the job stream and run this computer's jobs.
+      // Walk the whole loop and say which hop fails.
+      case 'remote-check':
+        return await remoteCheckCommand();
       // Put the newest CLI on this machine.
       case 'update-cli':
       case 'self-update':

package/src/commands/remote-check.js

@@ -0,0 +1,88 @@
+// `atlas remote-check` — prove the whole loop, or say exactly which link is broken.
+//
+// "Connected but nothing happens" is the hardest kind of failure to report,
+// because every part looks fine on its own: the app says connected, the queue
+// accepts jobs, the runs page is empty. The only useful question is which HOP
+// fails, so this walks them in order and stops at the first one that does.
+//
+// Run it while `atlas remote-control` is running in another window.
+import { API, VERSION } from '../config.js';
+import { requestJson, isLoggedIn } from '../api/client.js';
+import { computerName } from '../remote-control.js';
+import { color, println } from '../util/ui.js';
+
+const OK = () => color.green('  OK   ');
+const BAD = () => color.red('  FAIL ');
+const step = (n, label) => { println(''); println(color.bold(`${n}. ${label}`)); };
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+export async function remoteCheckCommand() {
+  step(1, 'Signed in?');
+  if (!isLoggedIn()) {
+    println(BAD() + 'Not signed in. Run `atlas login`.');
+    return 1;
+  }
+  try {
+    const who = await requestJson('/oauth/userinfo');
+    println(OK() + (who.email || who.sub || 'signed in'));
+  } catch (err) {
+    println(BAD() + `Could not verify the token: ${err.message}`);
+    return 1;
+  }
+
+  step(2, 'Is a computer connected?');
+  let status;
+  try {
+    status = await requestJson(API.remoteStatus);
+  } catch (err) {
+    println(BAD() + `Could not read the status: ${err.message}`);
+    return 1;
+  }
+  if (!status.online) {
+    println(BAD() + 'No computer is connected.');
+    println('       Start `atlas remote-control` (or turn on Local Mode in the app),');
+    println(`       then run this again. This machine is ${computerName()}.`);
+    return 1;
+  }
+  println(OK() + `${status.computer || 'a computer'} is connected.`);
+
+  step(3, 'Queue a test job');
+  try {
+    const res = await requestJson(API.remoteJobs, {
+      method: 'POST',
+      body: { automation_id: 'remote-check', name: 'Remote check', source: 'manual', payload: { hello: 'world' } },
+    });
+    println(OK() + `queued (${res.queued ?? '?'} waiting)`);
+  } catch (err) {
+    println(BAD() + `Could not queue it: ${err.message}`);
+    return 1;
+  }
+
+  step(4, 'Did the computer pick it up?');
+  println(color.dim('       waiting up to 30s…'));
+  let seen = null;
+  const deadline = Date.now() + 30_000;
+  while (Date.now() < deadline) {
+    await sleep(2000);
+    try {
+      const runs = await requestJson(`${API.localRuns}?automation_id=remote-check&limit=1`);
+      if (Array.isArray(runs) && runs.length) { seen = runs[0]; break; }
+    } catch { /* keep waiting */ }
+  }
+  if (!seen) {
+    println(BAD() + 'Nothing came back.');
+    println('       The job was queued but the computer never ran it. The runner is');
+    println('       connected, so the break is between the queue and the run —');
+    println('       check the `atlas remote-control` window for errors.');
+    return 1;
+  }
+  println(OK() + `${seen.machine || 'the computer'} reported: ${seen.status}`);
+  // not_built is the RIGHT answer here: remote-check has no script, and the
+  // point is that the round trip completed, not that a script existed.
+  if (seen.status === 'not_built') {
+    println(color.dim('       (no script for it — which is expected, and proves the round trip)'));
+  }
+  println('');
+  println(color.green(`Everything works. CLI ${VERSION}.`));
+  return 0;
+}

package/src/commands/remote-control.js

@@ -15,15 +15,50 @@ import { requestJson } from '../api/client.js';
 import { runStream } from '../util/stream-loop.js';
 import { color, eprintln } from '../util/ui.js';
 import {
-  DEFAULT_TIMEOUT_MS, computerName, jobEnv, staleness, summarize, tail, workspace, workspaceRoot,
+  DEFAULT_TIMEOUT_MS, computerName, jobEnv, listJobFiles, machineId, osLabel,
+  readJobFile, staleness, summarize, tail, workspace, workspaceRoot,
 } from '../remote-control.js';
 import fs from 'node:fs';
+import path from 'node:path';
 
 const iso = (ms) => new Date(ms).toISOString().replace(/\.\d+Z$/, 'Z');
 
-/** POST one run record. Best-effort: a failed report must not take down the
- *  runner, and the next job still deserves to run. */
-async function report(job, status, started, finished, extra = {}) {
+/**
+ * Keep the run's own account of itself, on this computer.
+ *
+ * The server is told THAT a run happened; what it printed stays here. That is
+ * the whole promise of Local Mode, and it is also where a person debugging
+ * should look — the log sits next to the script that produced it.
+ *
+ * Best-effort: a job that ran must not be reported as failed because a log file
+ * could not be written.
+ */
+function writeLog(dir, job, status, started, finished, text) {
+  try {
+    const logs = path.join(dir, 'runs');
+    fs.mkdirSync(logs, { recursive: true });
+    const d = new Date(started);
+    const p2 = (n) => String(n).padStart(2, '0');
+    const stamp = `${d.getFullYear()}${p2(d.getMonth() + 1)}${p2(d.getDate())}`
+      + `-${p2(d.getHours())}${p2(d.getMinutes())}${p2(d.getSeconds())}`;
+    fs.writeFileSync(path.join(logs, `${stamp}-${status}.log`),
+      `${iso(started)}  ${status}  ${job.name || ''}\n`
+      + `took ${((finished - started) / 1000).toFixed(1)}s\n\n`
+      + (text || '(no output)\n'));
+    // Keep the last 50, so a job running every five minutes does not fill a
+    // disk it was never given permission to fill.
+    const old = fs.readdirSync(logs).filter((f) => f.endsWith('.log')).sort().slice(0, -50);
+    for (const f of old) { try { fs.unlinkSync(path.join(logs, f)); } catch { /* gone */ } }
+  } catch { /* a log is a courtesy, never a failure */ }
+}
+
+/**
+ * POST that a run happened. METADATA ONLY — never what the script printed.
+ *
+ * Best-effort: a failed report must not take down the runner, and the next job
+ * still deserves to run.
+ */
+async function report(job, status, started, finished) {
   try {
     await requestJson(API.localRuns, {
       method: 'POST',
@@ -32,9 +67,6 @@ async function report(job, status, started, finished, extra = {}) {
         name: job.name || '',
         source: job.source || 'schedule',
         status,
-        summary: extra.summary ?? null,
-        output: extra.output ?? null,
-        error: extra.error ?? null,
         started_at: iso(started),
         finished_at: iso(finished),
         // One account can run jobs on several computers; the results view says
@@ -63,6 +95,27 @@ function runOnce(argv, dir, env, timeoutMs) {
   });
 }
 
+/** Send one answer back up. Pass-through: the server relays it to whoever asked
+ *  and stores none of it, which is what keeps a file's contents on this computer
+ *  even while someone is looking at them. */
+async function answer(requestId, payload) {
+  try {
+    await requestJson(API.remoteAnswer, { method: 'POST', body: { request_id: requestId, ...payload } });
+  } catch (err) {
+    eprintln(color.dim(`  ↳ could not answer: ${err.message}`));
+  }
+}
+
+/** A question from the web about THIS computer's workspace. Read-only and
+ *  confined to the jobs folder: it can list what is there and show one file; it
+ *  cannot write, delete, or reach outside. */
+async function handleAsk(ask, root) {
+  if (!ask?.request_id) return;
+  if (ask.op === 'list') return answer(ask.request_id, { ok: true, jobs: listJobFiles(root) });
+  if (ask.op === 'read') return answer(ask.request_id, readJobFile(ask.job || '', ask.path || '', root));
+  return answer(ask.request_id, { ok: false, error: 'Unknown request.' });
+}
+
 async function runJob(job, root, timeoutMs) {
   const name = job.name || job.automation_id || 'job';
   const started = Date.now();
@@ -70,7 +123,7 @@ async function runJob(job, root, timeoutMs) {
   const late = staleness(job);
   if (late) {
     eprintln(color.yellow(`↷ ${name} — too late`));
-    return report(job, 'skipped_stale', started, Date.now(), { summary: late });
+    return report(job, 'skipped_stale', started, Date.now());
   }
 
   const { dir, entry, argv } = workspace(job.automation_id, root);
@@ -79,10 +132,7 @@ async function runJob(job, root, timeoutMs) {
     // was simply nothing to carry out yet. Its owner never sees the code, so
     // they cannot tell "broken" from "unfinished" unless the status does it.
     eprintln(color.yellow(`· ${name} — nothing to run yet`));
-    return report(job, 'not_built', started, Date.now(), {
-      summary: 'Nothing is running yet. This setup has not been built, so there was'
-        + ' nothing for your computer to do.',
-    });
+    return report(job, 'not_built', started, Date.now());
   }
 
   eprintln(color.dim(`▶ ${name}`));
@@ -99,23 +149,20 @@ async function runJob(job, root, timeoutMs) {
   const finished = Date.now();
   if (r.timedOut) {
     eprintln(color.red(`✗ ${name} — timed out`));
-    return report(job, 'failed', started, finished, {
-      error: `Stopped after ${Math.round(timeoutMs / 1000)}s. The script did not finish.`,
-      output: tail(r.out),
-    });
+    writeLog(dir, job, 'failed', started, finished,
+      `Stopped after ${Math.round(timeoutMs / 1000)}s. The script did not finish.\n${tail(r.out) || ''}`);
+    return report(job, 'failed', started, finished);
   }
   if (r.error) {
     eprintln(color.red(`✗ ${name} — ${r.error}`));
-    return report(job, 'failed', started, finished, { error: r.error, output: tail(r.out) });
+    writeLog(dir, job, 'failed', started, finished, `${r.error}\n${tail(r.out) || ''}`);
+    return report(job, 'failed', started, finished);
   }
   const ok = r.code === 0;
   eprintln((ok ? color.green('✓ ') : color.red('✗ ')) + name
     + color.dim(` (${((finished - started) / 1000).toFixed(1)}s)`));
-  return report(job, ok ? 'completed' : 'failed', started, finished, {
-    summary: summarize(r.out, ok),
-    output: tail(r.out),
-    error: ok ? null : `Exited ${r.code}.`,
-  });
+  writeLog(dir, job, ok ? 'completed' : 'failed', started, finished, tail(r.out));
+  return report(job, ok ? 'completed' : 'failed', started, finished);
 }
 
 export async function remoteControlCommand(args) {
@@ -126,7 +173,10 @@ export async function remoteControlCommand(args) {
   eprintln(color.dim(`${computerName()} — Atlas can run jobs here. Workspace: ${workspaceRoot(root)}`));
   eprintln(color.dim('Nothing runs while this is closed. Ctrl-C to stop.'));
 
-  const jobsPath = `${API.remoteJobs}?computer=${encodeURIComponent(computerName())}`;
+  // Identity is the machine id; the name and OS are how it is DISPLAYED. Two
+  // processes on one computer therefore share one row instead of splitting it.
+  const q = new URLSearchParams({ computer: computerName(), machine_id: machineId(), os: osLabel() });
+  const jobsPath = `${API.remoteJobs}?${q}`;
   return runStream(jobsPath, {
     label: 'remote-control',
     reconnect: flags.reconnect !== false,
@@ -148,6 +198,8 @@ export async function remoteControlCommand(args) {
     onEvent: async ({ event, payload }) => {
       if (event === 'job' || event === 'message' || event === 'run') {
         await runJob(payload, root, timeoutMs);
+      } else if (event === 'ask') {
+        await handleAsk(payload, root);
       }
     },
   });

package/src/config.js

@@ -2,7 +2,7 @@
 import path from 'node:path';
 import os from 'node:os';
 
-export const VERSION = '0.4.2';
+export const VERSION = '0.5.0';
 export const DEFAULT_BASE_URL = 'https://atlasmcp.finmanagerai.com';
 export const DEFAULT_SCOPE = 'atlas broker';
 export const CLIENT_NAME = 'Atlas CLI';
@@ -40,6 +40,8 @@ export const API = {
   // goes back UP to localRuns. The web never calls this machine.
   remoteJobs: '/api/v1/remote-computer/jobs',
   remotePending: '/api/v1/remote-computer/pending',
+  remoteStatus: '/api/v1/remote-computer/status',
+  remoteAnswer: '/api/v1/remote-computer/answer',
   localRuns: '/api/local/runs',
 };
 

package/src/remote-control.js

@@ -8,6 +8,8 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { configDir } from './config.js';
 
 /**
  * Default workspace root, one directory per automation underneath.
@@ -69,6 +71,49 @@ export function computerName() {
   return host.slice(0, 200) || 'this computer';
 }
 
+/**
+ * What kind of computer this is, in the words its owner would use.
+ *
+ * Windows 11 still reports its release as 10.x — the BUILD number is the only
+ * thing separating them, and 22000 is where 11 starts.
+ */
+export function osLabel() {
+  const p = os.platform();
+  const rel = os.release();
+  if (p === 'win32') {
+    const build = Number(rel.split('.')[2] || 0);
+    return build >= 22000 ? 'Windows 11' : 'Windows 10';
+  }
+  if (p === 'darwin') return 'macOS';
+  if (p === 'linux') return `Linux ${rel}`.trim();
+  return `${p} ${rel}`.trim();
+}
+
+/**
+ * A stable id for THIS computer, created once and kept.
+ *
+ * Identity cannot be the hostname: two processes on one machine (a terminal and
+ * the app) would each register, and the owner would see their single laptop
+ * twice. Nor can it be derived from the hostname — renaming a computer would
+ * spawn a second one. So it is a random id written next to the credentials,
+ * shared by every process here and surviving a rename.
+ */
+export function machineId() {
+  const file = path.join(configDir(), 'machine-id');
+  try {
+    const existing = fs.readFileSync(file, 'utf8').trim();
+    if (existing) return existing.slice(0, 64);
+  } catch { /* not created yet */ }
+  const id = randomUUID().replace(/-/g, '');
+  try {
+    fs.mkdirSync(configDir(), { recursive: true });
+    fs.writeFileSync(file, id);
+  } catch {
+    // Unwritable config dir: a per-session id beats refusing to connect.
+  }
+  return id;
+}
+
 /** The automation's OWN interpreter, if it has one. A venv is a DEPENDENCY
  *  boundary, not a security one, so falling back to the ambient python is a
  *  convenience, never a safety decision. */
@@ -173,3 +218,68 @@ export function summarize(output, ok) {
   if (!lines.length) return ok ? 'Ran and finished.' : null;
   return lines[lines.length - 1].slice(0, 2000);
 }
+
+/** Files bigger than this are not read into a browser: a job's script or log is
+ *  a few KB, and anything past it is a data file the viewer would choke on. */
+export const MAX_VIEW_BYTES = 256 * 1024;
+const SKIP_DIRS = new Set(['.venv', 'node_modules', '__pycache__']);
+
+/**
+ * Every job folder and what is in it, as plain metadata.
+ *
+ * Names, sizes and times only — never contents. Confined to the workspace: this
+ * answers a request that arrived over the network, so it must not be able to
+ * describe anything outside the folder Atlas was given.
+ */
+export function listJobFiles(root) {
+  const base = path.join(workspaceRoot(root), SCRIPTS_DIR);
+  let jobs = [];
+  try {
+    jobs = fs.readdirSync(base, { withFileTypes: true })
+      .filter((d) => d.isDirectory()).map((d) => d.name).sort();
+  } catch { return []; }
+  return jobs.map((job) => {
+    const files = [];
+    const walk = (dir, rel) => {
+      if (files.length >= 200) return;
+      let entries = [];
+      try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
+      for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        if (SKIP_DIRS.has(e.name)) continue;
+        const abs = path.join(dir, e.name);
+        const r = rel ? `${rel}/${e.name}` : e.name;
+        if (e.isDirectory()) { walk(abs, r); continue; }
+        try {
+          const st = fs.statSync(abs);
+          files.push({ path: r, size: st.size, modified: st.mtimeMs / 1000 });
+        } catch { /* vanished mid-walk */ }
+        if (files.length >= 200) return;
+      }
+    };
+    walk(path.join(base, job), '');
+    return { job, files };
+  });
+}
+
+/**
+ * One file's text, or a reason it cannot be shown.
+ *
+ * The path is resolved and then checked to still be INSIDE the job's folder,
+ * which is what stops `../../.ssh/id_rsa` — a request arriving over the network
+ * must not reach a file the user never put in the workspace.
+ */
+export function readJobFile(job, rel, root) {
+  const base = path.resolve(path.join(workspaceRoot(root), SCRIPTS_DIR, safeSlug(job)));
+  const target = path.resolve(path.join(base, rel));
+  if (target !== base && !target.startsWith(base + path.sep)) {
+    return { ok: false, error: "That file is outside this job's folder." };
+  }
+  try {
+    if (fs.statSync(target).size > MAX_VIEW_BYTES) {
+      return { ok: false, error: 'That file is too large to show here.' };
+    }
+    return { ok: true, text: fs.readFileSync(target, 'utf8') };
+  } catch {
+    return { ok: false, error: 'That file could not be read.' };
+  }
+}

package/src/util/help.js

@@ -33,6 +33,7 @@ export function printRootHelp() {
   println('  flow stream --symbol NVDA [--side call]            Live options-flow feed (SSE)');
   println('  remote-control [--dir DIR]                          Let Atlas run this computer\'s jobs');
   println('  update-cli                                        Install the newest Atlas CLI');
+  println('  remote-check                                      Test the whole loop, hop by hop');
   println('         [--min-premium N] [--min-tag unusual] [--json]');
   println();
   println(c.bold('GLOBAL'));