darkmesh-node 0.1.0

package/src/index.js

@@ -0,0 +1,400 @@
+import http from 'http';
+import { createEnvelope, EVENT_TYPES } from '../../../packages/protocol/src/index.js';
+import { createId, createKeyPair, createProviderFingerprintHash, decryptFromCoordinator, nowIso, safeJsonParse, signPayload } from '../../../packages/shared/src/index.js';
+import { createOperatorBindingAuth } from './operator.js';
+
+export class MemoryProviderAdapter {
+  constructor(models = ['qwen3:latest'], options = {}) {
+    this.provider = 'memory-provider';
+    this.providerType = 'memory';
+    this.models = models;
+    this.delayMs = options.delayMs || 0;
+  }
+
+  async listModels() {
+    return this.models;
+  }
+
+  async getFingerprint() {
+    return {
+      providerType: this.providerType,
+      providerLabel: this.provider,
+      models: this.models,
+      transport: 'in-memory'
+    };
+  }
+
+  async generate({ prompt, model, signal }) {
+    if (this.delayMs > 0) {
+      await abortableDelay(this.delayMs, signal);
+    }
+    if (signal?.aborted) {
+      throw new Error('job_cancelled');
+    }
+    return {
+      model,
+      output: `[${model}] ${prompt}`
+    };
+  }
+
+  async runChallenge({ prompt, expectedModel, signal }) {
+    const result = await this.generate({ prompt, model: expectedModel || this.models[0], signal });
+    return {
+      model: result.model,
+      output: result.output
+    };
+  }
+}
+
+export class OpenAICompatibleAdapter {
+  constructor({ baseUrl, model = 'qwen3:latest', providerLabel = 'openai-compatible', headers = {} }) {
+    this.baseUrl = baseUrl.replace(/\/$/, '');
+    this.provider = providerLabel;
+    this.providerType = 'openai-compatible';
+    this.defaultModel = model;
+    this.headers = headers;
+  }
+
+  async listModels() {
+    const res = await fetch(`${this.baseUrl}/models`, { headers: this.headers });
+    if (!res.ok) throw new Error(`model_list_failed_${res.status}`);
+    const data = await res.json();
+    return (data.data || []).map(item => item.id);
+  }
+
+  async getFingerprint() {
+    const models = await this.listModels();
+    return {
+      providerType: this.providerType,
+      providerLabel: this.provider,
+      baseUrl: this.baseUrl,
+      defaultModel: this.defaultModel,
+      models,
+      authMode: Object.keys(this.headers || {}).length ? 'custom-headers' : 'none'
+    };
+  }
+
+  async generate({ prompt, model, signal }) {
+    const res = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', ...this.headers },
+      body: JSON.stringify({
+        model: model || this.defaultModel,
+        messages: [{ role: 'user', content: prompt }],
+        stream: false
+      }),
+      signal
+    });
+    if (!res.ok) throw new Error(`generation_failed_${res.status}`);
+    const data = await res.json();
+    return {
+      model: data.model || model || this.defaultModel,
+      output: data.choices?.[0]?.message?.content || ''
+    };
+  }
+
+  async runChallenge({ prompt, expectedModel, signal }) {
+    const result = await this.generate({ prompt, model: expectedModel || this.defaultModel, signal });
+    return {
+      model: result.model,
+      output: result.output
+    };
+  }
+}
+
+function abortableDelay(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new Error('job_cancelled'));
+      return;
+    }
+    const timer = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      cleanup();
+      reject(new Error('job_cancelled'));
+    };
+    const cleanup = () => signal?.removeEventListener('abort', onAbort);
+    signal?.addEventListener('abort', onAbort, { once: true });
+  });
+}
+
+export class DarkMeshNode {
+  constructor(options = {}) {
+    const operatorIdExplicit = Object.prototype.hasOwnProperty.call(options, 'operatorId');
+    this.options = {
+      coordinatorBaseUrl: 'http://127.0.0.1:8787',
+      operatorId: 'operator-local',
+      label: createId('node-label'),
+      adapter: new MemoryProviderAdapter(),
+      requestedModel: null,
+      privacyClass: 'class-a-public-safe',
+      privacySecret: null,
+      heartbeatIntervalMs: 500,
+      ...options
+    };
+    this.keyPair = this.options.keyPair || createKeyPair();
+    if (!operatorIdExplicit && this.options.operatorId === 'operator-local') {
+      this.options.operatorId = createId('operator');
+    }
+    this.operatorKeyPair = this.options.operatorKeyPair || this.keyPair;
+    this.nodeId = this.options.nodeId || null;
+    this.wsPath = this.options.wsPath || null;
+    this.request = null;
+    this.socket = null;
+    this.response = null;
+    this.buffer = '';
+    this.activeJobs = new Map();
+    this.heartbeatTimer = null;
+  }
+
+  async register() {
+    if (this.operatorKeyPair?.publicKey) {
+      const operatorRegisterRes = await fetch(`${this.options.coordinatorBaseUrl}/v1/operators/register`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+          operatorId: this.options.operatorId,
+          label: this.options.label,
+          publicKey: this.operatorKeyPair.publicKey
+        })
+      });
+      if (!operatorRegisterRes.ok && operatorRegisterRes.status !== 200 && operatorRegisterRes.status !== 201) {
+        throw new Error(`operator_register_failed_${operatorRegisterRes.status}`);
+      }
+    }
+
+    const operatorAuth = this.operatorKeyPair
+      ? await createOperatorBindingAuth({
+          coordinatorUrl: this.options.coordinatorBaseUrl,
+          operator: {
+            operatorId: this.options.operatorId,
+            label: this.options.label,
+            publicKey: this.operatorKeyPair.publicKey,
+            privateKey: this.operatorKeyPair.privateKey
+          },
+          nodeId: this.nodeId,
+          nodePublicKey: this.keyPair.publicKey,
+          label: this.options.label
+        })
+      : null;
+    const res = await fetch(`${this.options.coordinatorBaseUrl}/v1/nodes/register`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({
+        nodeId: this.nodeId,
+        operatorId: this.options.operatorId,
+        label: this.options.label,
+        publicKey: this.keyPair.publicKey,
+        privacyClass: this.options.privacyClass,
+        operatorAuth
+      })
+    });
+    if (!res.ok) throw new Error(`node_register_failed_${res.status}`);
+    const data = await res.json();
+    this.nodeId = data.nodeId;
+    this.wsPath = data.wsPath;
+    return data;
+  }
+
+  async connect() {
+    if (!this.nodeId || !this.wsPath) await this.register();
+    const url = new URL(this.wsPath, this.options.coordinatorBaseUrl);
+    await this.openSocket(url);
+    const models = await this.options.adapter.listModels();
+    const fingerprint = this.options.adapter.getFingerprint
+      ? await this.options.adapter.getFingerprint()
+      : {
+          providerType: this.options.adapter.providerType,
+          providerLabel: this.options.adapter.provider,
+          models
+        };
+    const providerFingerprint = {
+      ...fingerprint,
+      models
+    };
+    const claim = {
+      nodeId: this.nodeId,
+      operatorId: this.options.operatorId,
+      provider: this.options.adapter.provider,
+      providerType: this.options.adapter.providerType,
+      privacyClass: this.options.privacyClass,
+      models,
+      providerFingerprintHash: createProviderFingerprintHash(providerFingerprint),
+      timestamp: nowIso()
+    };
+    const signature = signPayload(this.keyPair.privateKey, JSON.stringify(claim));
+    this.send(createEnvelope(EVENT_TYPES.NODE_HELLO, {
+      claim,
+      provider: this.options.adapter.provider,
+      providerType: this.options.adapter.providerType,
+      privacyClass: this.options.privacyClass,
+      models,
+      providerFingerprint,
+      signature
+    }));
+    this.send(createEnvelope(EVENT_TYPES.NODE_MODELS, {
+      provider: this.options.adapter.provider,
+      providerType: this.options.adapter.providerType,
+      privacyClass: this.options.privacyClass,
+      models,
+      providerFingerprint
+    }));
+    this.send(createEnvelope(EVENT_TYPES.NODE_PRIVACY_CAPS, {
+      privacyClass: this.options.privacyClass,
+      protectedTransport: Boolean(this.options.privacySecret)
+    }));
+    this.startHeartbeatLoop();
+    return { nodeId: this.nodeId, models };
+  }
+
+  startHeartbeatLoop() {
+    this.stopHeartbeatLoop();
+    this.send(createEnvelope(EVENT_TYPES.NODE_HEARTBEAT, { nodeId: this.nodeId }));
+    this.heartbeatTimer = setInterval(() => {
+      if (!this.request || this.request.destroyed) return;
+      this.send(createEnvelope(EVENT_TYPES.NODE_HEARTBEAT, { nodeId: this.nodeId }));
+    }, this.options.heartbeatIntervalMs);
+  }
+
+  stopHeartbeatLoop() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+
+  async openSocket(url) {
+    return new Promise((resolve, reject) => {
+      const req = http.request({
+        hostname: url.hostname,
+        port: url.port,
+        path: url.pathname + url.search,
+        method: 'POST',
+        headers: {
+          'content-type': 'application/x-ndjson'
+        }
+      });
+      this.request = req;
+      req.on('response', res => {
+        this.response = res;
+        res.setEncoding('utf8');
+        res.on('data', chunk => this.onData(chunk));
+        res.on('error', reject);
+        this.socket = req.socket;
+        resolve();
+      });
+      req.on('error', reject);
+      req.flushHeaders();
+    });
+  }
+
+  onData(chunk) {
+    this.buffer += chunk;
+    let index;
+    while ((index = this.buffer.indexOf('\n')) >= 0) {
+      const raw = this.buffer.slice(0, index).trim();
+      this.buffer = this.buffer.slice(index + 1);
+      if (!raw) continue;
+      const message = safeJsonParse(raw);
+      if (!message) continue;
+      this.handleMessage(message).catch(error => {
+        if (message?.payload?.jobId) {
+          this.send(createEnvelope(EVENT_TYPES.JOB_FAIL, { jobId: message.payload.jobId, error: error.message }));
+        }
+      });
+    }
+  }
+
+  async handleMessage(message) {
+    if (message.type === EVENT_TYPES.SESSION_READY) return;
+
+    if (message.type === EVENT_TYPES.NODE_RUNTIME_CHALLENGE) {
+      const payload = message.payload || {};
+      const challengeId = payload.challengeId;
+      const controller = new AbortController();
+      try {
+        const proof = this.options.adapter.runChallenge
+          ? await this.options.adapter.runChallenge({
+              prompt: payload.prompt,
+              expectedModel: payload.expectedModel,
+              signal: controller.signal
+            })
+          : await this.options.adapter.generate({
+              prompt: payload.prompt,
+              model: payload.expectedModel,
+              signal: controller.signal
+            });
+
+        this.send(createEnvelope(EVENT_TYPES.NODE_RUNTIME_PROOF, {
+          challengeId,
+          model: proof.model,
+          output: proof.output
+        }));
+      } catch (error) {
+        this.send(createEnvelope(EVENT_TYPES.NODE_RUNTIME_PROOF, {
+          challengeId,
+          error: error.message || 'runtime_challenge_failed'
+        }));
+      }
+      return;
+    }
+
+    if (message.type === EVENT_TYPES.JOB_CANCEL) {
+      const active = this.activeJobs.get(message.payload.jobId);
+      if (active) active.controller.abort();
+      return;
+    }
+
+    if (message.type === EVENT_TYPES.JOB_ASSIGN) {
+      this.send(createEnvelope(EVENT_TYPES.JOB_ACCEPT, { jobId: message.payload.jobId }));
+      const controller = new AbortController();
+      this.activeJobs.set(message.payload.jobId, { controller });
+      try {
+        let prompt = message.payload.prompt;
+        if (message.payload.protectedPayload) {
+          if (!this.options.privacySecret) {
+            throw new Error('protected_payload_not_supported');
+          }
+          prompt = decryptFromCoordinator(message.payload.protectedPayload, this.options.privacySecret);
+        }
+        const result = await this.options.adapter.generate({
+          prompt,
+          model: message.payload.requestedModel,
+          signal: controller.signal
+        });
+        if (controller.signal.aborted) {
+          this.send(createEnvelope(EVENT_TYPES.JOB_FAIL, { jobId: message.payload.jobId, error: 'job_cancelled' }));
+          return;
+        }
+        this.send(createEnvelope(EVENT_TYPES.JOB_COMPLETE, { jobId: message.payload.jobId, result }));
+      } catch (error) {
+        this.send(createEnvelope(EVENT_TYPES.JOB_FAIL, { jobId: message.payload.jobId, error: error.message }));
+      } finally {
+        this.activeJobs.delete(message.payload.jobId);
+      }
+    }
+  }
+
+  send(message) {
+    if (!this.request || this.request.destroyed) throw new Error('node_connection_not_open');
+    this.request.write(JSON.stringify(message) + '\n');
+  }
+
+  async close() {
+    this.stopHeartbeatLoop();
+    for (const active of this.activeJobs.values()) active.controller.abort();
+    this.activeJobs.clear();
+    if (this.request && !this.request.destroyed) this.request.destroy();
+    if (this.response && !this.response.destroyed) this.response.destroy();
+    if (this.socket && !this.socket.destroyed) this.socket.destroy();
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const node = new DarkMeshNode();
+  node.connect().then(info => console.log(JSON.stringify({ ok: true, ...info }, null, 2)));
+}

package/src/operator.js

@@ -0,0 +1,113 @@
+import { createKeyPair, nowIso, signPayload } from '../../../packages/shared/src/index.js';
+import { JsonFileStore } from '../../../packages/shared/src/store.js';
+import { ensureDarkMeshHome, getOperatorIdentityPath } from './config.js';
+
+function createOperatorStore(customHome) {
+  return new JsonFileStore(getOperatorIdentityPath(customHome));
+}
+
+export async function loadOperatorIdentity(customHome) {
+  const store = createOperatorStore(customHome);
+  return store.load(null);
+}
+
+export async function ensureOperatorIdentity(customHome, overrides = {}) {
+  await ensureDarkMeshHome(customHome);
+  const store = createOperatorStore(customHome);
+  const existing = await store.load(null);
+  const operatorId = overrides.operatorId || existing?.operatorId || 'operator-local';
+  const label = overrides.label || existing?.label || operatorId;
+
+  if (existing?.publicKey && existing?.privateKey && existing.operatorId === operatorId) {
+    const next = {
+      ...existing,
+      label,
+      operatorId,
+      updatedAt: nowIso()
+    };
+    await store.save(next);
+    return next;
+  }
+
+  const keyPair = createKeyPair();
+  const createdAt = nowIso();
+  const identity = {
+    operatorId,
+    label,
+    publicKey: keyPair.publicKey,
+    privateKey: keyPair.privateKey,
+    createdAt,
+    updatedAt: createdAt
+  };
+  await store.save(identity);
+  return identity;
+}
+
+export function buildOperatorBindingPayload({ operatorId, nodeId, nodePublicKey, label, challengeId, timestamp, nonce }) {
+  return JSON.stringify({
+    action: 'bind_node',
+    operatorId,
+    nodeId,
+    nodePublicKey,
+    label: label || null,
+    challengeId,
+    timestamp,
+    nonce
+  });
+}
+
+export async function registerOperatorAccount({ coordinatorUrl, operator }) {
+  const res = await fetch(`${coordinatorUrl}/v1/operators/register`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({
+      operatorId: operator.operatorId,
+      label: operator.label,
+      publicKey: operator.publicKey
+    })
+  });
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error || `operator_register_failed_${res.status}`);
+  return data;
+}
+
+export async function fetchOperatorAccount({ coordinatorUrl, operatorId }) {
+  const res = await fetch(`${coordinatorUrl}/v1/operators/${encodeURIComponent(operatorId)}`);
+  if (res.status === 404) return null;
+  const data = await res.json();
+  if (!res.ok) throw new Error(data.error || `operator_fetch_failed_${res.status}`);
+  return data.operator || null;
+}
+
+export async function createOperatorBindingAuth({ coordinatorUrl, operator, nodeId, nodePublicKey, label }) {
+  const challengeRes = await fetch(`${coordinatorUrl}/v1/operators/bind-challenge`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({
+      operatorId: operator.operatorId,
+      nodeId,
+      nodePublicKey,
+      label: label || null
+    })
+  });
+  const challengeData = await challengeRes.json();
+  if (!challengeRes.ok) throw new Error(challengeData.error || `operator_bind_challenge_failed_${challengeRes.status}`);
+
+  const payload = buildOperatorBindingPayload({
+    operatorId: operator.operatorId,
+    nodeId,
+    nodePublicKey,
+    label: label || null,
+    challengeId: challengeData.challengeId,
+    timestamp: challengeData.timestamp,
+    nonce: challengeData.nonce
+  });
+
+  return {
+    operatorId: operator.operatorId,
+    challengeId: challengeData.challengeId,
+    timestamp: challengeData.timestamp,
+    nonce: challengeData.nonce,
+    signature: signPayload(operator.privateKey, payload)
+  };
+}

package/src/providers.js

@@ -0,0 +1,19 @@
+import { MemoryProviderAdapter, OpenAICompatibleAdapter } from './index.js';
+
+export function createProviderAdapter(options = {}) {
+  const providerType = options.providerType || 'memory';
+
+  if (providerType === 'memory') {
+    return new MemoryProviderAdapter(options.models || ['qwen3:latest']);
+  }
+
+  if (providerType === 'openai-compatible' || providerType === 'ollama') {
+    return new OpenAICompatibleAdapter({
+      baseUrl: options.baseUrl || 'http://127.0.0.1:11434/v1',
+      model: options.model || 'qwen3:latest',
+      providerLabel: providerType
+    });
+  }
+
+  throw new Error(`unsupported_provider_${providerType}`);
+}

package/src/service.js

@@ -0,0 +1,148 @@
+import fs from 'fs';
+import fsPromises from 'fs/promises';
+import path from 'path';
+import { ensureDarkMeshHome, getDarkMeshHome } from './config.js';
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+export function getServiceRuntimeDir(customHome) {
+  return path.join(getDarkMeshHome(customHome), 'runtime');
+}
+
+export function getServiceStatePath(customHome) {
+  return path.join(getServiceRuntimeDir(customHome), 'service.json');
+}
+
+export function getServiceLogPath(customHome) {
+  return path.join(getServiceRuntimeDir(customHome), 'service.log');
+}
+
+export function getServiceStopPath(customHome) {
+  return path.join(getServiceRuntimeDir(customHome), 'service.stop');
+}
+
+export async function ensureServiceRuntime(customHome) {
+  await ensureDarkMeshHome(customHome);
+  await fsPromises.mkdir(getServiceRuntimeDir(customHome), { recursive: true });
+}
+
+export async function loadServiceState(customHome) {
+  try {
+    const raw = await fsPromises.readFile(getServiceStatePath(customHome), 'utf8');
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error?.code === 'ENOENT') return null;
+    throw error;
+  }
+}
+
+export async function saveServiceState(customHome, state) {
+  await ensureServiceRuntime(customHome);
+  const {
+    installed: _installed,
+    running: _running,
+    pidRunning: _pidRunning,
+    stopRequested: _stopRequested,
+    ...persistable
+  } = state || {};
+  const nextState = {
+    ...persistable,
+    updatedAt: nowIso(),
+    logPath: getServiceLogPath(customHome)
+  };
+  await fsPromises.writeFile(getServiceStatePath(customHome), `${JSON.stringify(nextState, null, 2)}\n`, 'utf8');
+  return nextState;
+}
+
+export async function clearServiceStopRequest(customHome) {
+  try {
+    await fsPromises.unlink(getServiceStopPath(customHome));
+  } catch (error) {
+    if (error?.code !== 'ENOENT') throw error;
+  }
+}
+
+export async function writeServiceStopRequest(customHome) {
+  await ensureServiceRuntime(customHome);
+  await fsPromises.writeFile(getServiceStopPath(customHome), nowIso(), 'utf8');
+}
+
+export async function serviceStopRequested(customHome) {
+  try {
+    await fsPromises.access(getServiceStopPath(customHome));
+    return true;
+  } catch (error) {
+    if (error?.code === 'ENOENT') return false;
+    throw error;
+  }
+}
+
+export function isPidRunning(pid) {
+  if (!pid || !Number.isInteger(pid)) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function refreshServiceState(customHome) {
+  const state = await loadServiceState(customHome);
+  if (!state) {
+    return {
+      installed: false,
+      running: false,
+      status: 'stopped',
+      pid: null,
+      logPath: getServiceLogPath(customHome),
+      stopRequested: await serviceStopRequested(customHome)
+    };
+  }
+
+  const running = ['starting', 'running', 'stopping'].includes(state.status);
+
+  return {
+    ...state,
+    installed: true,
+    running,
+    pidRunning: state.pid ? isPidRunning(state.pid) : false,
+    stopRequested: await serviceStopRequested(customHome),
+    logPath: state.logPath || getServiceLogPath(customHome)
+  };
+}
+
+export function openServiceLogFd(customHome) {
+  fs.mkdirSync(getServiceRuntimeDir(customHome), { recursive: true });
+  return fs.openSync(getServiceLogPath(customHome), 'a');
+}
+
+export async function readServiceLog(customHome, options = {}) {
+  const logPath = getServiceLogPath(customHome);
+  const tailLines = Math.max(1, Number(options.tailLines || 50));
+  try {
+    const text = await fsPromises.readFile(logPath, 'utf8');
+    const lines = text.split(/\r?\n/).filter(Boolean);
+    const tail = lines.slice(-tailLines);
+    return {
+      exists: true,
+      logPath,
+      lineCount: lines.length,
+      tailLines,
+      text: tail.join('\n')
+    };
+  } catch (error) {
+    if (error?.code === 'ENOENT') {
+      return {
+        exists: false,
+        logPath,
+        lineCount: 0,
+        tailLines,
+        text: ''
+      };
+    }
+    throw error;
+  }
+}