@infernetprotocol/cli 0.1.64 → 0.1.66

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/commands/help.js CHANGED
@@ -38,7 +38,7 @@ Diagnostics:
38
38
  doctor End-to-end health check across all three sides
39
39
 
40
40
  Payments:
41
- payout Manage payout coin/address
41
+ payout Earnings, withdrawals and payout address
42
42
  payments Show recent payment transactions
43
43
 
44
44
  Managed endpoints:
@@ -0,0 +1,305 @@
1
+ /**
2
+ * `infernet model train|evaluate|predict|serve|capabilities|runtime|synth` —
3
+ * the temporal-policy family (workloads infernet.temporal.train and
4
+ * infernet.temporal.infer): CfC/LTC liquid networks and a GRU baseline,
5
+ * run by the isolated `infernet-liquid` Python runtime. Node only validates,
6
+ * hashes and pipes NDJSON; Python never loads unless one of these runs.
7
+ */
8
+
9
+ import { readFile, writeFile, mkdir } from "node:fs/promises";
10
+ import { spawn } from "node:child_process";
11
+ import path from "node:path";
12
+ import {
13
+ FAMILIES,
14
+ LiquidRuntime,
15
+ RUNTIME_DIR,
16
+ SCHEMA_VERSION,
17
+ WORKLOADS,
18
+ assertValid,
19
+ lockHash,
20
+ resolveRuntime,
21
+ setupRuntime,
22
+ verifyBundle
23
+ } from "@infernetprotocol/liquid-agent";
24
+
25
+ export const TEMPORAL_SUBCOMMANDS = new Set(["train", "evaluate", "eval", "predict", "serve", "capabilities", "runtime", "synth"]);
26
+
27
+ export const TEMPORAL_HELP = `
28
+ Temporal policies (workloads ${WORKLOADS.TRAIN}, ${WORKLOADS.INFER}):
29
+ infernet model runtime [status] Is the infernet-liquid runtime installed?
30
+ infernet model runtime setup [--accelerator cpu|cuda] [--yes]
31
+ Install it (PyTorch + ncps from a hash-pinned
32
+ lock, ~1 GB on CPU). Never done implicitly.
33
+ infernet model train --dataset <bundle.json> --output <dir>
34
+ [--family cfc|ltc|gru] [--baseline gru[,ltc]]
35
+ [--epochs N] [--seed N] [--hidden N] [--device auto|cpu|cuda]
36
+ [--job <train-job.json>] [--json]
37
+ Train on a liquid-agent/v1 dataset bundle;
38
+ writes model.safetensors + manifest.json.
39
+ --baseline trains the others on the same
40
+ splits and picks a winner by the rule.
41
+ infernet model evaluate --model <dir> --dataset <bundle.json> [--split test|all] [--json]
42
+ infernet model predict --model <dir> --input <steps.jsonl> [--session <id>]
43
+ Feed observed steps, print action proposals.
44
+ infernet model serve --stdio [--max-sessions N] [--ttl S] [--worker <id>]
45
+ The runtime's NDJSON contract on stdin/stdout
46
+ (what c0mpute's temporal serve drives).
47
+ infernet model capabilities [--json] Runtime, devices, RAM, families.
48
+ infernet model synth --out <bundle.json> [--per-task N] [--seed N] [--shifted]
49
+ Synthetic mock desktop traces (email,
50
+ Reddit, LinkedIn mock sites) for testing.
51
+ `;
52
+
53
+ const flag = (args, name, fallback) => (args.has(name) ? args.get(name) : fallback);
54
+ const intFlag = (args, name) => (args.has(name) ? Number.parseInt(args.get(name), 10) : undefined);
55
+
56
+ function out(args, obj, text) {
57
+ process.stdout.write(args.has("json") ? `${JSON.stringify(obj, null, 2)}\n` : text);
58
+ }
59
+
60
+ async function readJson(p) {
61
+ return JSON.parse(await readFile(p, "utf8"));
62
+ }
63
+
64
+ async function cmdRuntime(args) {
65
+ const sub = args.positional?.[1] ?? "status";
66
+ const accelerator = flag(args, "accelerator", "cpu");
67
+ if (sub === "setup") {
68
+ if (!args.has("yes") && !args.has("y") && process.env.INFERNET_NONINTERACTIVE !== "1") {
69
+ process.stdout.write(
70
+ `This installs the infernet-liquid runtime: Python venv + PyTorch (${accelerator}) + ncps from\n` +
71
+ `${path.relative(process.cwd(), path.join(RUNTIME_DIR, accelerator === "cuda" ? "requirements-cuda.lock" : "requirements.lock"))}\n` +
72
+ `(about ${accelerator === "cuda" ? "5" : "1"} GB). Re-run with --yes to proceed.\n`
73
+ );
74
+ return 1;
75
+ }
76
+ const rt = await setupRuntime({ accelerator, log: (l) => process.stderr.write(`${l}\n`) });
77
+ process.stdout.write(`installed: ${rt.python} (${rt.accelerator}, lock ${lockHash(accelerator)})\n`);
78
+ return 0;
79
+ }
80
+ const rt = resolveRuntime();
81
+ if (!rt) {
82
+ out(args, { installed: false }, "infernet-liquid runtime: not installed (infernet model runtime setup --yes)\n");
83
+ return 1;
84
+ }
85
+ const r = new LiquidRuntime(rt);
86
+ try {
87
+ const h = await r.request("health", {}, { timeoutMs: 120000 });
88
+ out(args, { installed: true, ...rt, health: h }, `infernet-liquid ${h.runtime.version}: python ${h.runtime.python}, torch ${h.runtime.torch}, ncps ${h.runtime.ncps}, cuda ${h.devices.cuda}\n ${rt.source}\n`);
89
+ return 0;
90
+ } finally {
91
+ await r.close();
92
+ }
93
+ }
94
+
95
+ async function cmdCapabilities(args) {
96
+ const rt = resolveRuntime();
97
+ if (!rt) {
98
+ out(args, { workloads: [], runtime: null }, "temporal workloads: none (runtime not installed)\n");
99
+ return 1;
100
+ }
101
+ const r = new LiquidRuntime(rt);
102
+ try {
103
+ const caps = await r.request("capabilities", {}, { timeoutMs: 120000 });
104
+ out(args, caps, `workloads: ${caps.workloads.join(", ")}\nfamilies: ${caps.families.join(", ")} (research: ${caps.research_families.join(", ")})\ncuda: ${caps.devices.cuda} ram: ${caps.ram_mb} MB threads: ${caps.threads}\n`);
105
+ return 0;
106
+ } finally {
107
+ await r.close();
108
+ }
109
+ }
110
+
111
+ function fmtMetrics(m) {
112
+ const f = (k) => (typeof m[k] === "number" ? m[k].toFixed(3) : "n/a");
113
+ return `episode_success ${f("episode_success")} step_accuracy ${f("step_accuracy")} target_accuracy ${f("target_accuracy")} ext_write_recall ${f("external_write_recall")} p50 ${f("latency_ms_p50")} ms`;
114
+ }
115
+
116
+ /** Pick by the PRD rule: a liquid family wins only if it beats every baseline on episode_success. */
117
+ export function selectFamily(results) {
118
+ const baseline = results.find((r) => r.family === "gru") ?? results[0];
119
+ const liquid = results.filter((r) => r.family !== baseline.family);
120
+ const better = liquid
121
+ .filter((r) => r.eval.metrics.episode_success > baseline.eval.metrics.episode_success)
122
+ .sort((a, b) => b.eval.metrics.episode_success - a.eval.metrics.episode_success);
123
+ return better[0] ?? baseline;
124
+ }
125
+
126
+ async function cmdTrain(args) {
127
+ const datasetPath = flag(args, "dataset");
128
+ const output = flag(args, "output");
129
+ if (!datasetPath || !output) {
130
+ process.stderr.write("error: --dataset <bundle.json> and --output <dir> are required\n");
131
+ return 2;
132
+ }
133
+ const bundle = await readJson(datasetPath);
134
+ const datasetHash = verifyBundle(bundle);
135
+ let job = null;
136
+ if (args.has("job")) job = assertValid(await readJson(args.get("job")), "train_job");
137
+ const family = job?.model_type ?? flag(args, "family", "cfc");
138
+ if (!FAMILIES.includes(family)) {
139
+ process.stderr.write(`error: --family must be one of ${FAMILIES.join(", ")}\n`);
140
+ return 2;
141
+ }
142
+ const baselines = String(flag(args, "baseline", (job?.baselines ?? []).join(",")) || "")
143
+ .split(",")
144
+ .map((s) => s.trim())
145
+ .filter((s) => s && s !== family);
146
+ const hyper = Object.fromEntries(
147
+ Object.entries({ epochs: intFlag(args, "epochs"), seed: intFlag(args, "seed"), hidden_units: intFlag(args, "hidden") }).filter(([, v]) => v !== undefined)
148
+ );
149
+ const families = [family, ...baselines];
150
+ const r = new LiquidRuntime();
151
+ const results = [];
152
+ try {
153
+ for (const fam of families) {
154
+ const dir = families.length > 1 ? path.join(output, fam) : output;
155
+ const params = {
156
+ bundle_path: path.resolve(datasetPath),
157
+ output_dir: path.resolve(dir),
158
+ family: fam,
159
+ hyperparameters: hyper,
160
+ device: flag(args, "device", "auto")
161
+ };
162
+ if (job) params.job = fam === family ? job : { ...job, model_type: fam };
163
+ if (!args.has("json")) process.stderr.write(`training ${fam} on ${datasetHash.slice(0, 19)}…\n`);
164
+ const res = await r.request("train", params, {
165
+ timeoutMs: (job?.limits?.timeout_s ?? 6 * 3600) * 1000,
166
+ onEvent: (ev) => {
167
+ if (!args.has("json") && ev.event === "epoch") process.stderr.write(` ${fam} epoch ${ev.epoch} loss ${ev.loss} val_step_acc ${ev.val_step_accuracy}\n`);
168
+ }
169
+ });
170
+ results.push({ family: fam, model_dir: res.model_dir, model_hash: res.manifest.weights.weights_hash, eval: res.eval });
171
+ }
172
+ } finally {
173
+ await r.close();
174
+ }
175
+ const chosen = selectFamily(results);
176
+ if (results.length > 1) {
177
+ await mkdir(output, { recursive: true });
178
+ await writeFile(path.join(output, "comparison.json"), JSON.stringify({ schema_version: SCHEMA_VERSION, dataset_hash: datasetHash, results, selected: chosen.family, rule: "liquid family selected only if it beats the GRU baseline on episode_success" }, null, 2) + "\n");
179
+ }
180
+ let text = "";
181
+ for (const res of results) text += `${res.family.padEnd(4)} ${res.model_hash}\n ${fmtMetrics(res.eval.metrics)}\n ${res.model_dir}\n`;
182
+ if (results.length > 1) text += `selected: ${chosen.family} (a liquid family wins only if it beats the GRU baseline)\n`;
183
+ out(args, { dataset_hash: datasetHash, results, selected: chosen.family }, text);
184
+ return 0;
185
+ }
186
+
187
+ async function cmdEvaluate(args) {
188
+ const model = flag(args, "model");
189
+ const dataset = flag(args, "dataset");
190
+ if (!model || !dataset) {
191
+ process.stderr.write("error: --model <dir> and --dataset <bundle.json> are required\n");
192
+ return 2;
193
+ }
194
+ verifyBundle(await readJson(dataset));
195
+ const r = new LiquidRuntime();
196
+ try {
197
+ const res = await r.request("evaluate", { model_dir: path.resolve(model), bundle_path: path.resolve(dataset), split: flag(args, "split", "test") }, { timeoutMs: 3600 * 1000 });
198
+ out(args, res, `${res.model_hash}\n${res.split}: ${fmtMetrics(res.metrics)}\n`);
199
+ return 0;
200
+ } finally {
201
+ await r.close();
202
+ }
203
+ }
204
+
205
+ async function cmdPredict(args) {
206
+ const model = flag(args, "model");
207
+ const input = flag(args, "input");
208
+ if (!model || !input) {
209
+ process.stderr.write("error: --model <dir> and --input <steps.jsonl> are required\n");
210
+ return 2;
211
+ }
212
+ const steps = (await readFile(input, "utf8")).split("\n").filter((l) => l.trim()).map((l) => JSON.parse(l));
213
+ const sessionId = flag(args, "session", `local-${Date.now()}`);
214
+ const r = new LiquidRuntime();
215
+ try {
216
+ const loaded = await r.request("load", { model_dir: path.resolve(model), abstain_threshold: Number(flag(args, "threshold", 0.5)) }, { timeoutMs: 120000 });
217
+ await r.request("open_session", { model_hash: loaded.model_hash, session_id: sessionId });
218
+ let prev = null;
219
+ for (const [i, step] of steps.entries()) {
220
+ const request = {
221
+ schema_version: SCHEMA_VERSION,
222
+ kind: "predict_request",
223
+ session_id: sessionId,
224
+ model_hash: loaded.model_hash,
225
+ sequence_index: i,
226
+ dt_ms: step.dt_ms ?? 0,
227
+ ...(step.task ? { task: step.task } : {}),
228
+ observation: step.observation,
229
+ prev_action: step.prev_action ?? prev
230
+ };
231
+ const p = await r.request("predict", { request });
232
+ process.stdout.write(`${JSON.stringify(p)}\n`);
233
+ prev = step.action ?? p.action;
234
+ }
235
+ await r.request("close_session", { session_id: sessionId });
236
+ return 0;
237
+ } finally {
238
+ await r.close();
239
+ }
240
+ }
241
+
242
+ function passthrough(rt, pyArgs) {
243
+ return new Promise((resolve) => {
244
+ const child = spawn(rt.python, ["-m", "infernet_liquid", ...pyArgs], {
245
+ stdio: "inherit",
246
+ env: { ...process.env, PYTHONPATH: RUNTIME_DIR, PYTHONUNBUFFERED: "1", INFERNET_LIQUID_LOCK: rt.accelerator }
247
+ });
248
+ child.on("exit", (code) => resolve(code ?? 1));
249
+ child.on("error", (e) => {
250
+ process.stderr.write(`error: ${e.message}\n`);
251
+ resolve(1);
252
+ });
253
+ });
254
+ }
255
+
256
+ function requireRuntime() {
257
+ const rt = resolveRuntime();
258
+ if (!rt) process.stderr.write("error: the infernet-liquid runtime is not installed; run `infernet model runtime setup --yes`\n");
259
+ return rt;
260
+ }
261
+
262
+ async function cmdServe(args) {
263
+ const rt = requireRuntime();
264
+ if (!rt) return 1;
265
+ const extra = [];
266
+ if (args.has("max-sessions")) extra.push("--max-sessions", String(args.get("max-sessions")));
267
+ if (args.has("ttl")) extra.push("--ttl", String(args.get("ttl")));
268
+ if (args.has("worker")) extra.push("--worker", String(args.get("worker")));
269
+ return passthrough(rt, ["serve", ...extra]);
270
+ }
271
+
272
+ async function cmdSynth(args) {
273
+ const rt = requireRuntime();
274
+ if (!rt) return 1;
275
+ const outPath = flag(args, "out");
276
+ if (!outPath) {
277
+ process.stderr.write("error: --out <bundle.json> is required\n");
278
+ return 2;
279
+ }
280
+ const pyArgs = ["synth", "--out", path.resolve(outPath), "--per-task", String(flag(args, "per-task", 160)), "--seed", String(flag(args, "seed", 7))];
281
+ if (args.has("shifted")) pyArgs.push("--shifted");
282
+ return passthrough(rt, pyArgs);
283
+ }
284
+
285
+ export async function runTemporal(sub, args) {
286
+ switch (sub) {
287
+ case "runtime":
288
+ return cmdRuntime(args);
289
+ case "capabilities":
290
+ return cmdCapabilities(args);
291
+ case "train":
292
+ return cmdTrain(args);
293
+ case "evaluate":
294
+ case "eval":
295
+ return cmdEvaluate(args);
296
+ case "predict":
297
+ return cmdPredict(args);
298
+ case "serve":
299
+ return cmdServe(args);
300
+ case "synth":
301
+ return cmdSynth(args);
302
+ default:
303
+ throw new Error(`not a temporal subcommand: ${sub}`);
304
+ }
305
+ }
package/commands/model.js CHANGED
@@ -29,6 +29,7 @@ import {
29
29
  import { recommendModels } from "../lib/recommender.js";
30
30
  import { resolveClientOptions } from "../lib/reservations-client.js";
31
31
  import { fetchNodeModels, formatNodeModels } from "../lib/node-models.js";
32
+ import { TEMPORAL_HELP, TEMPORAL_SUBCOMMANDS, runTemporal } from "./model-temporal.js";
32
33
 
33
34
  const HELP = `infernet model — manage models served by this node
34
35
 
@@ -60,7 +61,7 @@ Examples:
60
61
 
61
62
  Defaults are stored in ~/.config/infernet/config.json under engine.*
62
63
  and consumed by the daemon and \`infernet chat\`.
63
- `;
64
+ ${TEMPORAL_HELP}`;
64
65
 
65
66
  const DEFAULT_HOST = "http://localhost:11434";
66
67
 
@@ -576,6 +577,15 @@ export default async function model(args) {
576
577
  const sub = positional[0];
577
578
  const arg = positional[1];
578
579
 
580
+ if (TEMPORAL_SUBCOMMANDS.has(sub)) {
581
+ try {
582
+ return await runTemporal(sub, args);
583
+ } catch (err) {
584
+ process.stderr.write(`error: ${err?.code ? `${err.code}: ` : ""}${err?.message ?? err}\n`);
585
+ return 1;
586
+ }
587
+ }
588
+
579
589
  const cfg = (await loadConfig()) ?? {};
580
590
  const host = resolveHost(cfg);
581
591
 
@@ -1,24 +1,65 @@
1
1
  /**
2
- * `infernet payout` — manage this provider's payout coin/address via the
2
+ * `infernet payout` — earnings, withdrawals and the payout address, via the
3
3
  * signed node API.
4
4
  *
5
5
  * Subcommands:
6
+ * infernet payout list balance, recent credits, withdrawals, addresses
6
7
  * infernet payout set <coin> <address> [--network <name>]
7
- * infernet payout list
8
+ * infernet payout request [--amount <usd>] withdraw (queued for admin approval)
9
+ * infernet payout admin list|approve|reject|settings (INFERNET_ADMIN_TOKEN)
8
10
  */
9
11
 
10
12
  import { PAYMENT_COINS, PAYMENT_COIN_CODES } from '@infernetprotocol/config/payment-coins';
13
+ import { resolveClientOptions } from '../lib/reservations-client.js';
11
14
 
12
- const HELP = `infernet payout — manage payout coin/address
15
+ const HELP = `infernet payout — earnings, withdrawals and payout address
13
16
 
14
17
  Usage:
18
+ infernet payout list Balance, recent credits, withdrawals, addresses
15
19
  infernet payout set <coin> <address> [--network <name>]
16
- infernet payout list
20
+ infernet payout request [--amount <usd>] Withdraw (default: whole available balance)
17
21
  infernet payout --help
18
22
 
23
+ Every completed job credits your node. Free (playground) jobs earn a house
24
+ subsidy per 1k output tokens, "pending approval" until the rate is approved;
25
+ paid jobs earn your share of the client's payment once it is confirmed.
26
+ Earnings accrue with or without a payout address: you only need one to
27
+ withdraw. Withdrawals are queued and sent through CoinPay after approval.
28
+
29
+ Admin (needs INFERNET_ADMIN_TOKEN or --token):
30
+ infernet payout admin list [--status requested|sending|sent|all]
31
+ infernet payout admin approve <request-id> SENDS REAL FUNDS via CoinPay
32
+ infernet payout admin reject <request-id> [--reason <text>]
33
+ infernet payout admin mark-sent <request-id> --tx <hash>
34
+ infernet payout admin mark-failed <request-id>
35
+ infernet payout admin settings [--rate <usd per 1k>] [--fee <pct>] [--min <usd>] [--approve-subsidy]
36
+
19
37
  Supported coins: ${PAYMENT_COIN_CODES.join(', ')}
20
38
  `;
21
39
 
40
+ /** Sub-cent credits must not print as $0.00. */
41
+ export function fmtUsd(n) {
42
+ const v = Number(n) || 0;
43
+ if (v === 0) return '$0.00';
44
+ if (Math.abs(v) >= 0.01) return `$${v.toFixed(2)}`;
45
+ return `$${v.toFixed(6).replace(/0+$/, '')}`;
46
+ }
47
+
48
+ const STATUS_LABEL = {
49
+ pending_approval: 'pending approval',
50
+ pending: 'awaiting client payment',
51
+ confirmed: 'confirmed',
52
+ void: 'void'
53
+ };
54
+
55
+ export function formatBalance(b = {}) {
56
+ return [
57
+ `Earnings: ${fmtUsd(b.pending_approval_usd)} pending approval, ${fmtUsd(b.pending_usd)} awaiting client payment, ${fmtUsd(b.confirmed_usd)} confirmed`,
58
+ `Payouts: ${fmtUsd(b.paid_usd)} paid, ${fmtUsd(b.requested_usd)} requested, ${fmtUsd(b.available_usd)} available to withdraw`,
59
+ `Jobs: ${b.jobs_credited ?? 0} credited`
60
+ ].join('\n');
61
+ }
62
+
22
63
  function pickNetwork(coin, requestedNetwork) {
23
64
  const upper = String(coin).toUpperCase();
24
65
  const matches = PAYMENT_COINS.filter((c) => c.code === upper);
@@ -38,6 +79,12 @@ async function runList(args, ctx) {
38
79
  return 1;
39
80
  }
40
81
 
82
+ let earnings = null;
83
+ try {
84
+ earnings = await client.earnings(Number.parseInt(args.get('limit') ?? '10', 10) || 10);
85
+ } catch (err) {
86
+ process.stderr.write(`earnings lookup failed: ${err?.message ?? err}\n`);
87
+ }
41
88
  let result;
42
89
  try {
43
90
  result = await client.listPayouts();
@@ -45,12 +92,52 @@ async function runList(args, ctx) {
45
92
  process.stderr.write(`payout list failed: ${err?.message ?? err}\n`);
46
93
  return 1;
47
94
  }
95
+
96
+ if (args.has('json')) {
97
+ process.stdout.write(JSON.stringify({ earnings, addresses: result?.rows ?? [] }, null, 2) + '\n');
98
+ return 0;
99
+ }
100
+
101
+ if (earnings) {
102
+ const cfg = earnings.config ?? {};
103
+ process.stdout.write(formatBalance(earnings.balance) + '\n');
104
+ process.stdout.write(
105
+ `Rates: free jobs ${fmtUsd(cfg.subsidy_per_1k_output_usd)}/1k output tokens` +
106
+ `${cfg.subsidy_approved ? '' : ' (pending approval)'}, house fee on paid jobs ${cfg.house_fee_pct ?? 0}%, ` +
107
+ `minimum withdrawal ${fmtUsd(cfg.min_payout_usd)}\n`
108
+ );
109
+ const recent = earnings.recent ?? [];
110
+ if (recent.length) {
111
+ process.stdout.write('\nRecent credits:\n');
112
+ for (const e of recent) {
113
+ const when = String(e.earned_at ?? '').replace('T', ' ').slice(0, 16);
114
+ process.stdout.write(
115
+ ` ${when} ${String(e.job_id).slice(0, 8)} ${(e.model_name ?? '-').padEnd(18)} ` +
116
+ `${String(e.output_tokens ?? 0).padStart(6)} tok ${fmtUsd(e.amount_usd).padStart(11)} ` +
117
+ `${e.kind} ${STATUS_LABEL[e.status] ?? e.status}\n`
118
+ );
119
+ }
120
+ }
121
+ const payouts = earnings.payouts ?? [];
122
+ if (payouts.length) {
123
+ process.stdout.write('\nWithdrawals:\n');
124
+ for (const p of payouts) {
125
+ process.stdout.write(
126
+ ` ${String(p.created_at).slice(0, 10)} ${fmtUsd(p.amount_usd)} ${p.coin} ${p.status}` +
127
+ `${p.tx_hash ? ` tx ${p.tx_hash}` : ''}${p.status === 'rejected' && p.error ? ` (${p.error})` : ''}\n`
128
+ );
129
+ }
130
+ }
131
+ process.stdout.write('\n');
132
+ }
133
+
48
134
  const rows = result?.rows ?? [];
49
135
  if (!rows.length) {
50
- process.stdout.write('(no payout addresses configured)\n');
51
- process.stdout.write('Use `infernet payout set <coin> <address>` to add one.\n');
136
+ process.stdout.write('(no payout addresses configured: earnings still accrue)\n');
137
+ process.stdout.write('Use `infernet payout set <coin> <address>` before you withdraw.\n');
52
138
  return 0;
53
139
  }
140
+ process.stdout.write('Payout addresses:\n');
54
141
  for (const row of rows) {
55
142
  const marker = row.is_default ? '* ' : ' ';
56
143
  const net = row.network ? ` (${row.network})` : '';
@@ -59,6 +146,132 @@ async function runList(args, ctx) {
59
146
  return 0;
60
147
  }
61
148
 
149
+ async function runRequest(args, ctx) {
150
+ const { config, client } = ctx;
151
+ if ((config.node?.role) !== 'provider') {
152
+ process.stderr.write('Payouts are only available to providers.\n');
153
+ return 1;
154
+ }
155
+ const raw = args.get('amount');
156
+ const amount = raw == null || raw === true ? null : Number(raw);
157
+ if (amount !== null && !(amount > 0)) {
158
+ process.stderr.write('--amount must be a positive USD amount\n');
159
+ return 1;
160
+ }
161
+ try {
162
+ const out = await client.requestPayout(amount);
163
+ const r = out?.request ?? {};
164
+ process.stdout.write(
165
+ `Requested ${fmtUsd(r.amount_usd)} to ${r.coin}${r.network ? ` (${r.network})` : ''} ${r.address}.\n` +
166
+ `Request ${r.id} is waiting for approval; \`infernet payout list\` shows its status.\n`
167
+ );
168
+ return 0;
169
+ } catch (err) {
170
+ process.stderr.write(`payout request failed: ${err?.body?.error ?? err?.message ?? err}\n`);
171
+ return 1;
172
+ }
173
+ }
174
+
175
+ async function adminCall(opts, method, path, body) {
176
+ const { baseUrl, adminToken } = await resolveClientOptions(opts);
177
+ if (!adminToken) throw new Error('set INFERNET_ADMIN_TOKEN (or pass --token)');
178
+ const res = await fetch(`${baseUrl}${path}`, {
179
+ method,
180
+ headers: {
181
+ accept: 'application/json',
182
+ authorization: `Bearer ${adminToken}`,
183
+ ...(body === undefined ? {} : { 'content-type': 'application/json' })
184
+ },
185
+ body: body === undefined ? undefined : JSON.stringify(body)
186
+ });
187
+ const text = await res.text();
188
+ let json = null;
189
+ try { json = text ? JSON.parse(text) : null; } catch { /* non-JSON */ }
190
+ if (!res.ok) throw new Error(`${method} ${path} -> HTTP ${res.status} ${json?.error ?? text.slice(0, 200)}`);
191
+ return json?.data ?? json;
192
+ }
193
+
194
+ async function runAdmin(args, positional) {
195
+ const [action, id] = positional;
196
+ const opts = {
197
+ url: args.get('url') === true ? undefined : args.get('url'),
198
+ token: args.get('token') === true ? undefined : args.get('token')
199
+ };
200
+ const enc = encodeURIComponent;
201
+ try {
202
+ if (!action || action === 'list') {
203
+ const status = args.get('status') && args.get('status') !== true ? args.get('status') : 'requested';
204
+ const data = await adminCall(opts, 'GET', `/api/v1/admin/payouts?status=${enc(status)}`);
205
+ if (args.has('json')) {
206
+ process.stdout.write(JSON.stringify(data, null, 2) + '\n');
207
+ return 0;
208
+ }
209
+ const t = data?.totals ?? {};
210
+ const tot = t.totals_usd ?? {};
211
+ process.stdout.write(
212
+ `Ledger: ${t.credits ?? 0} credits, ${t.providers ?? 0} providers; subsidy ${fmtUsd(tot['subsidy:pending_approval'])} pending approval, ` +
213
+ `${fmtUsd(tot['subsidy:confirmed'])} confirmed; paid jobs ${fmtUsd(tot['paid:pending'])} pending, ${fmtUsd(tot['paid:confirmed'])} confirmed\n`
214
+ );
215
+ const c = t.config ?? {};
216
+ process.stdout.write(
217
+ `Config: subsidy ${fmtUsd(c.subsidy_per_1k_output_usd)}/1k (${c.subsidy_approved ? 'approved' : 'NOT approved'}), fee ${c.house_fee_pct}%, minimum ${fmtUsd(c.min_payout_usd)}\n\n`
218
+ );
219
+ const rows = data?.rows ?? [];
220
+ if (!rows.length) {
221
+ process.stdout.write(`(no ${status} payout requests)\n`);
222
+ return 0;
223
+ }
224
+ for (const r of rows) {
225
+ process.stdout.write(
226
+ `${r.id} ${String(r.created_at).slice(0, 16)} ${(r.provider_name ?? r.provider_id).slice(0, 32).padEnd(32)} ` +
227
+ `${fmtUsd(r.amount_usd).padStart(10)} ${r.coin}${r.network ? `/${r.network}` : ''} ${r.address} ${r.status}` +
228
+ `${r.error ? ` (${r.error})` : ''}\n`
229
+ );
230
+ }
231
+ return 0;
232
+ }
233
+ if (action === 'settings') {
234
+ const body = {};
235
+ if (args.get('rate') != null) body.subsidy_per_1k_output_usd = Number(args.get('rate'));
236
+ if (args.get('fee') != null) body.house_fee_pct = Number(args.get('fee'));
237
+ if (args.get('min') != null) body.min_payout_usd = Number(args.get('min'));
238
+ if (args.has('approve-subsidy')) body.subsidy_approved = true;
239
+ if (args.has('unapprove-subsidy')) body.subsidy_approved = false;
240
+ const data = Object.keys(body).length
241
+ ? await adminCall(opts, 'POST', '/api/v1/admin/earnings/settings', body)
242
+ : await adminCall(opts, 'GET', '/api/v1/admin/earnings/settings');
243
+ process.stdout.write(JSON.stringify(data, null, 2) + '\n');
244
+ return 0;
245
+ }
246
+ const actions = { approve: 'approve', reject: 'reject', 'mark-sent': 'mark_sent', 'mark-failed': 'mark_failed' };
247
+ if (!actions[action]) {
248
+ process.stderr.write(`Unknown payout admin action "${action}".\n`);
249
+ return 1;
250
+ }
251
+ if (!id) {
252
+ process.stderr.write(`Usage: infernet payout admin ${action} <request-id>\n`);
253
+ return 1;
254
+ }
255
+ const body = { action: actions[action] };
256
+ if (action === 'reject' && args.get('reason') && args.get('reason') !== true) body.reason = args.get('reason');
257
+ if (action === 'mark-sent') {
258
+ const tx = args.get('tx');
259
+ if (!tx || tx === true) {
260
+ process.stderr.write('mark-sent needs --tx <hash>\n');
261
+ return 1;
262
+ }
263
+ body.tx_hash = tx;
264
+ }
265
+ const data = await adminCall(opts, 'POST', `/api/v1/admin/payouts/${enc(id)}`, body);
266
+ const r = data?.request ?? {};
267
+ process.stdout.write(`${r.id}: ${r.status}${data?.outcome ? ` (outcome ${data.outcome})` : ''}${r.tx_hash ? ` tx ${r.tx_hash}` : ''}${r.error ? ` ${r.error}` : ''}\n`);
268
+ return r.status === 'failed' ? 1 : 0;
269
+ } catch (err) {
270
+ process.stderr.write(`payout admin ${action ?? 'list'} failed: ${err?.message ?? err}\n`);
271
+ return 1;
272
+ }
273
+ }
274
+
62
275
  async function runSet(args, ctx, positional) {
63
276
  const [coinArg, addressArg] = positional;
64
277
  if (!coinArg || !addressArg) {
@@ -118,6 +331,11 @@ export default async function payout(args, ctx) {
118
331
  return runList(args, ctx);
119
332
  case 'set':
120
333
  return runSet(args, ctx, rest);
334
+ case 'request':
335
+ case 'withdraw':
336
+ return runRequest(args, ctx);
337
+ case 'admin':
338
+ return runAdmin(args, rest);
121
339
  default:
122
340
  process.stderr.write(`Unknown payout subcommand "${sub}".\n`);
123
341
  process.stderr.write(HELP);
@@ -7,6 +7,7 @@
7
7
 
8
8
  import { isDaemonAlive, sendToDaemon } from '../lib/ipc.js';
9
9
  import { formatEndpoint } from '../lib/network.js';
10
+ import { formatBalance } from './payout.js';
10
11
 
11
12
  const HELP = `infernet status — show this node's state
12
13
 
@@ -98,14 +99,11 @@ export default async function status(args, ctx) {
98
99
 
99
100
  if (node.role === 'provider') {
100
101
  try {
101
- const { rows } = await client.listPayments(100);
102
- const sum = (list) => list.reduce((a, t) => a + (Number.parseFloat(t.amount_usd) || 0), 0);
103
- const outbound = (rows ?? []).filter((t) => t.direction === 'outbound');
104
- const confirmed = outbound.filter((t) => t.status === 'confirmed');
105
- const pending = outbound.filter((t) => t.status === 'pending');
106
- process.stdout.write(
107
- `Earnings: $${sum(confirmed).toFixed(2)} confirmed, $${sum(pending).toFixed(2)} pending (USD)\n`
108
- );
102
+ const earnings = await client.earnings(1);
103
+ process.stdout.write(formatBalance(earnings?.balance) + '\n');
104
+ if (!earnings?.config?.subsidy_approved && Number(earnings?.balance?.pending_approval_usd) > 0) {
105
+ process.stdout.write(' free-job credits are pending approval of the subsidy rate; see `infernet payout list`\n');
106
+ }
109
107
  } catch (err) {
110
108
  process.stderr.write(`earnings query failed: ${err?.message ?? err}\n`);
111
109
  }
package/index.js CHANGED
@@ -171,7 +171,11 @@ async function main() {
171
171
 
172
172
  const helpRequested = args.has('help') || args.has('h');
173
173
 
174
- if (!NO_CONFIG.has(sub) && !helpRequested) {
174
+ // `infernet payout admin ...` runs on an admin's machine with only the
175
+ // admin token, not a node config.
176
+ const adminOnly = sub === 'payout' && rest[0] === 'admin';
177
+
178
+ if (!NO_CONFIG.has(sub) && !helpRequested && !adminOnly) {
175
179
  const config = await loadConfig();
176
180
  if (!config) {
177
181
  process.stderr.write(
@@ -109,6 +109,14 @@ export function createNodeClient({ url, publicKey, privateKey, role, timeoutMs =
109
109
  return signedFetch('/api/v1/node/me', { role });
110
110
  },
111
111
 
112
+ earnings(recent = 20) {
113
+ return signedFetch('/api/v1/node/earnings', { recent });
114
+ },
115
+
116
+ requestPayout(amountUsd = null) {
117
+ return signedFetch('/api/v1/node/payouts/request', amountUsd == null ? {} : { amount_usd: amountUsd });
118
+ },
119
+
112
120
  listPayments(limit = 20) {
113
121
  return signedFetch('/api/v1/node/payments/list', { role, limit });
114
122
  },
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@infernetprotocol/cli",
3
- "version": "0.1.64",
3
+ "version": "0.1.66",
4
4
  "description": "GPU-node CLI / daemon for the Infernet Protocol — register a GPU server with a Supabase control plane and start earning.",
5
5
  "license": "MIT",
6
6
  "type": "module",
@@ -30,12 +30,13 @@
30
30
  "ora": "^9.4.0",
31
31
  "react": "^17.0.2",
32
32
  "react-blessed": "^0.7.2",
33
- "@infernetprotocol/auth": "0.1.64",
34
- "@infernetprotocol/deploy-providers": "0.1.64",
35
- "@infernetprotocol/config": "0.1.64",
36
- "@infernetprotocol/engine": "0.1.64",
37
- "@infernetprotocol/gpu": "0.1.64",
38
- "@infernetprotocol/rpc-adapter": "0.1.64"
33
+ "@infernetprotocol/auth": "0.1.66",
34
+ "@infernetprotocol/config": "0.1.66",
35
+ "@infernetprotocol/engine": "0.1.66",
36
+ "@infernetprotocol/gpu": "0.1.66",
37
+ "@infernetprotocol/liquid-agent": "0.1.66",
38
+ "@infernetprotocol/rpc-adapter": "0.1.66",
39
+ "@infernetprotocol/deploy-providers": "0.1.66"
39
40
  },
40
41
  "repository": {
41
42
  "type": "git",