mindvest-atlas 0.8.0 → 0.9.0

package/package.json

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

@@ -17,9 +17,10 @@ import { color, eprintln } from '../util/ui.js';
 import {
   DEFAULT_TIMEOUT_MS, claimRun, computerName, isPaused, jobEnv, listJobFiles, listRuns, machineId,
   osLabel, readJobFile, releaseRun, staleness, summarize, tail, workspace, workspaceRoot,
-  setPaused, writeHelpers,
+  setPaused, writeHelpers, askModel, listModels,
 } 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');
@@ -104,18 +105,39 @@ async function handleAsk(ask, 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));
+  if (ask.op === 'models') {
+    void listModels().then((m) => answer(ask.request_id, { ok: true, ...m }));
+    return undefined;
+  }
+  if (ask.op === 'build') {
+    // THE POINT OF ALL OF THIS. Words in, working script out: the owner says
+    // what they want in one sentence and their own model writes it, runs it,
+    // and fixes it here. No terminal, no questions asked back, no code shown
+    // unless they go looking. Deliberately NOT awaited — the model writes AND
+    // runs, which takes minutes, and the stream must keep serving everyone else.
+    void askModel(ask.prompt || '', { job: ask.job || '' })
+      .then((a) => answer(ask.request_id, { ok: true, answer: a }))
+      .catch((err) => answer(ask.request_id, { ok: false, error: String(err.message || err) }));
+    return undefined;
+  }
   return answer(ask.request_id, { ok: false, error: 'Unknown request.' });
 }
 
 /**
  * How many projects may run at once.
  *
- * Different projects are genuinely independent — own folder, own .env, own
- * single run — so serialising them would make a five-minute job delay a
- * five-second one for no reason. Capped so a burst of due schedules cannot
- * fork-bomb a laptop.
+ * 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 = 4;
+const MAX_PARALLEL = Math.max(4, Math.min(16, os.cpus().length || 4));
 let active = 0;
 const waiting = [];
 
@@ -196,6 +218,9 @@ async function runJob(job, root, timeoutMs) {
     ATLAS_TOKEN: await jobToken(),
     ...(job.env && typeof job.env === 'object'
       ? Object.fromEntries(Object.entries(job.env).map(([k, v]) => [String(k), String(v)])) : {}),
+    // Which job is asking. The ask bridge keys the model's session on this, so
+    // one job's questions stay one conversation and do not blend into another's.
+    ATLAS_JOB: path.basename(dir),
     ATLAS_JOB_PAYLOAD: JSON.stringify(job.payload || {}),
   };
   const r = await runOnce(argv, dir, env, timeoutMs);

package/src/config.js

@@ -2,7 +2,7 @@
 import path from 'node:path';
 import os from 'node:os';
 
-export const VERSION = '0.8.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
@@ -481,3 +488,56 @@ export function listRuns(root, limit = 50) {
   runs.sort((a, b) => b.started_at - a.started_at);
   return runs.slice(0, limit);
 }
+
+/**
+ * Hand a plain-English instruction to the model on THIS computer.
+ *
+ * This is how "watch SPY and buy the dip" becomes a working script without
+ * anyone opening a terminal: the words go straight to the owner's own model
+ * over ACP, which writes the script into the job's folder, runs it, reads its
+ * own errors and fixes them until it works.
+ *
+ * Returns the model's account of what it did. Throws if no model is connected.
+ */
+export async function askModel(prompt, { job = '', tools = true, fresh = false, timeoutMs = 900000 } = {}) {
+  const url = process.env.ATLAS_ASK_URL;
+  const token = process.env.ATLAS_ASK_TOKEN;
+  if (!url || !token) {
+    throw new Error(
+      'No model is connected on this computer. Open Atlas Remote Control, '
+      + 'connect a model, and turn Local Mode on.'
+    );
+  }
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'X-Atlas-Token': token },
+    body: JSON.stringify({ job, prompt: String(prompt), tools, fresh }),
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+  const out = await res.json().catch(() => ({}));
+  if (!res.ok || !out.ok) throw new Error(out.error || `The model could not answer (${res.status}).`);
+  return out.answer || '';
+}
+
+/**
+ * Every model this computer can build with, and which one it uses by default.
+ *
+ * Names only. Returns an empty catalog rather than throwing when no model is
+ * connected, because "none yet" is a state the UI shows, not an error.
+ */
+export async function listModels(timeoutMs = 15000) {
+  const url = process.env.ATLAS_ASK_URL;
+  const token = process.env.ATLAS_ASK_TOKEN;
+  const empty = { models: [], default: null, agent: null };
+  if (!url || !token) return empty;
+  try {
+    const res = await fetch(url.replace('/ask', '/models'), {
+      headers: { 'X-Atlas-Token': token },
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!res.ok) return empty;
+    return await res.json();
+  } catch {
+    return empty;
+  }
+}