mindvest-atlas 0.7.0 → 0.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindvest-atlas",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "description": "Atlas CLI \u2014 OAuth login, tool calls, and live alert/flow streaming for the Atlas trading API",
   "type": "module",
   "bin": {

package/src/api/client.js

@@ -41,6 +41,13 @@ async function refreshAndStore(creds) {
   return updated;
 }
 
+/** The bearer a job uses to call the Atlas API directly. Exported so the runner
+ *  can put it in a child's environment; empty when not signed in, because a
+ *  missing token is a script's problem to report, not the runner's to crash on. */
+export async function jobToken() {
+  try { return await currentAccessToken(); } catch { return ''; }
+}
+
 async function currentAccessToken() {
   const env = envToken();
   if (env) return env;

package/src/commands/remote-control.js

@@ -10,8 +10,8 @@
 // a schedule that quietly broke, which is the failure the record exists to make
 // visible.
 import { spawn } from 'node:child_process';
-import { API } from '../config.js';
-import { requestJson } from '../api/client.js';
+import { API, baseUrl } from '../config.js';
+import { requestJson, jobToken } from '../api/client.js';
 import { runStream } from '../util/stream-loop.js';
 import { color, eprintln } from '../util/ui.js';
 import {
@@ -20,6 +20,7 @@ import {
   setPaused, writeHelpers,
 } from '../remote-control.js';
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 
 const iso = (ms) => new Date(ms).toISOString().replace(/\.\d+Z$/, 'Z');
@@ -107,6 +108,50 @@ async function handleAsk(ask, root) {
   return answer(ask.request_id, { ok: false, error: 'Unknown request.' });
 }
 
+/**
+ * How many projects may run at once.
+ *
+ * Scaled to the machine rather than fixed at a timid number: these are mostly
+ * IO-bound jobs waiting on an API, so a modern laptop can carry far more than
+ * four, and holding a job back on an idle machine helps nobody. The floor of 4
+ * covers a single-core VM; the ceiling of 16 leaves the computer usable for the
+ * person sitting at it, which is the actual constraint — this is their machine,
+ * not a build server.
+ *
+ * This bounds RUNS, not threads. A single run is free to use every core it can
+ * (see the build prompt): one run per project is about not racing two copies of
+ * the same script over one folder, never about how hard that script may work.
+ */
+const MAX_PARALLEL = Math.max(4, Math.min(16, os.cpus().length || 4));
+let active = 0;
+const waiting = [];
+
+/**
+ * Run a job WITHOUT blocking the stream.
+ *
+ * Awaiting it inline was a real bug: a ten-minute script held the SSE loop, so
+ * no other job started, the keepalive stopped, and the web's questions about
+ * this computer went unanswered until it finished. The loop's job is to listen;
+ * the work belongs beside it.
+ *
+ * One run per PROJECT is still enforced by the marker inside runJob, so this
+ * parallelism is across projects only.
+ */
+function spawnJob(job, root, timeoutMs) {
+  const start = () => {
+    active += 1;
+    void runJob(job, root, timeoutMs)
+      .catch((err) => eprintln(color.red(`✗ ${err.message}`)))
+      .finally(() => {
+        active -= 1;
+        const next = waiting.shift();
+        if (next) next();
+      });
+  };
+  if (active < MAX_PARALLEL) start();
+  else waiting.push(start);
+}
+
 async function runJob(job, root, timeoutMs) {
   const name = job.name || job.automation_id || 'job';
   const started = Date.now();
@@ -150,6 +195,12 @@ async function runJob(job, root, timeoutMs) {
     // Secrets first (shared .env, then the job's own), so a job's own env can
     // deliberately override a shared key.
     ...jobEnv(dir, root),
+    // The job's own credentials for the Atlas API, so a script calls it directly
+    // instead of shelling out to the CLI once per ticker. The token is the SAME
+    // one this runner is signed in with — the job acts as its owner, which is
+    // the only identity it could sensibly have.
+    ATLAS_BASE_URL: baseUrl(),
+    ATLAS_TOKEN: await jobToken(),
     ...(job.env && typeof job.env === 'object'
       ? Object.fromEntries(Object.entries(job.env).map(([k, v]) => [String(k), String(v)])) : {}),
     ATLAS_JOB_PAYLOAD: JSON.stringify(job.payload || {}),
@@ -205,12 +256,14 @@ export async function remoteControlCommand(args) {
       }
       const jobs = Array.isArray(pending) ? pending : (pending?.jobs || []);
       if (jobs.length) eprintln(color.dim(`● ${jobs.length} job(s) queued while away`));
-      for (const job of jobs) await runJob(job, root, timeoutMs);
+      for (const job of jobs) spawnJob(job, root, timeoutMs);
     },
     onEvent: async ({ event, payload }) => {
       if (event === 'job' || event === 'message' || event === 'run') {
-        await runJob(payload, root, timeoutMs);
+        spawnJob(payload, root, timeoutMs);
       } else if (event === 'ask') {
+        // Questions ARE awaited: they are fast, and answering them in order
+        // keeps a reply matched to the request that asked for it.
         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.7.0';
+export const VERSION = '0.8.1';
 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

@@ -28,8 +28,15 @@ export const DEFAULT_ROOT = '~/AtlasStudio';
  * so nothing has to be declared anywhere.
  */
 export const ENTRIES = ['main.py', 'main.js', 'main.mjs'];
-/** Hard ceiling on one job, so a hung script cannot hold the runner forever. */
-export const DEFAULT_TIMEOUT_MS = 600_000;
+/**
+ * Hard ceiling on one job, so a hung script cannot hold a slot forever.
+ *
+ * Half an hour, not ten minutes: real work — a chain walk, a wide scan, a model
+ * call in the middle — routinely runs past ten, and killing an honest job
+ * because the limit was set for a toy one is the worse failure. A script that is
+ * genuinely stuck is still stopped.
+ */
+export const DEFAULT_TIMEOUT_MS = 1_800_000;
 
 export function workspaceRoot(override) {
   const raw = override || process.env.ATLAS_LOCAL_DIR