@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 +1 -1
- package/commands/model-temporal.js +305 -0
- package/commands/model.js +11 -1
- package/commands/payout.js +224 -6
- package/commands/status.js +6 -8
- package/index.js +5 -1
- package/lib/node-client.js +8 -0
- package/package.json +8 -7
package/commands/help.js
CHANGED
|
@@ -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
|
|
package/commands/payout.js
CHANGED
|
@@ -1,24 +1,65 @@
|
|
|
1
1
|
/**
|
|
2
|
-
* `infernet payout` —
|
|
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
|
|
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 —
|
|
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
|
|
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>`
|
|
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);
|
package/commands/status.js
CHANGED
|
@@ -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
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
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
|
-
|
|
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(
|
package/lib/node-client.js
CHANGED
|
@@ -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.
|
|
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.
|
|
34
|
-
"@infernetprotocol/
|
|
35
|
-
"@infernetprotocol/
|
|
36
|
-
"@infernetprotocol/
|
|
37
|
-
"@infernetprotocol/
|
|
38
|
-
"@infernetprotocol/rpc-adapter": "0.1.
|
|
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",
|