@nosana/node 1.1.67-rc → 1.1.68

package/README.md

@@ -83,6 +83,16 @@ Options:
   -h, --help                display help for command
 ```
 
+### Shutting down after the current job
+
+Jobs can follow each other back to back, which leaves no clean moment to take
+the machine down. While a job is running, press `s` in the node's terminal to
+toggle between the auto market loop (default) and shutting the node down once
+that job finishes. The running-job status line shows what pressing the key does
+next: `[s] shutdown after job`, or `[s] cancel shutdown after job` once armed.
+The key is ignored outside a job (setup, benchmarks, queueing) and needs an
+interactive terminal (for example `docker run -it`).
+
 ## Documentation
 
 Please [visit our documentation](https://learn.nosana.com/) for a full list of commands and examples.

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@nosana/node",
-    "version": "1.1.67-rc",
+    "version": "1.1.68",
     "description": "",
     "bin": {
         "nosana-node": "./dist/src/index.js"

package/dist/src/NodeManager/index.d.ts

@@ -5,6 +5,7 @@ export default class NodeManager {
     private apiStarted;
     private signalled;
     private configLocation;
+    private operatorInput;
     /**
      * Seeded from the environment so the loop survives the process being
      * replaced by an update.
@@ -26,6 +27,15 @@ export default class NodeManager {
     /** Asked to stop, which is not a failure to restart on. */
     isStopping(): boolean;
     error(): Promise<void>;
+    /** Stop the node for good and leave the process. */
+    private shutdown;
+    /**
+     * Operator keys. `s` toggles shutting down after the current job, and only
+     * counts while a real job executes (the running-job line is on screen);
+     * setup, benchmarks, queueing and the result upload ignore it. Listening
+     * starts per job cycle in `start()`, see there.
+     */
+    private handleOperatorInput;
     /**
      * Set up handling for process exit signals
      */

package/dist/src/NodeManager/index.js

@@ -13,11 +13,13 @@ import { checkWSLStatus } from './utils/wslCheck.js';
 import { IN_JOB_LOOP_ENV } from '../exitCodes.js';
 import { reportError } from './monitoring/reportError.js';
 import { reportPodmanDiagnostics } from './monitoring/reportPodmanDiagnostics.js';
+import { OperatorInput } from './input/OperatorInput.js';
 export default class NodeManager {
     constructor(options) {
         this.exiting = false;
         this.apiStarted = false;
         this.signalled = false;
+        this.operatorInput = new OperatorInput();
         /**
          * Seeded from the environment so the loop survives the process being
          * replaced by an update.
@@ -32,6 +34,7 @@ export default class NodeManager {
         this.apiHandler = this.node.api();
         this.apiHandler.nodeManager = this;
         this.handleProcessExit();
+        this.handleOperatorInput();
     }
     async init() {
         /**
@@ -173,7 +176,21 @@ export default class NodeManager {
          *
          * NT: run() is the primary job execution path. monitorMarket() is a background safeguard.
          */
+        /**
+         * Listen for operator keys only for this job cycle. Any interactive
+         * prompt (registration, the health check question) has run by now and
+         * released stdin; a prompt resets raw mode and pauses stdin, which would
+         * silently end a listener armed earlier.
+         */
+        this.operatorInput.start();
         await Promise.race([this.node.monitorMarket(), this.node.run()]);
+        /**
+         * The operator asked (with the `s` key) for a clean stop once this job
+         * was done, rather than another cycle.
+         */
+        if (this.node.shouldShutdownAfterJob()) {
+            await this.shutdown();
+        }
         /**
          * start
          *
@@ -211,6 +228,7 @@ export default class NodeManager {
      */
     async clean() {
         this.exiting = true;
+        this.operatorInput.stop();
         /**
          * check if the node exists then clean the processes.
          */
@@ -258,20 +276,36 @@ export default class NodeManager {
         this.exiting = true;
         this.node.exit();
     }
+    /** Stop the node for good and leave the process. */
+    async shutdown() {
+        LogMonitoringRegistry.getInstance().setLoggable(true);
+        this.signalled = true;
+        if (this.exiting)
+            return;
+        this.exiting = true;
+        this.operatorInput.stop();
+        this.node.exit();
+        await this.stop();
+        process.exit();
+    }
+    /**
+     * Operator keys. `s` toggles shutting down after the current job, and only
+     * counts while a real job executes (the running-job line is on screen);
+     * setup, benchmarks, queueing and the result upload ignore it. Listening
+     * starts per job cycle in `start()`, see there.
+     */
+    handleOperatorInput() {
+        this.operatorInput.on('key', (key) => {
+            if (key === 's' && this.node.isRunningJob()) {
+                this.node.toggleShutdownAfterJob();
+            }
+        });
+    }
     /**
      * Set up handling for process exit signals
      */
     handleProcessExit() {
-        const exitHandler = async () => {
-            LogMonitoringRegistry.getInstance().setLoggable(true);
-            this.signalled = true;
-            if (this.exiting)
-                return;
-            this.exiting = true;
-            this.node.exit();
-            await this.stop();
-            process.exit();
-        };
+        const exitHandler = () => this.shutdown();
         process.on("SIGINT", exitHandler); // Handle Ctrl+C
         process.on("SIGTERM", exitHandler); // Handle termination signals
         // log crashes

package/dist/src/NodeManager/input/OperatorInput.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+/**
+ * Owns the terminal's stdin for the node's lifetime and hands single key
+ * presses to whoever listens, so nothing else in the node has to touch stdin
+ * (the spinners pass `discardStdin: false` for that reason).
+ *
+ * Stdin is held in raw mode so keys arrive one at a time and are not echoed.
+ * Raw mode disables the terminal's own Ctrl+C, so it is turned back into
+ * SIGINT here. Without a TTY there is no operator at a keyboard, and nothing
+ * is set up.
+ */
+export declare class OperatorInput extends EventEmitter {
+    private readonly stdin;
+    private listening;
+    constructor(stdin?: NodeJS.ReadStream);
+    start(): void;
+    /** Hands the terminal back in its normal mode. */
+    stop(): void;
+    private onData;
+}

package/dist/src/NodeManager/input/OperatorInput.js

@@ -0,0 +1,43 @@
+import { EventEmitter } from 'events';
+const CTRL_C = 0x03;
+/**
+ * Owns the terminal's stdin for the node's lifetime and hands single key
+ * presses to whoever listens, so nothing else in the node has to touch stdin
+ * (the spinners pass `discardStdin: false` for that reason).
+ *
+ * Stdin is held in raw mode so keys arrive one at a time and are not echoed.
+ * Raw mode disables the terminal's own Ctrl+C, so it is turned back into
+ * SIGINT here. Without a TTY there is no operator at a keyboard, and nothing
+ * is set up.
+ */
+export class OperatorInput extends EventEmitter {
+    constructor(stdin = process.stdin) {
+        super();
+        this.stdin = stdin;
+        this.listening = false;
+        this.onData = (chunk) => {
+            if (chunk[0] === CTRL_C) {
+                process.emit('SIGINT');
+                return;
+            }
+            this.emit('key', chunk.toString());
+        };
+    }
+    start() {
+        if (this.listening || !this.stdin.isTTY)
+            return;
+        this.listening = true;
+        this.stdin.setRawMode(true);
+        this.stdin.on('data', this.onData);
+        this.stdin.resume();
+    }
+    /** Hands the terminal back in its normal mode. */
+    stop() {
+        if (!this.listening)
+            return;
+        this.listening = false;
+        this.stdin.off('data', this.onData);
+        this.stdin.pause();
+        this.stdin.setRawMode(false);
+    }
+}

package/dist/src/NodeManager/monitoring/log/NodeLog.js

@@ -132,6 +132,18 @@ class NodeLog {
         if (data.class === 'BasicNode' && data.method === 'exit') {
             this.handleExit(data);
         }
+        if (data.class === 'BasicNode' &&
+            data.method === 'toggleShutdownAfterJob' &&
+            data.type === 'return') {
+            this.addLog({
+                method: `${data.class}.${data.method}`,
+                job: this.job,
+                log: '',
+                timestamp: Date.now(),
+                type: 'update',
+                payload: { enabled: data.result },
+            });
+        }
         if (data.class === 'BasicNode' &&
             (data.method === 'restartDelay' || data.method === 'delay')) {
             this.handleRestart(data);

package/dist/src/NodeManager/monitoring/log/console/ConsoleLogger.d.ts

@@ -15,6 +15,8 @@ export declare class ConsoleLogger implements LogObserver {
     private taskManagerStartMethod;
     private benchmarkProgress;
     private running;
+    private shutdownAfterJob;
+    private renderTaskManagerBar;
     private expiry;
     private taskManagerRunInterval;
     spinner: Ora;

package/dist/src/NodeManager/monitoring/log/console/ConsoleLogger.js

@@ -25,6 +25,7 @@ export class ConsoleLogger {
         this.taskManagerStartMethod = 'TaskManager.start';
         this.benchmarkProgress = { completed: 0, total: 0 };
         this.running = false;
+        this.shutdownAfterJob = false;
     }
     addObserver() {
         log().addObserver(this);
@@ -34,6 +35,15 @@ export class ConsoleLogger {
     }
     update(log, isNode = true) {
         const renderBase = `${chalk.bgGreenBright.black.bold(this.taskManagerLabel)} ${chalk.reset('')}`;
+        // Handled first so a toggle is never swallowed by the job's quiet window.
+        // The running-job line carries the command plate, so a flip re-renders it.
+        if (log.method === 'BasicNode.toggleShutdownAfterJob') {
+            this.shutdownAfterJob = !!log.payload?.enabled;
+            if (this.taskManagerActive && this.renderTaskManagerBar) {
+                this.spinner.text = this.renderTaskManagerBar();
+            }
+            return;
+        }
         if (!this.kill && log.type == 'kill-process') {
             if (this.pending) {
                 this.spinner.stop();
@@ -50,7 +60,7 @@ export class ConsoleLogger {
             if (isNode && this.taskManagerActive) {
                 this.spinner.succeed(renderBase + ' Exited');
             }
-            this.spinner = ora(log.log).start();
+            this.spinner = ora({ text: log.log, discardStdin: false }).start();
         }
         if (this.kill) {
             if (log.type == 'kill-success') {
@@ -96,14 +106,18 @@ export class ConsoleLogger {
                 const isBenchmark = log.method === 'BenchmarkTaskManager.start';
                 if (isBenchmark)
                     this.benchmarkProgress = { completed: 0, total: 0 };
+                // Command plate: what pressing the key does next, which also reads as the mode.
+                const modePlate = () => this.shutdownAfterJob
+                    ? `${chalk.red('[s]')} ${chalk.red.bold('cancel')} ${chalk.red('shutdown after job')}`
+                    : chalk.dim('[s] shutdown after job');
                 const renderBar = (duration = 0) => isBenchmark
                     ? `${activeRenderBase} ${chalk.bgYellow.black.bold(`  Ops: ${this.benchmarkProgress.completed}/${this.benchmarkProgress.total}  `)} ${chalk.reset('')}`
-                    : `${activeRenderBase} ${chalk.bgYellow.black.bold(`  ⏱ Duration: ${formatTime(duration)}  `)} ${chalk.reset('')} ${chalk.bgBlue.black.bold(`  ⚡ Max Duration: ${formatTime(this.expiry ?? 0)}  `)}`;
-                this.spinner = ora(renderBar(0)).start();
+                    : `${activeRenderBase} ${chalk.bgYellow.black.bold(`  ⏱ Duration: ${formatTime(duration)}  `)} ${chalk.reset('')} ${chalk.bgBlue.black.bold(`  ⚡ Max Duration: ${formatTime(this.expiry ?? 0)}  `)} ${modePlate()}`;
+                this.renderTaskManagerBar = () => renderBar((Date.now() - startTime) / 1000);
+                this.spinner = ora({ text: renderBar(0), discardStdin: false }).start();
                 this.taskManagerRunInterval = setInterval(() => {
                     if (this.taskManagerActive) {
-                        const duration = (Date.now() - startTime) / 1000;
-                        this.spinner.text = renderBar(duration);
+                        this.spinner.text = this.renderTaskManagerBar();
                     }
                     else {
                         clearInterval(this.taskManagerRunInterval);
@@ -141,7 +155,10 @@ export class ConsoleLogger {
             log.type == 'process') {
             this.benchmarking = true;
             this.pending = true;
-            this.spinner = ora(chalk.green(`${chalk.bgGreen.bold(' Checking Specs ')}`)).start();
+            this.spinner = ora({
+                text: chalk.green(`${chalk.bgGreen.bold(' Checking Specs ')}`),
+                discardStdin: false,
+            }).start();
             return;
         }
         if (this.benchmarking) {
@@ -317,7 +334,7 @@ export class ConsoleLogger {
             if (log.pending?.isPending) {
                 this.pending = true;
                 this.expecting = log.pending?.expecting;
-                this.spinner = ora(log.log).start();
+                this.spinner = ora({ text: log.log, discardStdin: false }).start();
             }
             else {
                 console.log(log.log);

package/dist/src/NodeManager/node/Node.d.ts

@@ -16,6 +16,9 @@ export declare class BasicNode {
     private provider;
     private containerOrchestration;
     private exiting;
+    private shutdownAfterJob;
+    /** Set by `run()` while a real job executes; the benchmark never sets it. */
+    private jobRunning;
     private sdk;
     constructor(options: {
         [key: string]: any;
@@ -37,6 +40,13 @@ export declare class BasicNode {
     monitorMarket(): Promise<unknown>;
     maintenance(): Promise<void>;
     exit(): void;
+    /**
+     * Flip whether the node leaves the market loop once the current job
+     * finishes, instead of re-queueing for the next one.
+     */
+    toggleShutdownAfterJob(): boolean;
+    shouldShutdownAfterJob(): boolean;
+    isRunningJob(): boolean;
     conclude(): Promise<void>;
     restartDelay(time: number): Promise<void>;
 }

package/dist/src/NodeManager/node/Node.js

@@ -24,6 +24,9 @@ import { StopReasons } from './task/TaskManager.js';
 export class BasicNode {
     constructor(options) {
         this.exiting = false;
+        this.shutdownAfterJob = false;
+        /** Set by `run()` while a real job executes; the benchmark never sets it. */
+        this.jobRunning = false;
         this.sdk = getSDK();
         const db = new DB(options.config).db;
         this.repository = new NodeRepository(db);
@@ -189,6 +192,7 @@ export class BasicNode {
                      */
                     const shouldStart = await this.jobHandler.start(job);
                     if (shouldStart) {
+                        this.jobRunning = true;
                         /**
                          * Run the flow asynchronously and handle errors via a Promise.
                          * This lets us run the job in the background (async) and still get an error in this main process.
@@ -199,6 +203,7 @@ export class BasicNode {
                          */
                         // await this.expiryHandler.waitUntilExpired();
                         resolvedStatus = await stopReason;
+                        this.jobRunning = false;
                     }
                 }
                 if (!this.exiting) {
@@ -212,6 +217,7 @@ export class BasicNode {
                 }
             }
             catch (error) {
+                this.jobRunning = false;
                 // Reject the Promise if any errors occur
                 reject(error);
             }
@@ -287,6 +293,20 @@ export class BasicNode {
     exit() {
         this.exiting = true;
     }
+    /**
+     * Flip whether the node leaves the market loop once the current job
+     * finishes, instead of re-queueing for the next one.
+     */
+    toggleShutdownAfterJob() {
+        this.shutdownAfterJob = !this.shutdownAfterJob;
+        return this.shutdownAfterJob;
+    }
+    shouldShutdownAfterJob() {
+        return this.shutdownAfterJob;
+    }
+    isRunningJob() {
+        return this.jobRunning;
+    }
     async conclude() {
         const run = this.runHandler.getRun();
         if (run) {

package/dist/src/NodeManager/node/balance/balanceHandler.js

@@ -41,7 +41,10 @@ export class BalanceHandler {
             if (!wait) {
                 throw new Error(insufficentSolMessage);
             }
-            const spinner = ora(chalk.yellow(insufficentSolMessage)).start();
+            const spinner = ora({
+                text: chalk.yellow(insufficentSolMessage),
+                discardStdin: false,
+            }).start();
             await this.waitForSufficentSol();
             spinner.succeed();
         }

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@nosana/node",
-  "version": "1.1.67-rc",
+  "version": "1.1.68",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@nosana/node",
-      "version": "1.1.67-rc",
+      "version": "1.1.68",
       "license": "ISC",
       "dependencies": {
         "@coral-xyz/anchor": "^0.28.1-beta.1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nosana/node",
-  "version": "1.1.67-rc",
+  "version": "1.1.68",
   "description": "",
   "bin": {
     "nosana-node": "./dist/src/index.js"