mindvest-atlas 0.9.0 → 0.9.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindvest-atlas",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "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,7 +17,7 @@ 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, askModel, listModels,
+  setPaused, writeHelpers, askModel, listModels, chatModel,
 } from '../remote-control.js';
 import fs from 'node:fs';
 import os from 'node:os';
@@ -97,7 +97,14 @@ async function answer(requestId, payload) {
  *  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) {
+  // ADDRESSED TO ONE MACHINE. The ask channel is per-USER, so every computer
+  // this person owns hears every question. Fine for "list your files" — they
+  // each answer about themselves — but a BUILD must land on the machine they
+  // picked, not on whichever happens to reply first. An ask naming a computer
+  // is ignored by every other one; an ask naming none is for anybody.
   if (!ask?.request_id) return;
+  const want = String(ask.machine_id || '').trim();
+  if (want && want !== machineId()) return undefined;
   if (ask.op === 'list') return answer(ask.request_id, { ok: true, jobs: listJobFiles(root) });
   if (ask.op === 'pause') {
     const { dir } = workspace(ask.job || '', root);
@@ -105,6 +112,17 @@ 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 === 'chat') {
+    // A person typing at the web, talking to the model on this machine. Each
+    // event is answered SEPARATELY against the same request id, so the web sees
+    // the build as it happens; the server relays and stores none of it.
+    let seq = 0;
+    const send = (ev) => answer(ask.request_id, { ok: true, stream: true, seq: ++seq, ...ev });
+    void chatModel(ask.prompt || '', send, { job: ask.job || '', model: ask.model || '' })
+      .catch((err) => send({ kind: 'error', message: String(err?.message || err) }))
+      .finally(() => send({ kind: 'done' }));
+    return undefined;
+  }
   if (ask.op === 'models') {
     void listModels().then((m) => answer(ask.request_id, { ok: true, ...m }));
     return undefined;

package/src/remote-control.js

@@ -541,3 +541,54 @@ export async function listModels(timeoutMs = 15000) {
     return empty;
   }
 }
+
+/**
+ * Stream a chat turn from the model on THIS computer.
+ *
+ * Calls onEvent once per event as it arrives — text chunks, the tool it is
+ * running, an error — so the person watching on the web sees the build happen
+ * rather than staring at nothing for two minutes and assuming it hung.
+ */
+export async function chatModel(prompt, onEvent, { job = '', model = '', timeoutMs = 1800000 } = {}) {
+  const url = process.env.ATLAS_ASK_URL;
+  const token = process.env.ATLAS_ASK_TOKEN;
+  if (!url || !token) {
+    onEvent({ kind: 'error', message:
+      'No model is connected on this computer. Open Atlas Remote Control, '
+      + 'connect a model, and turn Local Mode on.' });
+    return;
+  }
+  try {
+    const res = await fetch(url.replace('/ask', '/chat'), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'X-Atlas-Token': token },
+      body: JSON.stringify({ job, prompt: String(prompt), model }),
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!res.ok || !res.body) {
+      onEvent({ kind: 'error', message: `The model could not answer (${res.status}).` });
+      return;
+    }
+    // Line-delimited JSON. A chunk can split a line in half, so hold the tail
+    // until a newline proves it complete — parsing early yields half an event.
+    const reader = res.body.getReader();
+    const dec = new TextDecoder();
+    let buf = '';
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buf += dec.decode(value, { stream: true });
+      const lines = buf.split('\n');
+      buf = lines.pop() ?? '';
+      for (const line of lines) {
+        const t = line.trim();
+        if (!t) continue;
+        try { onEvent(JSON.parse(t)); } catch { /* skip a malformed line */ }
+      }
+    }
+    const tail = buf.trim();
+    if (tail) { try { onEvent(JSON.parse(tail)); } catch { /* ignore */ } }
+  } catch (err) {
+    onEvent({ kind: 'error', message: String(err?.message || err) });
+  }
+}