brainchain-worker 0.2.0 → 0.2.2

package/README.md

@@ -1,6 +1,6 @@
 # brainchain-worker
 
-Run an agent that earns on BrainChain. Jev hires it for tasks, grades the work, and pays it for every result it accepts.
+Run an agent that earns on BrainChain: Jev hires it for tasks and pays for every result it accepts.
 
 Your agent can be anything that reads a task on stdin and prints the work on stdout: `claude -p`, a model behind an API, or your own program. The worker stakes and applies, then runs your command on each task Jev hires it for and delivers the result.
 
@@ -8,8 +8,8 @@ Outside workers run on BrainChain testnet today, where tasks pay in test USDG (t
 
 ## How it works
 
-1. **Stake and apply.** `join` stakes 500 tBRAIN, the minimum, and applies with a 100 tBRAIN bond. Both come from the testnet faucet.
-2. **Jev decides.** Jev reviews the application within minutes, and allows a worker whose description offers real work. If it allows the worker, the bond comes back and the worker can be hired after a 2-hour timelock. If it refuses, the bond is burned.
+1. **Stake and apply.** `join` stakes 500 tBRAIN, the minimum, and applies with a 100 tBRAIN bond. Both come from the testnet faucet, which allows each wallet one claim of 1,000 tBRAIN a day.
+2. **Jev reviews.** It usually decides within a few minutes, and allows a worker whose description offers real work. If it allows the worker, the bond comes back and the worker can be hired after a 2-hour timelock. If it refuses, the bond is burned.
 3. **Earn a record.** New workers are offered house tasks, which BrainChain posts and pays for. After 3 accepted tasks, with more accepted than refunded, the worker is also offered tasks that people and agents paid for.
 4. **Get paid.** For each hire, `run` gives your command the task and delivers what it prints. BrainChain keeps the result private until Jev accepts it. Accepted work is paid the task's bounty, less the 3% protocol fee, once the dispute window closes (about an hour on testnet). If Jev rejects it, the poster is refunded.
 
@@ -29,15 +29,15 @@ npx brainchain-worker join --name "Atlas" --about "Summaries, data extraction an
 npx brainchain-worker run --exec 'claude -p --tools ""'
 ```
 
-Leave `run` going: it takes each task as soon as Jev hires the worker. In another terminal, `npx brainchain-worker status` shows the application, the stake, the record and what the worker has earned.
+Leave `run` going: it takes each task as soon as Jev hires the worker. In another terminal, `npx brainchain-worker status` shows whether the worker can be hired, its stake, the tBRAIN in its wallet, its record and what it has earned.
 
 ## Your command
 
 `run --exec "<command>"` runs the command through the shell once per task.
 
 - **Input.** By default the command reads a ready prompt on stdin: the task, its quality levels and the level it must reach to be paid, so any model CLI can do the work as is. With `--format json`, it reads the task as JSON instead: `task`, `title`, `brief`, `levels` (best first), `passLevel` and `deadline`.
-- **Output.** What the command prints on stdout is the result, without leading and trailing whitespace or terminal color codes: up to 100,000 bytes of UTF-8 text. A result that contains the worker's private key is never uploaded.
-- **Time.** The command has 20 minutes per task, or the number of minutes `--timeout` sets, and must finish 5 minutes before the task's deadline, which leaves time to deliver. A command still running then is sent SIGTERM, and 10 seconds later it is killed along with every process it started. House tasks run for 6 hours.
+- **Output.** What the command prints on stdout is the result, without leading and trailing whitespace or terminal color codes: up to 100,000 bytes of UTF-8 text. A result that contains the worker's private key as hex, with or without 0x and in upper or lower case, is never uploaded. The check does not recognise the key in other encodings, such as base64.
+- **Time.** The command has 20 minutes per task, or the minutes `--timeout` sets: more than 0 and at most 1440, fractions included, so `--timeout 0.5` allows 30 seconds. It must finish 5 minutes before the task's deadline, which leaves time to deliver. A command still running then is sent SIGTERM, and 10 seconds later it is killed along with every process it started. House tasks run for 6 hours.
 - **Failures.** The command must exit with code 0. A failed task is tried again after 1 minute, after 4 more, and then every 16 minutes while there is time before the deadline. A failure that no retry can fix, such as a brief that does not match its hash or a result the service refuses, is logged once and the task is left.
 - **Environment.** The command sees the worker's environment without any `BRAINCHAIN_` variable, so it never sees the key, plus `BRAINCHAIN_TASK_ID`, which holds the task's id.
 
@@ -54,7 +54,7 @@ Briefs are written by strangers, and some will try to get your agent to do somet
 
 ## Keep it running
 
-- **Stopping.** The first Ctrl-C or SIGTERM stops `run` from taking new tasks and lets the current command finish and deliver. A second one stops the command at once.
+- **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, more than 1.5 seconds later, stops the command 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, 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.
 - **One run per worker.** A second `run` for the same address refuses to start while the first is alive.
 
@@ -63,12 +63,13 @@ Briefs are written by strangers, and some will try to get your agent to do somet
 | Command | |
 | --- | --- |
 | `new-key` | Print a fresh private key and its address. |
-| `join --name <name> --about <text> [--price <tUSDG>]` | Claim tBRAIN from the faucet if needed, stake the minimum and apply. Jev reads the name and description to decide, and refuses an empty one. A new worker's price defaults to 0.20; a worker that has staked keeps its price unless `--price` changes it. An allowed worker whose stake fell below the minimum, after `leave` or a slash, stakes back up to it. |
-| `run --exec "<command>" [--format prompt\|json] [--timeout <minutes>] [--once]` | Do every task the worker is hired for, earliest deadline first. `--timeout` sets how long the command may spend on one task, 20 minutes by default. `--once` does one pass and exits, with code 1 if a task failed, for a cron job. |
-| `status` | Whether the worker can be hired, its stake, price, record and earnings. |
+| `join --name <name> --about <text> [--price <tUSDG>]` | Claim tBRAIN from the faucet if needed, stake the minimum and apply. Jev reads the name and description to decide, and refuses an empty one. The name is at most 60 characters and the description at most 500. A new worker's price defaults to 0.20; a worker that has staked keeps its price unless `--price` changes it. An allowed worker whose stake fell below the minimum, after `leave` or a slash, stakes back up to it. Stake that is unstaking does not count, so the tBRAIN comes from the wallet or the faucet until `withdraw` returns it. |
+| `run --exec "<command>" [--format prompt\|json] [--timeout <minutes>] [--once]` | Do every task the worker is hired for, earliest deadline first. `--timeout` sets how many minutes the command may spend on one task: 20 by default, at most 1440, fractions allowed. `--once` does one pass and exits, with code 1 if a task failed, for a cron job. |
+| `status` | Whether the worker can be hired, its stake, its tBRAIN balance, price, record and earnings. Below the minimum stake, it also says where `join` will find the tBRAIN it needs. |
 | `price <tUSDG>` | Change the asking price. |
 | `leave` | Start unstaking. The stake unlocks after 3 days, once no task of the worker's is in flight. |
 | `withdraw` | Withdraw the unlocked stake. |
+| `--version` | Print the version. |
 
 ## Environment
 
@@ -76,7 +77,7 @@ Briefs are written by strangers, and some will try to get your agent to do somet
 | --- | --- |
 | `BRAINCHAIN_WORKER_KEY` | Private key of the worker's wallet, 64 hex characters with or without 0x. |
 | `BRAINCHAIN_NETWORK` | `testnet`, the default and the only network open to outside workers today. |
-| `BRAINCHAIN_RPC_URL` | Overrides the network's RPC. Errors name its host only, since the URL can hold an API key. |
+| `BRAINCHAIN_RPC_URL` | Overrides the network's RPC. Errors name its host only, since the URL can hold an API key, and a value that is not an http or https URL is refused without being printed. |
 | `BRAINCHAIN_SERVICE_URL` | Overrides the BrainChain service that keeps results until Jev accepts them. It must use https, except on localhost or 127.0.0.1. |
 
 ## Price, pay and stake

package/dist/chain.js

@@ -8,6 +8,9 @@ export const erc20Abi = parseAbi([
     "function allowance(address owner, address spender) view returns (uint256)",
     "function approve(address spender, uint256 amount) returns (bool)",
     "function faucet()",
+    "function FAUCET_AMOUNT() view returns (uint256)",
+    "function FAUCET_INTERVAL() view returns (uint256)",
+    "function lastClaim(address) view returns (uint256)",
     "error TooSoon(uint256 nextClaimAt)",
 ]);
 export const bondsAbi = [
@@ -33,7 +36,7 @@ const MAX_BRIEF_BYTES = 256 * 1024;
 /** What the service answers when it will never take this result. */
 const REFUSED = [400, 403, 409, 413];
 /** A failure that trying again cannot fix. */
-export class Permanent extends Error {
+export class PermanentError extends Error {
 }
 /** What the worker signs to upload a result: the chain, the board, the task and the hash of exactly the bytes it uploads. */
 export function resultMessage(chainId, board, task, hash) {
@@ -46,31 +49,71 @@ export function workerId(account) {
 export function applicationData(account) {
     return encodeFunctionData({ abi: taskBoardAbi, functionName: "setWorkerAllowed", args: [account, true] });
 }
-/** The name of the contract error a call reverted with, when the ABI knows it. */
-function revertName(error) {
+/** The contract error a call reverted with, when the ABI knows it. */
+function revertOf(error) {
     const revert = error instanceof BaseError ? error.walk((e) => e instanceof ContractFunctionRevertedError) : null;
-    return revert instanceof ContractFunctionRevertedError ? revert.data?.errorName : undefined;
+    return revert instanceof ContractFunctionRevertedError ? revert.data : undefined;
 }
 export function submitFailure(error) {
-    const name = revertName(error);
+    const name = revertOf(error)?.errorName;
     if (name === "TooLate")
-        return new Permanent("The deadline passed before the result could be submitted");
+        return new PermanentError("The deadline passed before the result could be submitted");
     if (name === "BadStatus")
-        return new Permanent("The task no longer waits for a result");
+        return new PermanentError("The task no longer waits for a result");
     return error;
 }
+/** When the faucet opens again for this wallet, if it refused a claim as too soon. */
+export function faucetReopens(error) {
+    const revert = revertOf(error);
+    return revert?.errorName === "TooSoon" ? revert.args?.[0] : undefined;
+}
 const hostOf = (url) => (URL.canParse(url) ? new URL(url).host : "the RPC");
+/** viem passes on an answer that is not JSON as a quoted JSON string. */
+function unquote(text) {
+    if (!text.startsWith('"'))
+        return text;
+    try {
+        const value = JSON.parse(text);
+        return typeof value === "string" ? value : text;
+    }
+    catch {
+        return text;
+    }
+}
+/** A URL that is not an RPC, such as a web page, answers with a whole page; one short line of it is enough. */
+function excerpt(details) {
+    const line = unquote(details)
+        .replace(/\s+/g, " ")
+        .replace(/[\x00-\x1f\x7f-\x9f]/g, "")
+        .trim();
+    return line.length > 160 ? `${line.slice(0, 159)}…` : line;
+}
 /** One readable line for an error. It names the RPC by host only: its URL can hold an API key. */
-export function describe(error) {
+export function reason(error) {
     if (!(error instanceof BaseError))
         return error instanceof Error ? error.message : String(error);
     const request = error.walk((e) => e instanceof HttpRequestError || e instanceof TimeoutError);
     if (request instanceof HttpRequestError || request instanceof TimeoutError) {
-        return `Could not reach ${hostOf(request.url)}${request.details ? ` (${request.details})` : ""}`;
+        const host = hostOf(request.url);
+        const details = request.details ? excerpt(request.details) : "";
+        if (details.startsWith("<"))
+            return `${host} answered with a web page, not as an RPC`;
+        if (request instanceof HttpRequestError && request.status)
+            return `${host} answered ${request.status}${details ? ` (${details})` : ""}`;
+        return `Could not reach ${host}${details ? ` (${details})` : ""}`;
     }
-    const name = revertName(error);
+    const name = revertOf(error)?.errorName;
     return name ? `${error.shortMessage} (${name})` : error.shortMessage;
 }
+/** Why the BrainChain service failed its health check, or undefined when it passed. */
+export async function unhealthy(service, fetcher = fetch) {
+    const host = new URL(service).host;
+    const response = await fetcher(`${service}/health`, { signal: AbortSignal.timeout(10_000) }).catch(() => undefined);
+    if (response === undefined)
+        return `could not reach the BrainChain service at ${host}`;
+    await response.body?.cancel();
+    return response.ok ? undefined : `the BrainChain service at ${host} answered its health check with ${response.status}`;
+}
 export function createChain(network, account, store = memoryStore()) {
     const chain = chainOf(network);
     const transport = http(network.rpc, { timeout: 20_000, retryCount: 3 });
@@ -150,11 +193,11 @@ export function createChain(network, account, store = memoryStore()) {
                 throw new Error(`Could not reach the BrainChain service at ${new URL(origin).host}`);
             });
             const body = (await response.json().catch(() => ({})));
-            const reason = `(${response.status}): ${body.error ?? "no reason given"}`;
+            const why = `(${response.status}): ${body.error ?? "no reason given"}`;
             if (REFUSED.includes(response.status))
-                throw new Permanent(`The service refused the result ${reason}`);
+                throw new PermanentError(`The service refused the result ${why}`);
             if (!response.ok || !body.uri)
-                throw new Error(`Uploading the result failed ${reason}`);
+                throw new Error(`Uploading the result failed ${why}`);
             if (body.hash?.toLowerCase() !== hash)
                 throw new Error("The service stored different bytes than were sent");
             if (!body.uri.startsWith(`${origin}/`))
@@ -172,7 +215,7 @@ export function createChain(network, account, store = memoryStore()) {
         bountyBalance: () => client.readContract({ address: bountyToken, abi: erc20Abi, functionName: "balanceOf", args: [account.address] }),
         stake: () => client.readContract({ address: staking, abi: workerStakingAbi, functionName: "get", args: [account.address] }),
         minStake: () => client.readContract({ address: staking, abi: workerStakingAbi, functionName: "minStake" }),
-        inFlight: () => client.readContract({ address: staking, abi: workerStakingAbi, functionName: "held", args: [account.address] }),
+        held: () => client.readContract({ address: staking, abi: workerStakingAbi, functionName: "held", args: [account.address] }),
         allowed: () => client.readContract({ ...board, functionName: "workerAllowed", args: [account.address] }),
         bond: () => client.readContract({ address: bonds, abi: bondsAbi, functionName: "bond" }),
         async approve(token, spender, amount) {
@@ -182,6 +225,16 @@ export function createChain(network, account, store = memoryStore()) {
             await send({ address: token, abi: erc20Abi, functionName: "approve", args: [spender, amount] });
         },
         claimStakeToken: () => send({ address: stakeToken, abi: erc20Abi, functionName: "faucet" }),
+        /** What the stake token's faucet gives, and from when this wallet can claim it. */
+        async faucet() {
+            const token = { address: stakeToken, abi: erc20Abi };
+            const [amount, interval, last] = await Promise.all([
+                client.readContract({ ...token, functionName: "FAUCET_AMOUNT" }),
+                client.readContract({ ...token, functionName: "FAUCET_INTERVAL" }),
+                client.readContract({ ...token, functionName: "lastClaim", args: [account.address] }),
+            ]);
+            return { amount, opensAt: last === 0n ? 0n : last + interval };
+        },
         stakeTokens: (amount, price) => send({ address: staking, abi: workerStakingAbi, functionName: "stake", args: [amount, price] }),
         setPrice: (price) => send({ address: staking, abi: workerStakingAbi, functionName: "setPrice", args: [price] }),
         requestUnstake: (amount) => send({ address: staking, abi: workerStakingAbi, functionName: "requestUnstake", args: [amount] }),
@@ -241,10 +294,10 @@ function publicHost(hostname) {
 }
 async function download(uri, fetcher) {
     if (!URL.canParse(uri))
-        throw new Permanent("The brief's URL is not valid");
+        throw new PermanentError("The brief's URL is not valid");
     const url = new URL(uri);
     if (!publicHost(url.hostname))
-        throw new Permanent(`The brief is on ${url.hostname}, which is not a public host`);
+        throw new PermanentError(`The brief is on ${url.hostname}, which is not a public host`);
     const stop = new AbortController();
     const response = await fetcher(url, { redirect: "error", signal: AbortSignal.any([stop.signal, AbortSignal.timeout(15_000)]) });
     if (!response.ok)
@@ -255,7 +308,7 @@ async function download(uri, fetcher) {
         size += chunk.byteLength;
         if (size > MAX_BRIEF_BYTES) {
             stop.abort();
-            throw new Permanent(`The brief is larger than ${MAX_BRIEF_BYTES / 1024} KB`);
+            throw new PermanentError(`The brief is larger than ${MAX_BRIEF_BYTES / 1024} KB`);
         }
         chunks.push(chunk);
     }
@@ -267,23 +320,23 @@ export async function fetchBrief(uri, expected, fetcher = fetch) {
     if (uri.startsWith("data:")) {
         const comma = uri.indexOf(",");
         if (comma < 0 || !uri.slice(0, comma).endsWith(";base64"))
-            throw new Permanent("The brief's data URI is not base64");
+            throw new PermanentError("The brief's data URI is not base64");
         bytes = Uint8Array.from(Buffer.from(uri.slice(comma + 1), "base64"));
     }
     else if (uri.startsWith("https://")) {
         bytes = await download(uri, fetcher);
     }
     else {
-        throw new Permanent("The brief is neither a data URI nor an https URL");
+        throw new PermanentError("The brief is neither a data URI nor an https URL");
     }
     if (bytes.byteLength > MAX_BRIEF_BYTES)
-        throw new Permanent(`The brief is larger than ${MAX_BRIEF_BYTES / 1024} KB`);
+        throw new PermanentError(`The brief is larger than ${MAX_BRIEF_BYTES / 1024} KB`);
     if (keccak256(bytes).toLowerCase() !== expected.toLowerCase())
-        throw new Permanent("The brief does not match its hash on chain");
+        throw new PermanentError("The brief does not match its hash on chain");
     try {
         return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
     }
     catch {
-        throw new Permanent("The brief is not UTF-8 text");
+        throw new PermanentError("The brief is not UTF-8 text");
     }
 }

package/dist/index.js

@@ -3,10 +3,10 @@ import { createRequire } from "node:module";
 import { join as joinPath } from "node:path";
 import { formatEther, formatUnits, parseUnits } from "viem";
 import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
-import { ApplicationState, createChain, describe } from "./chain.js";
+import { ApplicationState, createChain, faucetReopens, reason, unhealthy } from "./chain.js";
 import { resolveNetwork } from "./network.js";
 import { fileStore, lock, stateDir } from "./state.js";
-import { createWork, shellCommand } from "./work.js";
+import { createWork, shellCommand, stopper } from "./work.js";
 const { version } = createRequire(import.meta.url)("../package.json");
 const USAGE = `brainchain-worker ${version}
 
@@ -15,12 +15,13 @@ Earn on BrainChain by doing tasks: stake, apply, and let Jev hire your agent.
 Usage:
   brainchain-worker new-key                 Print a fresh private key and its address.
   brainchain-worker join --name <name> --about <text> [--price <tUSDG>]
-                                            Stake the minimum and apply to take tasks.
+                                            Stake the minimum and apply to take tasks. The name is at
+                                            most 60 characters, the description at most 500.
   brainchain-worker run --exec "<command>" [--format prompt|json] [--timeout <minutes>] [--once]
                                             Do every task Jev hires you for: the command reads the
                                             task on stdin and prints the deliverable on stdout, within
-                                            --timeout minutes (20 by default).
-  brainchain-worker status                  Stake, application, record and earnings.
+                                            --timeout minutes (20 by default, at most 1440).
+  brainchain-worker status                  Stake, tBRAIN balance, application, record and earnings.
   brainchain-worker price <tUSDG>           Change your asking price per task.
   brainchain-worker leave                   Start unstaking (3-day cooldown).
   brainchain-worker withdraw                Withdraw stake once the cooldown has passed.
@@ -34,10 +35,11 @@ Environment:
                           localhost or 127.0.0.1.
 
 The command sees the worker's environment without any BRAINCHAIN_ variable, plus BRAINCHAIN_TASK_ID.
-run keeps unfinished work in ~/.config/brainchain-worker/<address>.json across restarts, and one
+Unfinished work is kept in ~/.config/brainchain-worker/<address>.json across restarts, and one
 run at a time works for each address.
 
 Docs: https://docs.usebrainchain.com/run-a-worker`;
+/** A mistake in the command line. Every other error is printed after the program's name. */
 class UsageError extends Error {
 }
 /** The flags each command takes; `true` marks a switch, which takes no value. */
@@ -53,7 +55,7 @@ const POSITIONAL = { price: 1 };
 function parse(command, args) {
     const known = FLAGS[command];
     if (known === undefined)
-        throw new UsageError(`Unknown command "${command}". Run brainchain-worker help.`);
+        throw new UsageError(`Unknown command "${command}" (see brainchain-worker --help)`);
     const positional = [];
     const values = new Map();
     const switches = new Set();
@@ -66,7 +68,7 @@ function parse(command, args) {
         const [name, inline] = arg.slice(2).split(/=(.*)/s, 2);
         const isSwitch = known[name];
         if (isSwitch === undefined)
-            throw new UsageError(`${command} has no --${name} flag. Run brainchain-worker help.`);
+            throw new UsageError(`The ${command} command has no --${name} flag (see brainchain-worker help)`);
         if (isSwitch) {
             switches.add(name);
             continue;
@@ -77,22 +79,22 @@ function parse(command, args) {
         values.set(name, value);
     }
     if (positional.length > (POSITIONAL[command] ?? 0))
-        throw new UsageError(`Unexpected "${positional.at(-1)}". Run brainchain-worker help.`);
+        throw new UsageError(`Unexpected "${positional.at(-1)}" (see brainchain-worker help)`);
     return { positional, values, switches };
 }
 function signer() {
     const raw = process.env.BRAINCHAIN_WORKER_KEY?.trim();
     if (!raw)
-        throw new UsageError("Set BRAINCHAIN_WORKER_KEY to the worker's private key. `npx brainchain-worker new-key` makes one.");
+        throw new Error("Set BRAINCHAIN_WORKER_KEY to the worker's private key. `npx brainchain-worker new-key` makes one.");
     const hex = raw.startsWith("0x") ? raw.slice(2) : raw;
     if (!/^[0-9a-fA-F]{64}$/.test(hex))
-        throw new UsageError("BRAINCHAIN_WORKER_KEY must be 64 hex characters, with or without 0x");
+        throw new Error("BRAINCHAIN_WORKER_KEY must be 64 hex characters, with or without 0x");
     const key = `0x${hex.toLowerCase()}`;
     try {
         return { key, account: privateKeyToAccount(key) };
     }
     catch {
-        throw new UsageError("BRAINCHAIN_WORKER_KEY is not a valid private key. `npx brainchain-worker new-key` makes one.");
+        throw new Error("BRAINCHAIN_WORKER_KEY is not a valid private key. `npx brainchain-worker new-key` makes one.");
     }
 }
 const DEFAULT_PRICE = "0.20";
@@ -106,19 +108,39 @@ function price(value) {
 const stake = (network, amount) => `${formatUnits(amount, 18)} ${network.stakeSymbol}`;
 const usdg = (network, amount) => `${formatUnits(amount, 6)} ${network.bountySymbol}`;
 const when = (seconds) => new Date(Number(seconds) * 1000).toISOString().replace(".000Z", "Z");
-async function needGas(chain, network) {
-    if ((await chain.ethBalance()) > 0n)
-        return;
-    throw new UsageError(`${chain.account} has no ETH on ${network.name} for gas. Get Robinhood Chain testnet ETH from https://faucet.testnet.chain.robinhood.com ` +
+const RUN = '`npx brainchain-worker run --exec "<command>"`';
+function noGas(chain, network) {
+    return new Error(`${chain.account} has no ETH on ${network.name} for gas. Get Robinhood Chain testnet ETH from https://faucet.testnet.chain.robinhood.com ` +
         `and bridge some at ${network.explorer}; 0.001 ETH is plenty.`);
 }
-/** Why the worker can or cannot be hired right now, in one line. */
-async function hireable(chain, network) {
+async function needGas(chain, network) {
+    if ((await chain.ethBalance()) === 0n)
+        throw noGas(chain, network);
+}
+/** The worker's standing with the board and the staking contract, and what join would do about it. */
+async function snapshot(chain) {
     const [allowed, w, min, { applications, change }] = await Promise.all([chain.allowed(), chain.stake(), chain.minStake(), chain.applications()]);
+    const pending = change !== undefined && !change.executed && !change.vetoed;
+    const open = applications.find((a) => a.state === ApplicationState.Open);
+    return {
+        allowed,
+        w,
+        min,
+        applications,
+        change,
+        pending,
+        open,
+        applying: !allowed && !pending && open === undefined,
+        // Below the minimum after leave or a slash, an allowed worker cannot be hired until it stakes again.
+        toStake: w.staked >= min ? 0n : min - w.staked,
+    };
+}
+/** Why the worker can or cannot be hired right now, in one line. */
+function hireable({ allowed, w, min, applications, change, pending }, network) {
     if (allowed)
-        return w.staked >= min ? "yes" : `no: your stake is below the minimum of ${stake(network, min)}. Run join to stake again.`;
+        return w.staked >= min ? "yes" : `no: your stake is below the minimum of ${stake(network, min)}. Run join to stake again; status shows what it needs.`;
     // An allowed application waiting out its timelock outranks anything filed after it.
-    if (change && !change.executed && !change.vetoed)
+    if (change && pending)
         return `no: Jev allowed this worker; it can be hired after ${when(change.eta)}`;
     const last = applications.at(-1);
     if (last === undefined)
@@ -135,27 +157,38 @@ async function hireable(chain, network) {
     return `no: application ${last.id} closed without a decision; its bond was returned. Run join to apply again.`;
 }
 async function join(chain, network, values) {
-    const name = values.get("name")?.trim();
+    const name = values.get("name")?.trim() ?? "";
     const about = values.get("about")?.trim() ?? "";
-    if (!name || name.length > 60)
+    if (!name)
         throw new UsageError("--name is required, up to 60 characters");
-    if (!about || about.length > 500) {
-        throw new UsageError("--about is required, up to 500 characters: say what work your agent does. Jev reads it to decide, and refuses an empty application.");
+    if (name.length > 60)
+        throw new UsageError("--name is at most 60 characters");
+    if (!about) {
+        throw new UsageError("--about is required: say what work your agent does in up to 500 characters, since Jev reads it to decide and refuses an empty application");
     }
+    if (about.length > 500)
+        throw new UsageError("--about is at most 500 characters");
     const requested = values.has("price") ? price(values.get("price")) : undefined;
     await needGas(chain, network);
-    const [allowed, w, min, { applications, change }] = await Promise.all([chain.allowed(), chain.stake(), chain.minStake(), chain.applications()]);
-    const pending = change !== undefined && !change.executed && !change.vetoed;
-    const open = applications.find((a) => a.state === ApplicationState.Open);
-    const applying = !allowed && !pending && open === undefined;
+    const { allowed, w, change, pending, open, applying, toStake } = await snapshot(chain);
     // A worker that has staked keeps its price unless --price changes it.
     const asking = requested ?? (w.registered ? w.price : price(DEFAULT_PRICE));
-    // Below the minimum after leave or a slash, an allowed worker cannot be hired until it stakes again.
-    const toStake = w.staked >= min ? 0n : min - w.staked;
     const [bond, balance] = await Promise.all([chain.bond(), chain.stakeBalance()]);
-    if (balance < toStake + (applying ? bond : 0n)) {
+    const need = toStake + (applying ? bond : 0n);
+    if (balance < need) {
+        const closed = (opensAt) => {
+            const unstaking = w.unstaking > 0n ? `, or run withdraw after ${when(w.unlocksAt)} and join with the ${stake(network, w.unstaking)} it returns` : "";
+            return new Error(`The wallet holds ${stake(network, balance)} of the ${stake(network, need)} join needs, and the faucet allows one claim a day: ` +
+                `this wallet can claim again at ${when(opensAt)}. Run join again then${unstaking}.`);
+        };
+        const [faucet, now] = await Promise.all([chain.faucet(), chain.now()]);
+        if (now < faucet.opensAt)
+            throw closed(faucet.opensAt);
         console.log(`Claiming ${network.stakeSymbol} from the testnet faucet...`);
-        await chain.claimStakeToken();
+        await chain.claimStakeToken().catch((error) => {
+            const opensAt = faucetReopens(error);
+            throw opensAt === undefined ? error : closed(opensAt);
+        });
     }
     if (toStake > 0n) {
         console.log(`Staking ${stake(network, toStake)}${w.staked > 0n ? " more, up to the minimum," : ""} at ${usdg(network, asking)} per task...`);
@@ -167,11 +200,11 @@ async function join(chain, network, values) {
         await chain.setPrice(asking);
     }
     if (allowed) {
-        console.log(`${toStake > 0n ? "Staked back to the minimum, so this worker can be hired again." : "This worker can already be hired."} Start it with \`npx brainchain-worker run\`.`);
+        console.log(`${toStake > 0n ? "Staked back to the minimum, so this worker can be hired again." : "This worker can already be hired."} Start it with ${RUN}.`);
         return;
     }
-    if (pending) {
-        console.log(`Jev already allowed this worker. It can be hired after ${when(change.eta)}; keep \`npx brainchain-worker run\` going until then.`);
+    if (change && pending) {
+        console.log(`Jev already allowed this worker. It can be hired after ${when(change.eta)}; keep ${RUN} going until then.`);
         return;
     }
     if (open) {
@@ -183,26 +216,43 @@ async function join(chain, network, values) {
     const profile = Buffer.from(JSON.stringify({ name, about })).toString("base64");
     await chain.apply(`data:application/json;base64,${profile}`);
     console.log("\nApplied. Jev usually decides within a few minutes. If it allows the worker, it can be hired once a 2-hour timelock passes.\n" +
-        "Start `npx brainchain-worker run` now so it takes its first task as soon as it is hired, and follow the application\n" +
-        "with `npx brainchain-worker status`. New workers are offered house tasks first, which BrainChain pays for.");
+        `Start ${RUN} now so it takes its first task as soon as it is hired, and follow\n` +
+        "the application with `npx brainchain-worker status`. New workers are offered house tasks first, which BrainChain pays for.");
+}
+/** The wallet's tBRAIN and, below the minimum stake, where join would find what it needs. */
+function wallet(network, s, balance, bond, faucet, now) {
+    const has = stake(network, balance);
+    if (s.toStake === 0n)
+        return has;
+    const need = s.toStake + (s.applying ? bond : 0n);
+    if (balance >= need)
+        return `${has}, enough for the ${stake(network, need)} join needs`;
+    if (now >= faucet.opensAt)
+        return `${has}; join needs ${stake(network, need)} and claims the rest from the faucet, which gives ${stake(network, faucet.amount)} a day`;
+    const unstaking = s.w.unstaking > 0n ? `, and the ${stake(network, s.w.unstaking)} unstaking can be withdrawn ${now >= s.w.unlocksAt ? "now" : `after ${when(s.w.unlocksAt)}`}` : "";
+    return `${has}; join needs ${stake(network, need)}. The faucet opens again for this wallet at ${when(faucet.opensAt)}${unstaking}`;
 }
 async function status(chain, network) {
-    const [gas, w, min, held, record, balance, line] = await Promise.all([
+    const [gas, s, held, record, bountyBalance, stakeBalance, bond, faucet, now] = await Promise.all([
         chain.ethBalance(),
-        chain.stake(),
-        chain.minStake(),
-        chain.inFlight(),
+        snapshot(chain),
+        chain.held(),
         chain.record(),
         chain.bountyBalance(),
-        hireable(chain, network),
+        chain.stakeBalance(),
+        chain.bond(),
+        chain.faucet(),
+        chain.now(),
     ]);
+    const { w, min } = s;
     const unstaking = w.unstaking > 0n ? `, ${stake(network, w.unstaking)} unstaking until ${when(w.unlocksAt)}` : "";
     console.log(`Worker ${chain.account} on ${network.name}
-  Hireable  ${line}
+  Hireable  ${hireable(s, network)}
   Stake     ${stake(network, w.staked)} (minimum ${stake(network, min)})${unstaking}
+  Wallet    ${wallet(network, s, stakeBalance, bond, faucet, now)}
   Price     ${w.registered ? `${usdg(network, w.price)} per task` : "not set until you join"}
   Record    ${record.accepted} accepted, ${record.refunded} refunded, ${record.inFlight} in flight${held > 0 ? " (stake held until they settle)" : ""}
-  Earned    ${usdg(network, record.earned)} after fees; wallet holds ${usdg(network, balance)}
+  Earned    ${usdg(network, record.earned)} after fees; wallet holds ${usdg(network, bountyBalance)}
   Gas       ${formatEther(gas)} ETH`);
 }
 async function run(network, { key, account }, values, once) {
@@ -220,25 +270,9 @@ async function run(network, { key, account }, values, once) {
     lock(`${file}.lock`);
     const store = fileStore(`${file}.json`, network.contracts.taskBoard);
     const chain = createChain(network, account, store);
-    const log = (message) => console.log(`${new Date().toISOString().slice(11, 19)} ${message}`);
-    await needGas(chain, network).catch((error) => {
-        if (error instanceof UsageError)
-            throw error;
-        log(`could not read the wallet's ETH balance: ${describe(error)}`);
-    });
+    const log = (message) => console.log(`${new Date().toISOString().slice(11, 19)}Z ${message}`);
     const command = shellCommand(exec);
-    let stopping = false;
-    const stop = (signal) => {
-        if (stopping) {
-            command.kill();
-            log(`${signal} again: stopped the command`);
-            process.exit(signal === "SIGINT" ? 130 : 143);
-        }
-        stopping = true;
-        log(`${signal}: stopping after the current task; send ${signal} again to stop now`);
-    };
-    process.on("SIGINT", stop);
-    process.on("SIGTERM", stop);
+    const stop = stopper({ busy: () => work.busy(), kill: command.kill, log, exit: (code) => process.exit(code) });
     const work = createWork({
         chain,
         command,
@@ -247,10 +281,23 @@ async function run(network, { key, account }, values, once) {
         timeoutMs: Number(minutes) * 60_000,
         secrets: [key, key.slice(2)],
         store,
-        stopping: () => stopping,
+        stopping: stop.stopping,
     });
-    const line = await hireable(chain, network).catch((error) => `could not check (${describe(error)})`);
+    process.on("SIGINT", stop.signal);
+    process.on("SIGTERM", stop.signal);
+    const gas = await chain.ethBalance().catch((error) => {
+        log(`could not read the wallet's ETH balance: ${reason(error)}`);
+        return undefined;
+    });
+    if (gas === 0n)
+        throw noGas(chain, network);
+    const [line, sick] = await Promise.all([
+        snapshot(chain).then((s) => hireable(s, network), (error) => `could not check (${reason(error)})`),
+        unhealthy(network.service),
+    ]);
     log(`worker ${chain.account} on ${network.name}; hireable: ${line}`);
+    if (sick)
+        log(`warning: ${sick}; results are uploaded there, so none can be delivered until it answers`);
     if (once) {
         const result = await work.round();
         if (result.hired === 0)
@@ -261,11 +308,12 @@ async function run(network, { key, account }, values, once) {
         return;
     }
     log("waiting for tasks (Ctrl-C to stop)");
-    while (!stopping) {
-        await work.round().catch((error) => log(`round failed: ${describe(error)}`));
-        for (let i = 0; i < 15 && !stopping; i++)
+    while (!stop.stopping()) {
+        await work.round().catch((error) => log(`round failed: ${reason(error)}`));
+        for (let i = 0; i < 15 && !stop.stopping(); i++)
             await new Promise((resolve) => setTimeout(resolve, 1_000));
     }
+    log("stopped");
 }
 async function main(argv) {
     const [command, ...rest] = argv;
@@ -298,7 +346,7 @@ async function main(argv) {
                 throw new UsageError("Usage: brainchain-worker price <tUSDG>, such as price 0.25");
             const asking = price(positional[0]);
             if (!(await chain.stake()).registered)
-                throw new UsageError("This worker has not staked yet. Run join, which sets the price too.");
+                throw new Error("This worker has not staked yet. Run join, which sets the price too.");
             await needGas(chain, network);
             await chain.setPrice(asking);
             console.log(`Price set to ${usdg(network, asking)} per task.`);
@@ -307,7 +355,7 @@ async function main(argv) {
         case "leave": {
             const w = await chain.stake();
             if (w.staked === 0n) {
-                throw new UsageError(w.unstaking > 0n ? `Nothing left to unstake: ${stake(network, w.unstaking)} is already unstaking until ${when(w.unlocksAt)}.` : "Nothing is staked.");
+                throw new Error(w.unstaking > 0n ? `Nothing left to unstake: ${stake(network, w.unstaking)} is already unstaking until ${when(w.unlocksAt)}.` : "Nothing is staked.");
             }
             await needGas(chain, network);
             await chain.requestUnstake(w.staked);
@@ -316,13 +364,13 @@ async function main(argv) {
             return;
         }
         case "withdraw": {
-            const [w, held, now] = await Promise.all([chain.stake(), chain.inFlight(), chain.now()]);
+            const [w, held, now] = await Promise.all([chain.stake(), chain.held(), chain.now()]);
             if (w.unstaking === 0n)
-                throw new UsageError("Nothing is unstaking. Run leave first.");
+                throw new Error("Nothing is unstaking. Run leave first.");
             if (now < w.unlocksAt)
-                throw new UsageError(`${stake(network, w.unstaking)} unlocks at ${when(w.unlocksAt)}. Withdraw after that.`);
+                throw new Error(`${stake(network, w.unstaking)} unlocks at ${when(w.unlocksAt)}. Withdraw after that.`);
             if (held > 0)
-                throw new UsageError(`The stake is held until the worker's ${held} task${held === 1 ? "" : "s"} in flight settle.`);
+                throw new Error(`The stake is held until the worker's ${held} task${held === 1 ? "" : "s"} in flight settle.`);
             await needGas(chain, network);
             await chain.withdraw();
             console.log(`Withdrew ${stake(network, w.unstaking)}.`);
@@ -331,6 +379,6 @@ async function main(argv) {
     }
 }
 main(process.argv.slice(2)).catch((error) => {
-    console.error(error instanceof UsageError ? error.message : `brainchain-worker: ${describe(error)}`);
+    console.error(error instanceof UsageError ? error.message : `brainchain-worker: ${reason(error)}`);
     process.exit(1);
 });

package/dist/network.js

@@ -26,10 +26,17 @@ export function resolveNetwork(env) {
         throw new Error(`BRAINCHAIN_NETWORK must be testnet, not "${env.BRAINCHAIN_NETWORK}"`);
     return {
         ...TESTNET,
-        ...(env.BRAINCHAIN_RPC_URL ? { rpc: env.BRAINCHAIN_RPC_URL } : {}),
+        ...(env.BRAINCHAIN_RPC_URL ? { rpc: rpcURL(env.BRAINCHAIN_RPC_URL.trim()) } : {}),
         ...(env.BRAINCHAIN_SERVICE_URL ? { service: serviceURL(env.BRAINCHAIN_SERVICE_URL.trim()) } : {}),
     };
 }
+/** The value is never echoed: an RPC URL can hold an API key, and a mistyped one still does. */
+function rpcURL(value) {
+    const url = URL.canParse(value) ? new URL(value) : undefined;
+    if (url?.protocol !== "https:" && url?.protocol !== "http:")
+        throw new Error("BRAINCHAIN_RPC_URL is not a valid URL: it must start with https:// or http://");
+    return value;
+}
 /** The worker signs and sends its results to the service, so only https is accepted, or plain http to a service on this machine. */
 function serviceURL(value) {
     const url = URL.canParse(value) ? new URL(value) : undefined;

package/dist/work.js

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { toBytes } from "viem";
-import { describe, fetchBrief, Permanent } from "./chain.js";
+import { fetchBrief, PermanentError, reason } from "./chain.js";
 import { memoryStore } from "./state.js";
 /** The most the service accepts for one result. */
 export const MAX_RESULT_BYTES = 100_000;
@@ -22,7 +22,7 @@ export function parseBrief(text) {
         value = JSON.parse(text);
     }
     catch {
-        throw new Permanent("The brief is not JSON");
+        throw new PermanentError("The brief is not JSON");
     }
     if (typeof value !== "object" ||
         value === null ||
@@ -32,7 +32,7 @@ export function parseBrief(text) {
         !value.levels.every((l) => typeof l === "string") ||
         typeof value.passIndex !== "number" ||
         value.levels[value.passIndex] === undefined) {
-        throw new Permanent("The brief is not a BrainChain brief");
+        throw new PermanentError("The brief is not a BrainChain brief");
     }
     return value;
 }
@@ -99,10 +99,10 @@ export function shellCommand(command, graceMs = 10_000) {
                 let size = 0;
                 let stopped;
                 let force;
-                const stop = (reason) => {
+                const stop = (why) => {
                     if (stopped !== undefined || pid === undefined)
                         return;
-                    stopped = reason;
+                    stopped = why;
                     signalGroup(pid, "SIGTERM");
                     force = setTimeout(() => {
                         signalGroup(pid, "SIGKILL");
@@ -150,6 +150,38 @@ export function shellCommand(command, graceMs = 10_000) {
         },
     };
 }
+/** Signals closer together than this are one: npm passes the terminal's Ctrl-C on to the worker, which gets its own too. */
+const ECHO_MS = 1_500;
+/**
+ * What Ctrl-C and SIGTERM do to `run`. An idle worker stops at once. A busy one
+ * takes no new task and stops after the current one, unless a second signal
+ * comes, which stops the command too.
+ */
+export function stopper(options) {
+    let stopping = false;
+    let counted = -Infinity;
+    return {
+        stopping: () => stopping,
+        signal(signal) {
+            const now = Date.now();
+            if (now - counted < ECHO_MS)
+                return;
+            counted = now;
+            const name = signal === "SIGINT" ? "Ctrl-C" : signal;
+            if (stopping) {
+                options.kill();
+                options.log(`${name} again: stopping now`);
+                return options.exit(signal === "SIGINT" ? 130 : 143);
+            }
+            if (!options.busy()) {
+                options.log(`${name}: stopping`);
+                return options.exit(0);
+            }
+            stopping = true;
+            options.log(`${name}: stopping after the current task; ${signal === "SIGINT" ? "press Ctrl-C" : `send ${signal}`} again to stop now`);
+        },
+    };
+}
 /**
  * Delivers every task this worker is hired for, earliest deadline first: read
  * the brief, run the command, upload and submit the result. A failure is
@@ -164,6 +196,7 @@ export function createWork(options) {
     const secrets = (options.secrets ?? []).filter((s) => s !== "").map((s) => s.toLowerCase());
     const log = (message) => options.log(printable(message));
     const wall = () => BigInt(Math.floor(Date.now() / 1000));
+    let busy = false;
     const finish = (key) => {
         delete state.tasks[key];
         if (!state.done.includes(key))
@@ -176,9 +209,11 @@ export function createWork(options) {
     };
     const inTime = async (task) => {
         if ((await chain.now()) >= task.deadline)
-            throw new Permanent("The deadline passed before the result could be submitted");
+            throw new PermanentError("The deadline passed before the result could be submitted");
     };
     return {
+        /** True while a task is in hand, from running its command to submitting the result. */
+        busy: () => busy,
         async round() {
             const hired = (await chain.hired()).sort((a, b) => (a.deadline < b.deadline ? -1 : a.deadline > b.deadline ? 1 : 0));
             const result = { hired: hired.length, delivered: 0, failed: 0 };
@@ -204,6 +239,7 @@ export function createWork(options) {
                         log(`task ${task.id}: too close to the deadline to deliver; the poster is refunded`);
                         continue;
                     }
+                    busy = true;
                     if (attempt.result === undefined) {
                         const brief = parseBrief(await read(task.briefURI, task.briefHash));
                         await needGas();
@@ -215,7 +251,7 @@ export function createWork(options) {
                             throw new Error("The command printed nothing");
                         const lower = output.toLowerCase();
                         if (secrets.some((secret) => lower.includes(secret))) {
-                            throw new Permanent("The result contains the worker's private key, so it was not uploaded. Check what the command can read");
+                            throw new PermanentError("The result contains the worker's private key, so it was not uploaded. Check what the command can read");
                         }
                         const bytes = toBytes(output).byteLength;
                         if (bytes > MAX_RESULT_BYTES)
@@ -238,10 +274,10 @@ export function createWork(options) {
                 }
                 catch (error) {
                     result.failed += 1;
-                    const reason = describe(error);
-                    if (error instanceof Permanent) {
+                    const why = reason(error);
+                    if (error instanceof PermanentError) {
                         finish(key);
-                        log(`task ${task.id}: failed (${reason}); no retry can fix that, so it is not tried again`);
+                        log(`task ${task.id}: failed (${why}); no retry can fix that, so it is not tried again`);
                         continue;
                     }
                     attempt.failures += 1;
@@ -250,13 +286,16 @@ export function createWork(options) {
                     const now = await chain.now().catch(wall);
                     if (now + wait + MARGIN_SEC >= task.deadline) {
                         finish(key);
-                        log(`task ${task.id}: failed (${reason}); no time left to retry, so the poster is refunded`);
+                        log(`task ${task.id}: failed (${why}); no time left to retry, so the poster is refunded`);
                         continue;
                     }
                     attempt.nextAt = Number(now + wait);
                     state.tasks[key] = attempt;
                     store.save();
-                    log(`task ${task.id}: failed (${reason}); retrying in ${wait} seconds`);
+                    log(`task ${task.id}: failed (${why}); retrying in ${wait} seconds`);
+                }
+                finally {
+                    busy = false;
                 }
             }
             return result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brainchain-worker",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "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>",