mindvest-atlas 0.6.2 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindvest-atlas",
-  "version": "0.6.2",
+  "version": "0.7.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,8 +15,9 @@ import { requestJson } from '../api/client.js';
 import { runStream } from '../util/stream-loop.js';
 import { color, eprintln } from '../util/ui.js';
 import {
-  DEFAULT_TIMEOUT_MS, claimRun, computerName, jobEnv, listJobFiles, listRuns, machineId,
+  DEFAULT_TIMEOUT_MS, claimRun, computerName, isPaused, jobEnv, listJobFiles, listRuns, machineId,
   osLabel, readJobFile, releaseRun, staleness, summarize, tail, workspace, workspaceRoot,
+  setPaused, writeHelpers,
 } from '../remote-control.js';
 import fs from 'node:fs';
 import path from 'node:path';
@@ -97,6 +98,10 @@ 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 === 'pause') {
+    const { dir } = workspace(ask.job || '', root);
+    return answer(ask.request_id, { ok: true, paused: setPaused(dir, Boolean(ask.paused)) });
+  }
   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.' });
@@ -113,6 +118,13 @@ async function runJob(job, root, timeoutMs) {
   }
 
   const { dir, entry, argv } = workspace(job.automation_id, root);
+  // Paused is the owner saying "not now". A scheduled run that fires anyway
+  // would make the switch meaningless; a MANUAL run is the owner asking
+  // directly, so it goes through.
+  if (isPaused(dir) && job.source !== 'manual') {
+    eprintln(color.dim(`· ${name} — paused`));
+    return undefined;
+  }
   if (!fs.existsSync(entry)) {
     // NOT a failure. The schedule fired and this computer took the job; there
     // was simply nothing to carry out yet. Its owner never sees the code, so
@@ -128,6 +140,10 @@ async function runJob(job, root, timeoutMs) {
     return undefined;
   }
 
+  // Refreshed every run, so a job always has the supported way to reach a
+  // secret and never a reason to open .env itself.
+  writeHelpers(dir);
+
   eprintln(color.dim(`▶ ${name}`));
   const env = {
     ...process.env,

package/src/config.js

@@ -2,7 +2,7 @@
 import path from 'node:path';
 import os from 'node:os';
 
-export const VERSION = '0.6.2';
+export const VERSION = '0.7.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

@@ -168,6 +168,70 @@ export function readEnvFile(file) {
  * Shared first so a key is typed once; the job's own last so a job that wants
  * its own value gets it. Neither is required.
  */
+/**
+ * Written into every job folder before it runs, in both languages.
+ *
+ * The job imports this instead of opening .env — so the script the model writes
+ * has no reason to touch the file, and a model debugging that script has nothing
+ * to learn by trying. Regenerated on every run, so editing or deleting it
+ * changes nothing.
+ */
+export function writeHelpers(dir) {
+  const py = `"""Secrets for this job. Written by Atlas — edits are overwritten.
+
+Values come from the environment Atlas set up before starting this script. Do
+NOT open .env: this module is the supported way to reach a secret, and the file
+itself is not something a script or a model needs to read.
+"""
+import os
+import sys
+
+
+def secret(name, default=None):
+    """The value of one secret, for USE — never for printing or logging."""
+    return os.environ.get(name, default)
+
+
+def has_secret(name):
+    """Whether a secret has been filled in. True/False only, never the value."""
+    return bool(os.environ.get(name))
+
+
+def require(*names):
+    """Stop cleanly when a secret has not been filled in yet."""
+    missing = [n for n in names if not os.environ.get(n)]
+    if missing:
+        print("Missing: %s. Add the value in Atlas Remote Control, then run again."
+              % ", ".join(missing))
+        sys.exit(2)
+`;
+  const js = `// Secrets for this job. Written by Atlas — edits are overwritten.
+//
+// Values come from the environment Atlas set up before starting this script. Do
+// NOT open .env: this module is the supported way to reach a secret, and the
+// file itself is not something a script or a model needs to read.
+
+/** The value of one secret, for USE — never for printing or logging. */
+export const secret = (name, fallback) => process.env[name] ?? fallback;
+
+/** Whether a secret has been filled in. True/false only, never the value. */
+export const hasSecret = (name) => Boolean(process.env[name]);
+
+/** Stop cleanly when a secret has not been filled in yet. */
+export function require_(...names) {
+  const missing = names.filter((n) => !process.env[n]);
+  if (missing.length) {
+    console.log(\`Missing: \${missing.join(", ")}. Add the value in Atlas Remote Control, then run again.\`);
+    process.exit(2);
+  }
+}
+`;
+  try {
+    fs.writeFileSync(path.join(dir, 'atlas_env.py'), py);
+    fs.writeFileSync(path.join(dir, 'atlas_env.js'), js);
+  } catch { /* a helper is a courtesy, never a failure */ }
+}
+
 export function jobEnv(dir, root) {
   return { ...readEnvFile(path.join(workspaceRoot(root), '.env')), ...readEnvFile(path.join(dir, '.env')) };
 }
@@ -267,7 +331,7 @@ export function listJobFiles(root) {
       }
     };
     walk(path.join(base, job), '');
-    return { job, files };
+    return { job, files, paused: isPaused(path.join(base, job)) };
   });
 }
 
@@ -308,6 +372,31 @@ export function readJobFile(job, rel, root) {
  * long), which is why the writer stamps both.
  */
 export const RUNNING_MARKER = '.running';
+/**
+ * Marks a project the owner has switched off.
+ *
+ * Local, like everything else about a project: pausing is a fact about this
+ * computer's copy, and a file is the only form of it that survives the runner
+ * restarting and is visible in the folder to anyone wondering why nothing has
+ * happened.
+ */
+export const PAUSED_MARKER = '.paused';
+
+export const isPaused = (dir) => fs.existsSync(path.join(dir, PAUSED_MARKER));
+
+/** Switch one project off or back on. Returns the state it ended in. */
+export function setPaused(dir, paused) {
+  const m = path.join(dir, PAUSED_MARKER);
+  try {
+    if (paused) {
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(m, `${Date.now() / 1000}\n`);
+    } else {
+      fs.rmSync(m, { force: true });
+    }
+  } catch { /* best-effort */ }
+  return isPaused(dir);
+}
 
 export const runningMarker = (dir) => path.join(dir, 'runs', RUNNING_MARKER);