darkmesh-node 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+All notable changes to this package are documented in this file.
+
+## 0.1.0 - 2026-06-01
+
+- initial public operator package for DarkMesh prototype
+- add local operator account identity + persistence
+- add operator-backed node registration and binding auth
+- add operator CLI for status, jobs, earnings, service control, balance, ledger, and payout claims
+- add foreground/background worker controls
+- add internal credits and escrow-style payout claim flow

package/README.md

@@ -0,0 +1,89 @@
+![DARKSOL Banner](./assets/darksol-banner.png)
+
+# darkmesh-node
+
+Built by DARKSOL 🌑
+
+[![npm version](https://img.shields.io/npm/v/darkmesh-node.svg)](https://www.npmjs.com/package/darkmesh-node)
+[![license: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](./package.json)
+[![node >= 20](https://img.shields.io/badge/node-%3E%3D20-339933.svg)](https://nodejs.org)
+
+Operator node CLI and daemon for the DarkMesh prototype network.
+
+`darkmesh-node` gives operators a local install surface for:
+- node identity generation
+- operator account key generation
+- coordinator registration/connect flow
+- local background service control
+- status, jobs, earnings, balance, ledger, and payout-claim commands
+
+## Status
+
+This package is a **working prototype operator surface**.
+
+What is real today:
+- local operator + node identity persistence
+- operator-backed node registration
+- outbound node connectivity to a coordinator
+- routed text-job handling
+- internal credits / ledger / payout-claim flow
+- foreground + background service controls
+
+What is not real yet:
+- production coordinator hosting
+- wallet settlement
+- payout approval backend
+- full operator dashboard/admin UX
+- final verification/audit pipeline
+
+## Install
+
+```bash
+npm install -g darkmesh-node
+```
+
+## Quick Start
+
+```bash
+darkmesh init \
+  --coordinator-url http://127.0.0.1:8787 \
+  --operator-id meta \
+  --label my-node \
+  --provider memory
+
+# register / connect the node
+darkmesh connect
+
+# inspect local/operator/node state
+darkmesh whoami
+darkmesh status --pretty
+
+# run foreground worker
+darkmesh run
+```
+
+## Core commands
+
+```bash
+darkmesh init
+darkmesh whoami
+darkmesh connect
+darkmesh disconnect
+darkmesh status --pretty
+darkmesh jobs
+darkmesh earnings
+darkmesh balance
+darkmesh ledger
+darkmesh payout --amount 1 --destination wallet:demo
+darkmesh service start
+darkmesh service status
+darkmesh service stop
+```
+
+## Notes
+
+- This package is the **operator-side install surface** only.
+- The coordinator / control plane is a separate service lane.
+- Current economics are **internal credits only**.
+
+Built with teeth. 🌑

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "darkmesh-node",
+  "version": "0.1.0",
+  "private": false,
+  "description": "Operator node CLI and daemon for the DarkMesh prototype network.",
+  "license": "MIT",
+  "author": "DARKSOL",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "darkmesh": "src/cli.js"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "CHANGELOG.md",
+    "assets"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "darkmesh",
+    "cli",
+    "operator",
+    "inference",
+    "ollama",
+    "ai"
+  ],
+  "scripts": {
+    "cli": "node src/cli.js",
+    "dev": "node src/index.js",
+    "start": "node src/index.js"
+  }
+}

package/src/cli.js

@@ -0,0 +1,366 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { getDarkMeshHome } from './config.js';
+import { getServiceLogPath, openServiceLogFd } from './service.js';
+import { initNodeClient, whoAmI, fetchNodeStatus, connectNodeClient, fetchNodeJobs, fetchNodeEarnings, fetchNodeBalance, fetchNodeLedgerEvents, fetchNodeClaims, requestNodePayout, runNodeClient, disconnectNodeClient, getServiceStatus, getServiceLogs, startNodeService, stopNodeService, restartNodeService, settleNodeServiceStopped, waitForServiceStopRequest } from './client.js';
+import { saveServiceState } from './service.js';
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const command = args[0] || 'help';
+  const options = {};
+
+  for (let i = 1; i < args.length; i += 1) {
+    const token = args[i];
+    if (!token.startsWith('--')) continue;
+    const key = token.slice(2);
+    const next = args[i + 1];
+    if (!next || next.startsWith('--')) {
+      options[key] = true;
+      continue;
+    }
+    options[key] = next;
+    i += 1;
+  }
+
+  return { command, options };
+}
+
+function print(value) {
+  process.stdout.write(`${JSON.stringify(value)}\n`);
+}
+
+function printText(value = '') {
+  process.stdout.write(String(value));
+}
+
+function getHome(options) {
+  return getDarkMeshHome(options.home);
+}
+
+const selfPath = fileURLToPath(import.meta.url);
+
+function spawnServiceWorker(home) {
+  const logFd = openServiceLogFd(home);
+  const child = spawn(process.execPath, [selfPath, 'run', '--home', home, '--service-mode'], {
+    detached: true,
+    stdio: ['ignore', logFd, logFd],
+    windowsHide: true,
+    cwd: process.cwd(),
+    env: { ...process.env, DARKMESH_SERVICE_MODE: '1' }
+  });
+  child.unref();
+  return child.pid;
+}
+
+function formatNodeStatusPretty(status) {
+  const lines = [
+    `DarkMesh node: ${status.label || 'unnamed-node'}`,
+    `operator: ${status.operatorId || 'unknown'}`,
+    `coordinator: ${status.coordinatorUrl}`,
+    `registration: ${status.registrationState}`,
+    `connectivity: ${status.connectivity}`,
+    `nodeId: ${status.nodeId || 'none'}`,
+    `privacy: ${status.privacyClass}`,
+    `models: ${(status.models || []).join(', ') || 'none'}`,
+    `verified models: ${(status.verifiedModels || []).join(', ') || 'none'}`,
+    `verification: ${status.verificationStatus || 'pending'}${status.verificationReason ? ` (${status.verificationReason})` : ''}`,
+    `service: ${status.runtime?.serviceStatus || 'stopped'}${status.runtime?.servicePid ? ` (pid ${status.runtime.servicePid})` : ''}`,
+    `credits: available ${status.availableCredits || 0} | lifetime ${status.lifetimeEarnedCredits || 0}`
+  ];
+
+  if (status.health) lines.push(`health: ${status.health}`);
+  if (status.activeJobId) lines.push(`active job: ${status.activeJobId}`);
+  if (status.recentJobs?.length) lines.push(`recent jobs: ${status.recentJobs.length}`);
+  return `${lines.join('\n')}\n`;
+}
+
+async function followServiceLogs(home, options = {}) {
+  const logPath = getServiceLogPath(home);
+  const tailLines = Math.max(1, Number(options.tailLines || 50));
+  const pollMs = Math.max(50, Number(options.pollMs || 250));
+  let offset = 0;
+
+  const initial = await getServiceLogs(home, { tailLines });
+  if (initial.text) {
+    printText(`${initial.text}${initial.text.endsWith('\n') ? '' : '\n'}`);
+  }
+
+  try {
+    const raw = await fs.readFile(logPath, 'utf8');
+    offset = Buffer.byteLength(raw, 'utf8');
+  } catch (error) {
+    if (error?.code !== 'ENOENT') throw error;
+  }
+
+  let stopping = false;
+  const stop = () => {
+    stopping = true;
+  };
+
+  process.on('SIGINT', stop);
+  process.on('SIGTERM', stop);
+
+  while (!stopping) {
+    try {
+      const raw = await fs.readFile(logPath, 'utf8');
+      const size = Buffer.byteLength(raw, 'utf8');
+      if (size < offset) {
+        offset = 0;
+      }
+      if (size > offset) {
+        const next = Buffer.from(raw, 'utf8').subarray(offset).toString('utf8');
+        printText(next);
+        offset = size;
+      }
+    } catch (error) {
+      if (error?.code !== 'ENOENT') throw error;
+    }
+    await new Promise(resolve => setTimeout(resolve, pollMs));
+  }
+}
+
+async function main() {
+  const { command, options } = parseArgs(process.argv);
+  const home = getHome(options);
+
+  if (command === 'init') {
+    const result = await initNodeClient(home, {
+      coordinatorUrl: options['coordinator-url'],
+      operatorId: options['operator-id'],
+      label: options.label,
+      privacyClass: options['privacy-class'],
+      provider: {
+        type: options.provider,
+        baseUrl: options['provider-url']
+      },
+      models: options.models ? String(options.models).split(',').map(v => v.trim()).filter(Boolean) : undefined,
+      privacySecret: options['privacy-secret'] || undefined
+    });
+    print({ ok: true, command, ...result });
+    return;
+  }
+
+  if (command === 'whoami') {
+    print({ ok: true, command, ...(await whoAmI(home)) });
+    return;
+  }
+
+  if (command === 'status') {
+    const result = { ok: true, command, ...(await fetchNodeStatus(home)) };
+    if (options.pretty || options.human) {
+      printText(formatNodeStatusPretty(result));
+      return;
+    }
+    print(result);
+    return;
+  }
+
+  if (command === 'connect') {
+    const { info, config } = await connectNodeClient(home);
+    print({
+      ok: true,
+      command,
+      nodeId: info.nodeId,
+      models: info.models,
+      label: config.label,
+      operatorId: config.operatorId,
+      coordinatorUrl: config.coordinatorUrl,
+      registered: true,
+      connected: false,
+      wsPath: info.wsPath
+    });
+    return;
+  }
+
+  if (command === 'jobs') {
+    print({ ok: true, command, ...(await fetchNodeJobs(home)) });
+    return;
+  }
+
+  if (command === 'earnings') {
+    print({ ok: true, command, ...(await fetchNodeEarnings(home)) });
+    return;
+  }
+
+  if (command === 'balance') {
+    print({ ok: true, command, ...(await fetchNodeBalance(home)) });
+    return;
+  }
+
+  if (command === 'ledger') {
+    print({ ok: true, command, ...(await fetchNodeLedgerEvents(home)) });
+    return;
+  }
+
+  if (command === 'claims') {
+    print({ ok: true, command, ...(await fetchNodeClaims(home, { status: options.status })) });
+    return;
+  }
+
+  if (command === 'payout') {
+    const amountCredits = Number(options.amount || options.credits);
+    print({
+      ok: true,
+      command,
+      ...(await requestNodePayout(home, {
+        amountCredits,
+        destination: options.destination,
+        requesterId: options['requester-id']
+      }))
+    });
+    return;
+  }
+
+  if (command === 'disconnect') {
+    print({ ok: true, command, ...(await disconnectNodeClient(home)) });
+    return;
+  }
+
+  if (command === 'service') {
+    const action = options.action || options._action || process.argv[3] || 'status';
+
+    if (action === 'status') {
+      print({ ok: true, command, action, service: await getServiceStatus(home) });
+      return;
+    }
+
+    if (action === 'start') {
+      const current = await getServiceStatus(home);
+      if (current.running) {
+        print({ ok: true, command, action, alreadyRunning: true, service: current });
+        return;
+      }
+
+      const pid = spawnServiceWorker(home);
+      const result = await startNodeService(home, { pid, status: 'starting' });
+      print({
+        ok: true,
+        command,
+        action,
+        alreadyRunning: false,
+        pid,
+        logPath: getServiceLogPath(home),
+        service: result.service
+      });
+      return;
+    }
+
+    if (action === 'restart') {
+      const result = await restartNodeService(home, {
+        status: 'starting',
+        spawn: () => spawnServiceWorker(home)
+      });
+      print({
+        ok: true,
+        command,
+        action,
+        restarted: true,
+        alreadyRunning: false,
+        pid: result.service.pid,
+        logPath: getServiceLogPath(home),
+        service: result.service,
+        previouslyRunning: result.previouslyRunning
+      });
+      return;
+    }
+
+    if (action === 'logs') {
+      const tailLines = Number(options.tail || options.lines || 50);
+      if (options.follow || options.f) {
+        await followServiceLogs(home, { tailLines, pollMs: options['poll-ms'] || 250 });
+        return;
+      }
+      print({ ok: true, command, action, ...(await getServiceLogs(home, { tailLines })) });
+      return;
+    }
+
+    if (action === 'stop') {
+      print({ ok: true, command, action, ...(await stopNodeService(home)) });
+      return;
+    }
+
+    throw new Error(`service_action_unknown_${action}`);
+  }
+
+  if (command === 'run') {
+    const { node, info, config } = await runNodeClient(home);
+    let shuttingDown = false;
+    let keepAliveResolve;
+    const keepAlive = new Promise(resolve => {
+      keepAliveResolve = resolve;
+    });
+    const shutdown = async (signal = 'shutdown') => {
+      if (shuttingDown) return;
+      shuttingDown = true;
+      try {
+        await node.close();
+        if (process.env.DARKMESH_SERVICE_MODE === '1' || options['service-mode']) {
+          await settleNodeServiceStopped(home, { signal, nodeId: info.nodeId });
+        }
+      } finally {
+        keepAliveResolve?.();
+        print({ ok: true, command, nodeId: info.nodeId, signal, stopped: true });
+      }
+    };
+
+    process.on('SIGINT', () => { shutdown('SIGINT').catch(() => process.exit(1)); });
+    process.on('SIGTERM', () => { shutdown('SIGTERM').catch(() => process.exit(1)); });
+    if (process.env.DARKMESH_SERVICE_MODE === '1' || options['service-mode']) {
+      waitForServiceStopRequest(home, shutdown).catch(() => process.exit(1));
+    }
+
+    if (process.env.DARKMESH_SERVICE_MODE === '1' || options['service-mode']) {
+      await saveServiceState(home, {
+        ...(await getServiceStatus(home)),
+        pid: process.pid,
+        status: 'running',
+        startedAt: new Date().toISOString(),
+        stoppedAt: null,
+        lastNodeId: info.nodeId
+      });
+    }
+
+    print({
+      ok: true,
+      command,
+      nodeId: info.nodeId,
+      models: info.models,
+      label: config.label,
+      operatorId: config.operatorId,
+      coordinatorUrl: config.coordinatorUrl,
+      connected: true,
+      running: true
+    });
+
+    await keepAlive;
+    return;
+  }
+
+  print({
+    ok: true,
+    commands: ['init', 'whoami', 'status', 'connect', 'disconnect', 'jobs', 'earnings', 'balance', 'ledger', 'claims', 'payout', 'run', 'service'],
+    usage: {
+      init: 'darkmesh init [--home <path>] [--coordinator-url <url>] [--operator-id <id>] [--label <name>] [--provider <type>] [--provider-url <url>] [--models <csv>] [--privacy-class <class>] [--privacy-secret <secret>]',
+      whoami: 'darkmesh whoami [--home <path>]',
+      status: 'darkmesh status [--home <path>] [--pretty]',
+      connect: 'darkmesh connect [--home <path>]',
+      disconnect: 'darkmesh disconnect [--home <path>]',
+      jobs: 'darkmesh jobs [--home <path>]',
+      earnings: 'darkmesh earnings [--home <path>]',
+      balance: 'darkmesh balance [--home <path>]',
+      ledger: 'darkmesh ledger [--home <path>]',
+      claims: 'darkmesh claims [--home <path>] [--status <pending_review|approved|rejected>]',
+      payout: 'darkmesh payout --amount <credits> [--destination <wallet-or-handle>] [--home <path>]',
+      run: 'darkmesh run [--home <path>] [--service-mode]',
+      service: 'darkmesh service <status|start|stop|restart|logs> [--home <path>] [--tail <lines>] [--follow]'
+    }
+  });
+}
+
+main().catch(error => {
+  process.stderr.write(`${JSON.stringify({ ok: false, error: error.message })}\n`);
+  process.exit(1);
+});