brainchain-worker 0.3.0 → 0.3.1

package/README.md

@@ -81,8 +81,8 @@ Briefs are written by strangers, and some will try to get your agent to do somet
 ## Keep it running
 
 - **Stopping.** A `run` with no task in hand stops at once on Ctrl-C or SIGTERM. During a task, the first one stops `run` from taking new tasks and lets the current command finish and deliver; a second one stops the command at once. SIGHUP, which a closed terminal or a dropped SSH session sends, stops the command and `run` at once.
-- **Restarts.** `run` saves unfinished work to `~/.config/brainchain-worker/<address>.json`, readable only by you: a result waiting to be uploaded or submitted, a submit already sent, when each failed task is due again, and how far it has read the chain. A restart, or the next `--once` run, picks up from there without running the command again for a result it already has, and waits for a sent submit before sending another. A command left running by a `run` that was killed is stopped when the next one starts. If the file is damaged, `run` moves it aside and starts without saved work.
-- **One run per worker.** A second `run` for the same address refuses to start while the first is alive.
+- **Restarts.** `run` saves unfinished work to `~/.config/brainchain-worker/<address>.<network>.json`, readable only by you: a result waiting to be uploaded or submitted, a submit already sent, when each failed task is due again, and how far it has read the chain. A restart, or the next `--once` run, picks up from there without running the command again for a result it already has, and waits for a sent submit before sending another. A command left running by a `run` that was killed is stopped when the next one starts. If the file is damaged, `run` moves it aside and starts without saved work.
+- **One run per worker and network.** State is kept per network, where `<network>` is `testnet` or `mainnet`, so one key can run on both at the same time, and a second `run` for the same address on the same network refuses to start while the first is alive.
 - **Under a supervisor.** systemd sends SIGTERM to every process of a service by default, the command included, and every supervisor kills what is left after a timeout: 90 seconds for systemd, 10 for Docker and 30 for Kubernetes. For a stop that lets the current task deliver, signal the worker alone and allow the task timeout plus two minutes, 22 minutes with the default `--timeout`:
 
   | Supervisor | Settings |

package/dist/index.js

@@ -1,13 +1,12 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
-import { join as joinPath } from "node:path";
 import { formatEther, parseUnits } from "viem";
 import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
 import { createChain, faucetReopens, reason, unhealthy } from "./chain.js";
 import { claim, createIncome } from "./claim.js";
 import { resolveNetwork } from "./network.js";
 import { hireable, shortOfStake, snapshot, stake, usdg, wallet, when } from "./standing.js";
-import { fileStore, lock, stateDir } from "./state.js";
+import { openStore } from "./state.js";
 import { createWork, shellCommand, stopLeftover, stopper } from "./work.js";
 const { version } = createRequire(import.meta.url)("../package.json");
 const USAGE = `brainchain-worker ${version}
@@ -39,8 +38,8 @@ Environment:
                           localhost or 127.0.0.1.
 
 The command sees the worker's environment without any BRAINCHAIN_ variable, plus BRAINCHAIN_TASK_ID.
-Unfinished work is kept in ~/.config/brainchain-worker/<address>.json across restarts, and one
-run at a time works for each address.
+Unfinished work is kept in ~/.config/brainchain-worker/<address>.<network>.json across restarts,
+and one run at a time works for each address on each network.
 
 Docs: https://docs.usebrainchain.com/run-a-worker`;
 /** A mistake in the command line. Every other error is printed after the program's name. */
@@ -220,9 +219,7 @@ async function run(network, { key, account }, values, once) {
         throw new UsageError("--timeout is the most minutes the command may spend on one task: more than 0, at most 1440, and 20 by default");
     }
     const log = (message) => console.log(`${new Date().toISOString().slice(0, 19)}Z ${message}`);
-    const file = joinPath(stateDir(), account.address);
-    lock(`${file}.lock`);
-    const store = fileStore(`${file}.json`, network.contracts.taskBoard, (message) => log(`warning: ${message}`));
+    const store = openStore(account.address, network, (message) => log(`warning: ${message}`));
     // The lock rules out a live run, so a command still in the state was left by one that died.
     await stopLeftover(store, log);
     const chain = createChain(network, account, store);

package/dist/network.js

@@ -1,6 +1,7 @@
 import { defineChain, zeroAddress } from "viem";
 /** BrainChain testnet, release 3.1.0. */
 export const TESTNET = {
+    id: "testnet",
     name: "BrainChain testnet",
     chainId: 274630,
     rpc: "https://rpc.testnet.usebrainchain.com",
@@ -28,6 +29,7 @@ export const MAINNET_DECISION_EXECUTOR = "0xA03614B09Dcc3813eD665a1693123f2a4f2C
 const BRAIN = "0x3367085Eb6C79BfB0fCa4f1433ec77bFA8CB8a37";
 /** BrainChain mainnet, release 3.3.0. */
 export const MAINNET = {
+    id: "mainnet",
     name: "BrainChain",
     chainId: 274663,
     rpc: "https://rpc.usebrainchain.com",

package/dist/state.js

@@ -90,6 +90,8 @@ function alive(pid) {
         return error.code === "EPERM";
     }
 }
+const holder = (file) => (existsSync(file) ? Number(readFileSync(file, "utf8").trim()) : 0);
+const held = (pid, file) => new Error(`Another run (pid ${pid}) is already working for this worker. Stop it before starting another; ${file} holds its lock.`);
 /** Takes the lock in `file` for this process until it exits; refuses while a live process holds it. */
 export function lock(file) {
     mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
@@ -103,9 +105,9 @@ export function lock(file) {
                 throw error;
         }
         // The holder may have released it since the write failed; then the next try takes it.
-        const holder = existsSync(file) ? Number(readFileSync(file, "utf8").trim()) : 0;
-        if (alive(holder))
-            throw new Error(`Another run (pid ${holder}) is already working for this worker. Stop it before starting another; ${file} holds its lock.`);
+        const pid = holder(file);
+        if (alive(pid))
+            throw held(pid, file);
         rmSync(file, { force: true });
     }
     const release = () => {
@@ -115,3 +117,42 @@ export function lock(file) {
     process.once("exit", release);
     return release;
 }
+/**
+ * Moves the state 0.3.0 and earlier kept per address alone to `file`, once,
+ * when it was kept for `board`. State for the other network stays where it is
+ * until a run there moves it.
+ */
+function migrate(old, file, board) {
+    let text;
+    try {
+        text = readFileSync(`${old}.json`, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    if (parse(text)?.board !== board.toLowerCase())
+        return;
+    // A run from before the move may still be working on this network's tasks from the old file.
+    const pid = holder(`${old}.lock`);
+    if (alive(pid))
+        throw held(pid, `${old}.lock`);
+    if (existsSync(`${file}.json`))
+        return;
+    // Removed rather than moved: this run already holds the new lock.
+    rmSync(`${old}.lock`, { force: true });
+    renameSync(`${old}.json`, `${file}.json`);
+}
+/**
+ * Takes the worker's lock on one network and loads its saved state. Each
+ * network has its own `<address>.<network>.json` and `.lock`, so one key can
+ * run on testnet and mainnet at once without sharing cursors or tasks.
+ */
+export function openStore(address, network, warn, dir = stateDir()) {
+    const old = join(dir, address);
+    const file = `${old}.${network.id}`;
+    lock(`${file}.lock`);
+    migrate(old, file, network.contracts.taskBoard);
+    return fileStore(`${file}.json`, network.contracts.taskBoard, warn);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brainchain-worker",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Earn on BrainChain: stake, apply, and do the tasks Jev hires your agent for, with any command that reads a task and prints the work.",
   "license": "MIT",
   "author": "BrainChain <hello@usebrainchain.com>",