darkmesh-node 0.1.0

package/src/client.js

@@ -0,0 +1,565 @@
+import { loadConfig, saveConfig } from './config.js';
+import { loadIdentity, ensureIdentity } from './identity.js';
+import { createOperatorBindingAuth, ensureOperatorIdentity, fetchOperatorAccount, registerOperatorAccount } from './operator.js';
+import { createProviderAdapter } from './providers.js';
+import { createId } from '../../../packages/shared/src/index.js';
+import { DarkMeshNode } from './index.js';
+import { clearServiceStopRequest, isPidRunning, loadServiceState, readServiceLog, refreshServiceState, saveServiceState, serviceStopRequested, writeServiceStopRequest } from './service.js';
+
+export async function initNodeClient(customHome, overrides = {}) {
+  const { saveConfig, getDefaultConfig } = await import('./config.js');
+  const current = await loadConfig(customHome);
+  const nextConfig = {
+    ...getDefaultConfig(customHome),
+    ...current,
+    ...overrides,
+    provider: {
+      ...current.provider,
+      ...(overrides.provider || {})
+    },
+    models: Array.isArray(overrides.models) && overrides.models.length ? overrides.models : current.models
+  };
+  const identity = await ensureIdentity(customHome);
+  const operator = await ensureOperatorIdentity(customHome, {
+    operatorId: nextConfig.operatorId,
+    label: nextConfig.label
+  });
+  await saveConfig(nextConfig, customHome);
+  return {
+    home: customHome,
+    config: nextConfig,
+    operator: {
+      operatorId: operator.operatorId,
+      label: operator.label,
+      publicKey: operator.publicKey,
+      createdAt: operator.createdAt
+    },
+    identity: {
+      publicKey: identity.publicKey,
+      createdAt: identity.createdAt
+    }
+  };
+}
+
+export async function whoAmI(customHome) {
+  const config = await loadConfig(customHome);
+  const identity = await loadIdentity(customHome);
+  const operator = await ensureOperatorIdentity(customHome, {
+    operatorId: config.operatorId,
+    label: config.label
+  });
+  return {
+    label: config.label,
+    operatorId: config.operatorId,
+    nodeId: config.nodeId,
+    coordinatorUrl: config.coordinatorUrl,
+    privacyClass: config.privacyClass,
+    models: config.models,
+    operatorAccount: {
+      operatorId: operator.operatorId,
+      label: operator.label,
+      publicKey: operator.publicKey,
+      createdAt: operator.createdAt
+    },
+    hasIdentity: Boolean(identity?.publicKey),
+    publicKey: identity?.publicKey || null,
+    identityCreatedAt: identity?.createdAt || null
+  };
+}
+
+export async function fetchNodeStatus(customHome) {
+  const config = await loadConfig(customHome);
+  const service = await refreshServiceState(customHome);
+  const baseStatus = {
+    configured: true,
+    registration: {
+      local: Boolean(config.nodeId),
+      nodeId: config.nodeId || null
+    },
+    runtime: {
+      serviceInstalled: service.installed,
+      serviceStatus: service.status,
+      serviceRunning: service.running,
+      servicePid: service.pid || null,
+      servicePidRunning: service.pidRunning || false,
+      stopRequested: service.stopRequested || false
+    },
+    coordinatorUrl: config.coordinatorUrl,
+    label: config.label,
+    operatorId: config.operatorId,
+    provider: config.provider,
+    models: config.models,
+    privacyClass: config.privacyClass,
+    availableCredits: 0,
+    lifetimeEarnedCredits: 0,
+    recentJobs: []
+  };
+
+  if (!config.nodeId) {
+    return {
+      ...baseStatus,
+      registered: false,
+      connected: false,
+      connectivity: 'unregistered',
+      registrationState: 'unregistered',
+      nodeId: null,
+      health: null
+    };
+  }
+
+  const res = await fetch(`${config.coordinatorUrl}/v1/nodes/${encodeURIComponent(config.nodeId)}`);
+  if (res.status === 404) {
+    return {
+      ...baseStatus,
+      registered: false,
+      connected: false,
+      connectivity: 'not_found',
+      registrationState: 'stale_local_registration',
+      nodeId: config.nodeId,
+      health: null
+    };
+  }
+
+  if (!res.ok) throw new Error(`status_fetch_failed_${res.status}`);
+  const data = await res.json();
+  const coordinatorConnected = Boolean(data.status.connected);
+  const registrationState = coordinatorConnected ? 'registered' : 'registered_offline';
+  return {
+    ...baseStatus,
+    registered: true,
+    connected: coordinatorConnected,
+    connectivity: coordinatorConnected ? 'connected' : 'offline',
+    registrationState,
+    nodeId: data.node.id,
+    label: data.node.label,
+    operatorId: data.node.operatorId,
+    provider: {
+      type: data.node.providerType || data.node.provider || config.provider.type,
+      baseUrl: config.provider.baseUrl
+    },
+    models: data.node.models || config.models,
+    verifiedModels: data.node.verifiedModels || [],
+    rejectedModels: data.node.rejectedModels || [],
+    verificationStatus: data.node.verificationStatus || 'pending',
+    verificationReason: data.node.verificationReason || null,
+    lastVerifiedAt: data.node.lastVerifiedAt || null,
+    privacyClass: data.node.privacyClass,
+    health: data.node.health,
+    activeJobId: data.status.activeJobId,
+    availableCredits: data.status.availableCredits,
+    lifetimeEarnedCredits: data.status.lifetimeEarnedCredits,
+    recentJobs: data.status.recentJobs || []
+  };
+}
+
+export async function connectNodeClient(customHome) {
+  const config = await loadConfig(customHome);
+  const identity = await ensureIdentity(customHome);
+  const operator = await ensureOperatorIdentity(customHome, {
+    operatorId: config.operatorId,
+    label: config.label
+  });
+  const adapter = createProviderAdapter({
+    providerType: config.provider.type,
+    baseUrl: config.provider.baseUrl,
+    model: config.models?.[0],
+    models: config.models
+  });
+
+  const models = await adapter.listModels();
+  const requestedNodeId = config.nodeId || createId('node');
+  let operatorAccount = await fetchOperatorAccount({
+    coordinatorUrl: config.coordinatorUrl,
+    operatorId: operator.operatorId
+  });
+  if (!operatorAccount) {
+    const registered = await registerOperatorAccount({
+      coordinatorUrl: config.coordinatorUrl,
+      operator
+    });
+    operatorAccount = registered.operator;
+  }
+  const operatorAuth = await createOperatorBindingAuth({
+    coordinatorUrl: config.coordinatorUrl,
+    operator,
+    nodeId: requestedNodeId,
+    nodePublicKey: identity.publicKey,
+    label: config.label
+  });
+  const res = await fetch(`${config.coordinatorUrl}/v1/nodes/register`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({
+      nodeId: requestedNodeId,
+      operatorId: config.operatorId,
+      label: config.label,
+      publicKey: identity.publicKey,
+      privacyClass: config.privacyClass,
+      operatorAuth
+    })
+  });
+  if (!res.ok) throw new Error(`node_register_failed_${res.status}`);
+  const data = await res.json();
+  config.nodeId = data.nodeId;
+  await saveConfig(config, customHome);
+  return {
+    info: {
+      nodeId: data.nodeId,
+      models,
+      wsPath: data.wsPath,
+      operatorAccount
+    },
+    config
+  };
+}
+
+export async function fetchNodeJobs(customHome) {
+  const status = await fetchNodeStatus(customHome);
+  return {
+    nodeId: status.nodeId,
+    activeJobId: status.activeJobId || null,
+    jobs: status.recentJobs || []
+  };
+}
+
+export async function fetchNodeEarnings(customHome) {
+  const status = await fetchNodeStatus(customHome);
+  const completedJobs = (status.recentJobs || []).filter(job => job.status === 'completed');
+  return {
+    nodeId: status.nodeId,
+    availableCredits: status.availableCredits || 0,
+    lifetimeEarnedCredits: status.lifetimeEarnedCredits || 0,
+    completedJobs: completedJobs.length,
+    recentPayouts: completedJobs.map(job => ({
+      jobId: job.id,
+      payoutCredits: job.payoutCredits,
+      completedAt: job.completedAt
+    }))
+  };
+}
+
+export async function fetchNodeBalance(customHome) {
+  const config = await loadConfig(customHome);
+  if (!config.nodeId) {
+    return {
+      nodeId: null,
+      availableCredits: 0,
+      escrowCredits: 0,
+      lifetimeEarnedCredits: 0,
+      uptimeCredits: 0,
+      jobCredits: 0
+    };
+  }
+
+  const res = await fetch(`${config.coordinatorUrl}/v1/ledger/balance?nodeId=${encodeURIComponent(config.nodeId)}`);
+  if (!res.ok) throw new Error(`balance_fetch_failed_${res.status}`);
+  const data = await res.json();
+  return data.balance;
+}
+
+export async function fetchNodeLedgerEvents(customHome) {
+  const config = await loadConfig(customHome);
+  if (!config.nodeId) {
+    return {
+      nodeId: null,
+      entries: []
+    };
+  }
+
+  const res = await fetch(`${config.coordinatorUrl}/v1/ledger/events?nodeId=${encodeURIComponent(config.nodeId)}`);
+  if (!res.ok) throw new Error(`ledger_events_fetch_failed_${res.status}`);
+  const data = await res.json();
+  return {
+    nodeId: config.nodeId,
+    entries: data.entries || []
+  };
+}
+
+export async function fetchNodeClaims(customHome, options = {}) {
+  const config = await loadConfig(customHome);
+  if (!config.nodeId) {
+    return {
+      nodeId: null,
+      claims: []
+    };
+  }
+
+  const params = new URLSearchParams({ nodeId: config.nodeId });
+  if (options.status) params.set('status', options.status);
+  const res = await fetch(`${config.coordinatorUrl}/v1/ledger/claims?${params.toString()}`);
+  if (!res.ok) throw new Error(`claims_fetch_failed_${res.status}`);
+  const data = await res.json();
+  return {
+    nodeId: config.nodeId,
+    claims: data.claims || []
+  };
+}
+
+export async function reviewNodeClaim(customHome, claimId, options = {}) {
+  const config = await loadConfig(customHome);
+  if (!config.nodeId) throw new Error('node_not_registered');
+  if (!claimId) throw new Error('claim_id_required');
+  const action = options.action === 'approve' ? 'approve' : options.action === 'reject' ? 'reject' : null;
+  if (!action) throw new Error('invalid_claim_review_action');
+
+  const res = await fetch(`${config.coordinatorUrl}/v1/ledger/claims/${encodeURIComponent(claimId)}/review`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({
+      action,
+      reviewerId: options.reviewerId || config.operatorId || null,
+      requesterId: options.requesterId || config.operatorId || null,
+      reason: options.reason || null
+    })
+  });
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error || `claim_review_failed_${res.status}`);
+  return data;
+}
+
+export async function requestNodePayout(customHome, options = {}) {
+  const config = await loadConfig(customHome);
+  if (!config.nodeId) throw new Error('node_not_registered');
+  const amountCredits = Number(options.amountCredits);
+  if (!Number.isFinite(amountCredits) || amountCredits <= 0) throw new Error('invalid_claim_amount');
+
+  const res = await fetch(`${config.coordinatorUrl}/v1/ledger/claims/request`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({
+      nodeId: config.nodeId,
+      amountCredits,
+      destination: options.destination || null,
+      requesterId: options.requesterId || config.operatorId || null
+    })
+  });
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error || `claim_request_failed_${res.status}`);
+  return data;
+}
+
+export async function createRuntimeNode(customHome) {
+  const config = await loadConfig(customHome);
+  const identity = await ensureIdentity(customHome);
+  const operator = await ensureOperatorIdentity(customHome, {
+    operatorId: config.operatorId,
+    label: config.label
+  });
+  const adapter = createProviderAdapter({
+    providerType: config.provider.type,
+    baseUrl: config.provider.baseUrl,
+    model: config.models?.[0],
+    models: config.models
+  });
+
+  const node = new DarkMeshNode({
+    coordinatorBaseUrl: config.coordinatorUrl,
+    operatorId: config.operatorId,
+    label: config.label,
+    privacyClass: config.privacyClass,
+    privacySecret: config.privacySecret,
+    keyPair: {
+      publicKey: identity.publicKey,
+      privateKey: identity.privateKey
+    },
+    operatorKeyPair: {
+      publicKey: operator.publicKey,
+      privateKey: operator.privateKey
+    },
+    nodeId: config.nodeId,
+    adapter
+  });
+
+  return { node, config };
+}
+
+export async function runNodeClient(customHome) {
+  const { node, config } = await createRuntimeNode(customHome);
+  const info = await node.connect();
+  if (config.nodeId !== info.nodeId) {
+    config.nodeId = info.nodeId;
+    await saveConfig(config, customHome);
+  }
+  return { node, info, config };
+}
+
+export async function disconnectNodeClient(customHome, options = {}) {
+  const config = await loadConfig(customHome);
+  if (!config.nodeId) {
+    return {
+      nodeId: null,
+      disconnected: true,
+      changed: false,
+      reason: 'not_registered'
+    };
+  }
+
+  const current = await fetchNodeStatus(customHome);
+  const wasRegistered = current.registered;
+  const wasConnected = current.connected;
+  config.nodeId = null;
+  await saveConfig(config, customHome);
+
+  return {
+    nodeId: current.nodeId,
+    disconnected: true,
+    changed: wasRegistered,
+    wasConnected,
+    preserveRemoteRegistration: Boolean(options.preserveRemoteRegistration),
+    reason: wasRegistered ? 'local_registration_cleared' : 'already_unregistered'
+  };
+}
+
+export async function getServiceStatus(customHome) {
+  return refreshServiceState(customHome);
+}
+
+export async function getServiceLogs(customHome, options = {}) {
+  return readServiceLog(customHome, options);
+}
+
+export async function startNodeService(customHome, options = {}) {
+  const state = await refreshServiceState(customHome);
+  if (state.running) {
+    return {
+      alreadyRunning: true,
+      service: state
+    };
+  }
+
+  await clearServiceStopRequest(customHome);
+  const nextState = await saveServiceState(customHome, {
+    ...state,
+    pid: options.pid || state.pid || null,
+    status: options.status || 'starting',
+    startedAt: state.startedAt || new Date().toISOString(),
+    stoppedAt: null
+  });
+
+  return {
+    alreadyRunning: false,
+    service: nextState
+  };
+}
+
+export async function restartNodeService(customHome, options = {}) {
+  const before = await refreshServiceState(customHome);
+  const stopped = await stopNodeService(customHome);
+  if (stopped.running) {
+    throw new Error('service_restart_failed_to_stop');
+  }
+  const pid = typeof options.spawn === 'function'
+    ? await options.spawn()
+    : (options.pid || null);
+  return {
+    restarted: true,
+    previouslyRunning: before.running,
+    stop: stopped,
+    ...await startNodeService(customHome, { ...options, pid })
+  };
+}
+
+export async function stopNodeService(customHome) {
+  const state = await refreshServiceState(customHome);
+  if (!state.installed || !state.pid) {
+    await saveServiceState(customHome, {
+      ...(await loadServiceState(customHome) || {}),
+      status: 'stopped',
+      pid: null,
+      stoppedAt: new Date().toISOString()
+    });
+    return {
+      requested: false,
+      running: false,
+      signalSent: false,
+      service: await refreshServiceState(customHome)
+    };
+  }
+
+  if (state.pidRunning === false) {
+    await saveServiceState(customHome, {
+      ...(await loadServiceState(customHome) || {}),
+      status: 'stopped',
+      pid: null,
+      stoppedAt: new Date().toISOString()
+    });
+    await clearServiceStopRequest(customHome);
+    return {
+      requested: false,
+      running: false,
+      signalSent: false,
+      service: await refreshServiceState(customHome)
+    };
+  }
+
+  await writeStopAndSignal(customHome, state.pid);
+  await saveServiceState(customHome, {
+    ...state,
+    status: 'stopping'
+  });
+
+  const stopped = await waitForPidExit(state.pid, 5000, 50);
+  if (stopped) {
+    await saveServiceState(customHome, {
+      ...(await loadServiceState(customHome) || {}),
+      status: 'stopped',
+      pid: null,
+      stoppedAt: new Date().toISOString()
+    });
+    await clearServiceStopRequest(customHome);
+    return {
+      requested: true,
+      running: false,
+      signalSent: true,
+      service: await refreshServiceState(customHome)
+    };
+  }
+
+  const next = await refreshServiceState(customHome);
+  return {
+    requested: true,
+    running: true,
+    signalSent: true,
+    service: next
+  };
+}
+
+async function writeStopAndSignal(customHome, pid) {
+  await writeServiceStopRequest(customHome);
+  try {
+    process.kill(pid, 'SIGTERM');
+  } catch {
+    // stale pid; refreshServiceState will normalize later
+  }
+}
+
+export async function settleNodeServiceStopped(customHome, details = {}) {
+  await saveServiceState(customHome, {
+    ...(await loadServiceState(customHome) || {}),
+    pid: null,
+    status: 'stopped',
+    stoppedAt: new Date().toISOString(),
+    lastSignal: details.signal || 'shutdown',
+    lastNodeId: details.nodeId || null
+  });
+  await clearServiceStopRequest(customHome);
+}
+
+export async function waitForServiceStopRequest(customHome, signalHandler, pollMs = 250) {
+  while (true) {
+    if (await serviceStopRequested(customHome)) {
+      await signalHandler('service_stop_request');
+      return;
+    }
+    await new Promise(resolve => setTimeout(resolve, pollMs));
+  }
+}
+
+async function waitForPidExit(pid, timeoutMs = 5000, intervalMs = 50) {
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    if (!isPidRunning(pid)) return true;
+    await new Promise(resolve => setTimeout(resolve, intervalMs));
+  }
+  return !isPidRunning(pid);
+}

package/src/config.js

@@ -0,0 +1,64 @@
+import fs from 'fs/promises';
+import os from 'os';
+import path from 'path';
+import { JsonFileStore } from '../../../packages/shared/src/store.js';
+
+export function getDarkMeshHome(customHome) {
+  return customHome || process.env.DARKMESH_HOME || path.join(os.homedir(), '.darkmesh');
+}
+
+export function getDefaultConfig(customHome) {
+  return {
+    coordinatorUrl: 'http://127.0.0.1:8787',
+    operatorId: 'operator-local',
+    label: 'darkmesh-node',
+    provider: {
+      type: 'ollama',
+      baseUrl: 'http://127.0.0.1:11434/v1'
+    },
+    models: ['qwen3:latest'],
+    privacyClass: 'class-a-public-safe',
+    privacySecret: null,
+    nodeId: null
+  };
+}
+
+export function getConfigPath(customHome) {
+  return path.join(getDarkMeshHome(customHome), 'config.json');
+}
+
+export function getIdentityPath(customHome) {
+  return path.join(getDarkMeshHome(customHome), 'identity.json');
+}
+
+export function getOperatorIdentityPath(customHome) {
+  return path.join(getDarkMeshHome(customHome), 'operator.json');
+}
+
+export function createConfigStore(customHome) {
+  return new JsonFileStore(getConfigPath(customHome));
+}
+
+export async function loadConfig(customHome) {
+  const store = createConfigStore(customHome);
+  const loaded = await store.load(getDefaultConfig(customHome));
+  return {
+    ...getDefaultConfig(customHome),
+    ...loaded,
+    provider: {
+      ...getDefaultConfig(customHome).provider,
+      ...(loaded.provider || {})
+    },
+    models: Array.isArray(loaded.models) && loaded.models.length ? loaded.models : getDefaultConfig(customHome).models
+  };
+}
+
+export async function saveConfig(config, customHome) {
+  const store = createConfigStore(customHome);
+  await store.save(config);
+  return config;
+}
+
+export async function ensureDarkMeshHome(customHome) {
+  await fs.mkdir(getDarkMeshHome(customHome), { recursive: true });
+}

package/src/identity.js

@@ -0,0 +1,26 @@
+import { createKeyPair } from '../../../packages/shared/src/index.js';
+import { JsonFileStore } from '../../../packages/shared/src/store.js';
+import { ensureDarkMeshHome, getIdentityPath } from './config.js';
+
+function createIdentityStore(customHome) {
+  return new JsonFileStore(getIdentityPath(customHome));
+}
+
+export async function loadIdentity(customHome) {
+  const store = createIdentityStore(customHome);
+  return store.load(null);
+}
+
+export async function ensureIdentity(customHome) {
+  await ensureDarkMeshHome(customHome);
+  const store = createIdentityStore(customHome);
+  const existing = await store.load(null);
+  if (existing?.publicKey && existing?.privateKey) return existing;
+  const keyPair = createKeyPair();
+  const identity = {
+    ...keyPair,
+    createdAt: new Date().toISOString()
+  };
+  await store.save(identity);
+  return identity;
+}