@consensus-tools/consensus-tools 0.1.0

package/src/network/client.ts

@@ -0,0 +1,70 @@
+import type { Assignment, Job, Resolution, Submission, Vote } from '../types';
+import type { JobPostInput, ClaimInput, SubmitInput, ResolveInput, VoteInput } from '../jobs/engine';
+
+export class ConsensusToolsClient {
+  constructor(private readonly baseUrl: string, private readonly accessToken: string, private readonly logger?: any) {}
+
+  async postJob(agentId: string, input: JobPostInput): Promise<Job> {
+    return this.request('POST', '/jobs', { agentId, ...input });
+  }
+
+  async listJobs(params: Record<string, string | undefined> = {}): Promise<Job[]> {
+    const query = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+      if (value) query.set(key, value);
+    }
+    const suffix = query.toString() ? `?${query}` : '';
+    return this.request('GET', `/jobs${suffix}`);
+  }
+
+  async getJob(jobId: string): Promise<Job> {
+    return this.request('GET', `/jobs/${jobId}`);
+  }
+
+  async getStatus(jobId: string): Promise<any> {
+    return this.request('GET', `/jobs/${jobId}/status`);
+  }
+
+  async claimJob(agentId: string, jobId: string, input: ClaimInput): Promise<Assignment> {
+    return this.request('POST', `/jobs/${jobId}/claim`, { agentId, ...input });
+  }
+
+  async submitJob(agentId: string, jobId: string, input: SubmitInput): Promise<Submission> {
+    return this.request('POST', `/jobs/${jobId}/submit`, { agentId, ...input });
+  }
+
+  async vote(agentId: string, jobId: string, input: VoteInput): Promise<Vote> {
+    return this.request('POST', `/jobs/${jobId}/vote`, { agentId, ...input });
+  }
+
+  async resolveJob(agentId: string, jobId: string, input: ResolveInput): Promise<Resolution> {
+    return this.request('POST', `/jobs/${jobId}/resolve`, { agentId, ...input });
+  }
+
+  async getLedger(agentId: string): Promise<{ agentId: string; balance: number }>
+  {
+    return this.request('GET', `/ledger/${agentId}`);
+  }
+
+  private async request(method: string, path: string, body?: any): Promise<any> {
+    const url = `${this.baseUrl.replace(/\/$/, '')}${path}`;
+    const headers: Record<string, string> = { 'content-type': 'application/json' };
+    if (this.accessToken) headers.authorization = `Bearer ${this.accessToken}`;
+
+    const res = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : undefined
+    });
+
+    if (!res.ok) {
+      const text = await res.text();
+      this.logger?.warn?.({ status: res.status, path }, 'consensus-tools: network request failed');
+      throw new Error(`Network error ${res.status}: ${text || res.statusText}`);
+    }
+
+    const text = await res.text();
+    if (!text) return null;
+    return JSON.parse(text);
+  }
+}

package/src/network/server.ts

@@ -0,0 +1,143 @@
+import http from 'node:http';
+import type { ConsensusToolsConfig } from '../types';
+import type { JobEngine } from '../jobs/engine';
+import type { LedgerEngine } from '../ledger/ledger';
+
+export class ConsensusToolsServer {
+  private server?: http.Server;
+
+  constructor(
+    private readonly config: ConsensusToolsConfig,
+    private readonly engine: JobEngine,
+    private readonly ledger: LedgerEngine,
+    private readonly logger?: any
+  ) {}
+
+  async start(): Promise<void> {
+    if (this.server) return;
+    const { host, port } = this.config.local.server;
+    this.server = http.createServer((req, res) => this.handle(req, res));
+
+    await new Promise<void>((resolve) => {
+      this.server?.listen(port, host, () => resolve());
+    });
+
+    this.logger?.info?.({ host, port }, 'consensus-tools embedded server started');
+  }
+
+  async stop(): Promise<void> {
+    if (!this.server) return;
+    const srv = this.server;
+    this.server = undefined;
+    await new Promise<void>((resolve, reject) => {
+      srv.close((err) => (err ? reject(err) : resolve()));
+    });
+    this.logger?.info?.('consensus-tools embedded server stopped');
+  }
+
+  private async handle(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+    try {
+      if (this.config.local.server.authToken) {
+        const auth = req.headers.authorization || '';
+        if (auth !== `Bearer ${this.config.local.server.authToken}`) {
+          return this.reply(res, 401, { error: 'Unauthorized' });
+        }
+      }
+
+      const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+      const path = url.pathname;
+      const method = req.method || 'GET';
+
+      if (method === 'POST' && path === '/jobs') {
+        const body = await this.readJson(req);
+        const job = await this.engine.postJob(body.agentId, body);
+        return this.reply(res, 200, job);
+      }
+
+      if (method === 'GET' && path === '/jobs') {
+        const jobs = await this.engine.listJobs({
+          status: url.searchParams.get('status') || undefined,
+          tag: url.searchParams.get('tag') || undefined,
+          mine: url.searchParams.get('mine') || undefined
+        });
+        return this.reply(res, 200, jobs);
+      }
+
+      const jobMatch = path.match(/^\/jobs\/([^/]+)(?:\/(claim|submit|vote|resolve|status))?$/);
+      if (jobMatch) {
+        const jobId = jobMatch[1];
+        const action = jobMatch[2];
+
+        if (method === 'GET' && !action) {
+          const job = await this.engine.getJob(jobId);
+          if (!job) return this.reply(res, 404, { error: 'Job not found' });
+          return this.reply(res, 200, job);
+        }
+
+        if (method === 'GET' && action === 'status') {
+          const status = await this.engine.getStatus(jobId);
+          return this.reply(res, 200, status);
+        }
+
+        if (method === 'POST' && action === 'claim') {
+          const body = await this.readJson(req);
+          const claim = await this.engine.claimJob(body.agentId, jobId, body);
+          return this.reply(res, 200, claim);
+        }
+
+        if (method === 'POST' && action === 'submit') {
+          const body = await this.readJson(req);
+          const submission = await this.engine.submitJob(body.agentId, jobId, body);
+          return this.reply(res, 200, submission);
+        }
+
+        if (method === 'POST' && action === 'vote') {
+          const body = await this.readJson(req);
+          const vote = await this.engine.vote(body.agentId, jobId, body);
+          return this.reply(res, 200, vote);
+        }
+
+        if (method === 'POST' && action === 'resolve') {
+          const body = await this.readJson(req);
+          const resolution = await this.engine.resolveJob(body.agentId, jobId, body);
+          return this.reply(res, 200, resolution);
+        }
+      }
+
+      const ledgerMatch = path.match(/^\/ledger\/([^/]+)$/);
+      if (method === 'GET' && ledgerMatch) {
+        const agentId = ledgerMatch[1];
+        const balance = await this.ledger.getBalance(agentId);
+        return this.reply(res, 200, { agentId, balance });
+      }
+
+      return this.reply(res, 404, { error: 'Not found' });
+    } catch (err: any) {
+      this.logger?.warn?.({ err }, 'consensus-tools server error');
+      try {
+        await this.engine.recordError?.(err?.message || 'Server error', { path: req.url, method: req.method });
+      } catch {
+        // ignore
+      }
+      return this.reply(res, 500, { error: err?.message || 'Server error' });
+    }
+  }
+
+  private async readJson(req: http.IncomingMessage): Promise<any> {
+    const chunks: Buffer[] = [];
+    for await (const chunk of req) {
+      chunks.push(Buffer.from(chunk));
+      if (Buffer.concat(chunks).length > 1024 * 1024) {
+        throw new Error('Payload too large');
+      }
+    }
+    const text = Buffer.concat(chunks).toString('utf8');
+    return text ? JSON.parse(text) : {};
+  }
+
+  private reply(res: http.ServerResponse, status: number, body: any): void {
+    res.statusCode = status;
+    res.setHeader('content-type', 'application/json');
+    res.end(JSON.stringify(body));
+  }
+}

package/src/service.ts

@@ -0,0 +1,26 @@
+import type { ConsensusToolsConfig, Job } from './types';
+
+export interface ConsensusToolsBackend {
+  listJobs(filters?: Record<string, string | undefined>): Promise<Job[]>;
+  getJob(jobId: string): Promise<Job | undefined>;
+}
+
+export function createService(
+  config: ConsensusToolsConfig,
+  backend: ConsensusToolsBackend,
+  agentId: string,
+  capabilities: string[],
+  logger?: any
+) {
+  return {
+    id: 'consensus-tools-service',
+    start: async () => {
+      if (config.mode === 'global') return;
+      logger?.debug?.({ agentId, capabilities }, 'consensus-tools: service started');
+    },
+    stop: async () => {
+      if (config.mode === 'global') return;
+      logger?.debug?.('consensus-tools: service stopped');
+    }
+  };
+}

package/src/storage/IStorage.ts

@@ -0,0 +1,31 @@
+import type { ConsensusToolsConfig, StorageState } from '../types';
+import { JsonStorage } from './JsonStorage';
+import { SqliteStorage } from './SqliteStorage';
+
+export interface IStorage {
+  init(): Promise<void>;
+  getState(): Promise<StorageState>;
+  saveState(state: StorageState): Promise<void>;
+  update<T>(fn: (state: StorageState) => T | Promise<T>): Promise<{ state: StorageState; result: T }>;
+}
+
+export function defaultState(): StorageState {
+  return {
+    jobs: [],
+    bids: [],
+    claims: [],
+    submissions: [],
+    votes: [],
+    resolutions: [],
+    ledger: [],
+    audit: [],
+    errors: []
+  };
+}
+
+export function createStorage(config: ConsensusToolsConfig): IStorage {
+  if (config.local.storage.kind === 'sqlite') {
+    return new SqliteStorage(config.local.storage.path);
+  }
+  return new JsonStorage(config.local.storage.path);
+}

package/src/storage/JsonStorage.ts

@@ -0,0 +1,63 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { Mutex } from '../util/locks';
+import { defaultState, IStorage } from './IStorage';
+import type { StorageState } from '../types';
+
+export class JsonStorage implements IStorage {
+  private readonly filePath: string;
+  private readonly mutex = new Mutex();
+
+  constructor(filePath: string) {
+    this.filePath = filePath;
+  }
+
+  async init(): Promise<void> {
+    await this.mutex.runExclusive(async () => {
+      await this.ensureFile();
+    });
+  }
+
+  async getState(): Promise<StorageState> {
+    await this.ensureFile();
+    const raw = await fs.readFile(this.filePath, 'utf8');
+    if (!raw.trim()) {
+      const state = defaultState();
+      await this.saveState(state);
+      return state;
+    }
+    try {
+      const parsed = JSON.parse(raw) as StorageState;
+      return parsed;
+    } catch (err) {
+      throw new Error(`consensus-tools: storage file corrupt at ${this.filePath}. ${String(err)}`);
+    }
+  }
+
+  async saveState(state: StorageState): Promise<void> {
+    const dir = path.dirname(this.filePath);
+    await fs.mkdir(dir, { recursive: true });
+    const temp = `${this.filePath}.tmp`;
+    await fs.writeFile(temp, JSON.stringify(state, null, 2), 'utf8');
+    await fs.rename(temp, this.filePath);
+  }
+
+  async update<T>(fn: (state: StorageState) => T | Promise<T>): Promise<{ state: StorageState; result: T }> {
+    return this.mutex.runExclusive(async () => {
+      const state = await this.getState();
+      const result = await fn(state);
+      await this.saveState(state);
+      return { state, result };
+    });
+  }
+
+  private async ensureFile(): Promise<void> {
+    const dir = path.dirname(this.filePath);
+    await fs.mkdir(dir, { recursive: true });
+    try {
+      await fs.access(this.filePath);
+    } catch {
+      await fs.writeFile(this.filePath, JSON.stringify(defaultState(), null, 2), 'utf8');
+    }
+  }
+}

package/src/storage/SqliteStorage.ts

@@ -0,0 +1,67 @@
+import { createRequire } from 'node:module';
+import { Mutex } from '../util/locks';
+import { defaultState, IStorage } from './IStorage';
+import type { StorageState } from '../types';
+
+export class SqliteStorage implements IStorage {
+  private readonly filePath: string;
+  private readonly mutex = new Mutex();
+  private db: any;
+
+  constructor(filePath: string) {
+    this.filePath = filePath;
+  }
+
+  async init(): Promise<void> {
+    await this.mutex.runExclusive(async () => {
+      this.ensureDb();
+      this.db.prepare('CREATE TABLE IF NOT EXISTS kv (key TEXT PRIMARY KEY, value TEXT)').run();
+      const row = this.db.prepare('SELECT value FROM kv WHERE key = ?').get('state');
+      if (!row) {
+        this.db.prepare('INSERT INTO kv (key, value) VALUES (?, ?)').run('state', JSON.stringify(defaultState()));
+      }
+    });
+  }
+
+  async getState(): Promise<StorageState> {
+    this.ensureDb();
+    const row = this.db.prepare('SELECT value FROM kv WHERE key = ?').get('state');
+    if (!row?.value) {
+      const state = defaultState();
+      await this.saveState(state);
+      return state;
+    }
+    return JSON.parse(row.value) as StorageState;
+  }
+
+  async saveState(state: StorageState): Promise<void> {
+    this.ensureDb();
+    this.db.prepare('INSERT INTO kv (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value').run(
+      'state',
+      JSON.stringify(state)
+    );
+  }
+
+  async update<T>(fn: (state: StorageState) => T | Promise<T>): Promise<{ state: StorageState; result: T }> {
+    return this.mutex.runExclusive(async () => {
+      const state = await this.getState();
+      const result = await fn(state);
+      await this.saveState(state);
+      return { state, result };
+    });
+  }
+
+  private ensureDb(): void {
+    if (this.db) return;
+    let BetterSqlite3: any;
+    try {
+      const require = createRequire(import.meta.url);
+      BetterSqlite3 = require('better-sqlite3');
+    } catch (err) {
+      throw new Error(
+        'consensus-tools: sqlite storage selected but better-sqlite3 is not installed. Install it or switch to storage.kind="json".'
+      );
+    }
+    this.db = new BetterSqlite3(this.filePath);
+  }
+}

package/src/tools.ts

@@ -0,0 +1,184 @@
+import type { ConsensusToolsConfig } from './types';
+import type { ConsensusToolsBackendCli } from './cli';
+
+export function registerTools(api: any, backend: ConsensusToolsBackendCli, config: ConsensusToolsConfig, agentId: string) {
+  const optional = config.safety.requireOptionalToolsOptIn;
+
+  const register = (tool: any, opts?: any) => api.registerTool(tool, opts);
+
+  register(
+    {
+      name: 'consensus-tools_post_job',
+      description: 'Post a new consensus job to the consensus-tools job board',
+      parameters: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          boardId: { type: 'string' },
+          title: { type: 'string' },
+          description: { type: 'string' },
+          desc: { type: 'string' },
+          inputRef: { type: 'string' },
+          mode: { type: 'string' },
+          policyKey: { type: 'string' },
+          policyConfigJson: { type: 'object' },
+          inputs: { type: 'object' },
+          reward: { type: 'number' },
+          rewardAmount: { type: 'number' },
+          stakeRequired: { type: 'number' },
+          stakeAmount: { type: 'number' },
+          currency: { type: 'string' },
+          maxParticipants: { type: 'number' },
+          minParticipants: { type: 'number' },
+          expiresSeconds: { type: 'number' },
+          opensAt: { type: 'string' },
+          closesAt: { type: 'string' },
+          resolvesAt: { type: 'string' },
+          priority: { type: 'number' },
+          policies: { type: 'object' },
+          tags: { type: 'array', items: { type: 'string' } },
+          requiredCapabilities: { type: 'array', items: { type: 'string' } },
+          constraints: { type: 'object' },
+          artifactSchemaJson: { type: 'object' }
+        },
+        required: ['title', 'description']
+      },
+      execute: async (args: any) => {
+        const job = await backend.postJob(agentId, {
+          boardId: args.boardId,
+          title: args.title,
+          description: args.description,
+          desc: args.desc,
+          inputRef: args.inputRef,
+          mode: args.mode,
+          policyKey: args.policyKey,
+          policyConfigJson: args.policyConfigJson,
+          inputs: args.inputs,
+          reward: args.reward,
+          rewardAmount: args.rewardAmount,
+          stakeRequired: args.stakeRequired,
+          stakeAmount: args.stakeAmount,
+          currency: args.currency,
+          maxParticipants: args.maxParticipants,
+          minParticipants: args.minParticipants,
+          expiresSeconds: args.expiresSeconds,
+          opensAt: args.opensAt,
+          closesAt: args.closesAt,
+          resolvesAt: args.resolvesAt,
+          priority: args.priority,
+          tags: args.tags,
+          requiredCapabilities: args.requiredCapabilities,
+          constraints: args.constraints,
+          artifactSchemaJson: args.artifactSchemaJson,
+          consensusPolicy: args.policies?.consensusPolicy,
+          slashingPolicy: args.policies?.slashingPolicy
+        });
+        return { content: [{ type: 'text', text: JSON.stringify(job, null, 2) }] };
+      }
+    },
+    { optional }
+  );
+
+  register(
+    {
+      name: 'consensus-tools_list_jobs',
+      description: 'List jobs on the consensus-tools job board',
+      parameters: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          filters: { type: 'object' }
+        }
+      },
+      execute: async (args: any) => {
+        const jobs = await backend.listJobs(args.filters || {});
+        return { content: [{ type: 'text', text: JSON.stringify(jobs, null, 2) }] };
+      }
+    },
+    { optional: false }
+  );
+
+  register(
+    {
+      name: 'consensus-tools_submit',
+      description: 'Submit job artifacts',
+      parameters: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          jobId: { type: 'string' },
+          summary: { type: 'string' },
+          artifacts: { type: 'object' },
+          artifactRef: { type: 'string' },
+          confidence: { type: 'number' },
+          requestedPayout: { type: 'number' }
+        },
+        required: ['jobId', 'summary']
+      },
+      execute: async (args: any) => {
+        const submission = await backend.submitJob(agentId, args.jobId, {
+          summary: args.summary,
+          artifacts: args.artifacts,
+          artifactRef: args.artifactRef,
+          confidence: args.confidence ?? 0.5,
+          requestedPayout: args.requestedPayout
+        });
+        return { content: [{ type: 'text', text: JSON.stringify(submission, null, 2) }] };
+      }
+    },
+    { optional }
+  );
+
+  register(
+    {
+      name: 'consensus-tools_vote',
+      description: 'Vote on a job target',
+      parameters: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          jobId: { type: 'string' },
+          submissionId: { type: 'string' },
+          choiceKey: { type: 'string' },
+          weight: { type: 'number' },
+          score: { type: 'number' },
+          stakeAmount: { type: 'number' },
+          rationale: { type: 'string' }
+        },
+        required: ['jobId']
+      },
+      execute: async (args: any) => {
+        const vote = await backend.vote(agentId, args.jobId, {
+          submissionId: args.submissionId,
+          choiceKey: args.choiceKey,
+          weight: args.weight ?? args.score,
+          score: args.score ?? args.weight,
+          stakeAmount: args.stakeAmount,
+          rationale: args.rationale
+        });
+        return { content: [{ type: 'text', text: JSON.stringify(vote, null, 2) }] };
+      }
+    },
+    { optional }
+  );
+
+  register(
+    {
+      name: 'consensus-tools_status',
+      description: 'Get job status, claims, submissions, and resolution',
+      parameters: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          jobId: { type: 'string' }
+        },
+        required: ['jobId']
+      },
+      execute: async (args: any) => {
+        const status = backend.getStatus ? await backend.getStatus(args.jobId) : await backend.getJob(args.jobId);
+        return { content: [{ type: 'text', text: JSON.stringify(status, null, 2) }] };
+      }
+    },
+    { optional: false }
+  );
+}