mindvest-atlas 0.5.0 → 0.6.0

package/package.json

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

@@ -15,7 +15,7 @@ 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, listJobFiles, machineId, osLabel,
+  DEFAULT_TIMEOUT_MS, computerName, jobEnv, listJobFiles, listRuns, machineId, osLabel,
   readJobFile, staleness, summarize, tail, workspace, workspaceRoot,
 } from '../remote-control.js';
 import fs from 'node:fs';
@@ -53,30 +53,15 @@ function writeLog(dir, job, status, started, finished, text) {
 }
 
 /**
- * POST that a run happened. METADATA ONLY — never what the script printed.
+ * Deliberately does nothing.
  *
- * Best-effort: a failed report must not take down the runner, and the next job
- * still deserves to run.
+ * A run is recorded in the log beside the script that produced it, on the
+ * computer that ran it, and nowhere else. This is kept as the single place every
+ * outcome funnels through, so "where does a run go" has one answer rather than
+ * five call sites each deciding.
  */
-async function report(job, status, started, finished) {
-  try {
-    await requestJson(API.localRuns, {
-      method: 'POST',
-      body: {
-        automation_id: job.automation_id || job.id,
-        name: job.name || '',
-        source: job.source || 'schedule',
-        status,
-        started_at: iso(started),
-        finished_at: iso(finished),
-        // One account can run jobs on several computers; the results view says
-        // which one produced each record.
-        machine: computerName(),
-      },
-    });
-  } catch (err) {
-    eprintln(color.dim(`  ↳ could not report the run: ${err.message}`));
-  }
+async function report() {
+  return undefined;
 }
 
 function runOnce(argv, dir, env, timeoutMs) {
@@ -112,6 +97,7 @@ async function answer(requestId, payload) {
 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 === 'runs') return answer(ask.request_id, { ok: true, runs: listRuns(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.' });
 }

package/src/config.js

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

package/src/remote-control.js

@@ -283,3 +283,47 @@ export function readJobFile(job, rel, root) {
     return { ok: false, error: 'That file could not be read.' };
   }
 }
+
+/**
+ * Recent runs, read from the logs this computer wrote.
+ *
+ * The machine that ran them is the only place they exist — nothing is reported
+ * to a server — so this is the source of truth, not a cache of one. Parsed from
+ * the filename (when, and how it ended) and the log's own second line (how
+ * long), which is why the writer stamps both.
+ */
+export function listRuns(root, limit = 50) {
+  const base = path.join(workspaceRoot(root), SCRIPTS_DIR);
+  const runs = [];
+  let jobs = [];
+  try {
+    jobs = fs.readdirSync(base, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch { return runs; }
+  for (const job of jobs) {
+    let files = [];
+    try {
+      files = fs.readdirSync(path.join(base, job, 'runs')).filter((f) => f.endsWith('.log')).sort().reverse();
+    } catch { continue; }
+    for (const f of files.slice(0, limit)) {
+      const stem = f.replace(/\.log$/, '');
+      const parts = stem.split('-');
+      if (parts.length < 3) continue;
+      const status = parts.slice(2).join('-');
+      const [d, t] = parts;
+      const started = Date.parse(
+        `${d.slice(0, 4)}-${d.slice(4, 6)}-${d.slice(6, 8)}T${t.slice(0, 2)}:${t.slice(2, 4)}:${t.slice(4, 6)}`,
+      ) / 1000;
+      let name = job;
+      let took = null;
+      try {
+        const [first, second] = fs.readFileSync(path.join(base, job, 'runs', f), 'utf8').split('\n');
+        const bits = (first || '').split('  ');
+        if (bits.length >= 3) name = bits[2];
+        if ((second || '').startsWith('took ')) took = parseFloat(second.slice(5));
+      } catch { /* unreadable: the filename still tells the story */ }
+      runs.push({ job, name, status, started_at: Number.isFinite(started) ? started : 0, duration_s: took, log: f });
+    }
+  }
+  runs.sort((a, b) => b.started_at - a.started_at);
+  return runs.slice(0, limit);
+}