arc402-cli 0.3.0 → 0.3.2

package/src/commands/hire.ts

@@ -6,7 +6,9 @@ import { requireSigner } from "../client";
 import { hashFile, hashString } from "../utils/hash";
 import { parseDuration } from "../utils/time";
 import { printSenderInfo, executeContractWriteViaWallet } from "../wallet-router";
-import { SERVICE_AGREEMENT_ABI } from "../abis";
+import { AGENT_REGISTRY_ABI, SERVICE_AGREEMENT_ABI } from "../abis";
+
+const DEFAULT_REGISTRY_ADDRESS = "0xD5c2851B00090c92Ba7F4723FB548bb30C9B6865";
 
 const sessionManager = new SessionManager();
 
@@ -183,6 +185,34 @@ export function registerHireCommand(program: Command): void {
         agreementId = result.agreementId;
       }
 
+      // Notify provider's HTTP endpoint (non-blocking)
+      const hireRegistryAddress = config.agentRegistryV2Address ?? config.agentRegistryAddress ?? DEFAULT_REGISTRY_ADDRESS;
+      try {
+        const hireProvider = new ethers.JsonRpcProvider(config.rpcUrl);
+        const hireRegistry = new ethers.Contract(hireRegistryAddress, AGENT_REGISTRY_ABI, hireProvider);
+        const agentData = await hireRegistry.getAgent(opts.agent);
+        const endpoint = agentData.endpoint as string;
+        if (endpoint) {
+          await fetch(`${endpoint}/hire`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              agreementId: agreementId!.toString(),
+              from: address,
+              provider: opts.agent,
+              serviceType: opts.serviceType,
+              task: opts.task,
+              price: price.toString(),
+              token,
+              deadline: deadlineSeconds,
+              deliverablesHash,
+            }),
+          });
+        }
+      } catch (err) {
+        console.warn(`Warning: could not notify provider endpoint: ${err instanceof Error ? err.message : String(err)}`);
+      }
+
       if (opts.session) {
         sessionManager.setOnChainId(opts.session, agreementId!.toString());
       }

package/src/commands/workroom.ts

@@ -2,6 +2,7 @@ import { Command } from "commander";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
+import * as http from "http";
 import { spawnSync, execSync } from "child_process";
 import {
   ARC402_DIR,
@@ -9,6 +10,45 @@ import {
 } from "../openshell-runtime";
 import { DAEMON_LOG, DAEMON_TOML } from "../daemon/config";
 
+// ─── Daemon lifecycle notify ──────────────────────────────────────────────────
+
+function notifyDaemonWorkroomStatus(
+  event: "entered" | "exited" | "job_started" | "job_completed",
+  agentAddress?: string,
+  jobId?: string,
+  port = 4402
+): void {
+  try {
+    // Try to read port from daemon config
+    let daemonPort = port;
+    if (fs.existsSync(DAEMON_TOML)) {
+      try {
+        const { loadDaemonConfig } = require("../daemon/config") as typeof import("../daemon/config");
+        const cfg = loadDaemonConfig();
+        daemonPort = cfg.relay?.listen_port ?? port;
+      } catch { /* use default */ }
+    }
+
+    const payload = JSON.stringify({
+      event,
+      agentAddress: agentAddress ?? "",
+      jobId,
+      timestamp: Date.now(),
+    });
+
+    const req = http.request({
+      hostname: "127.0.0.1",
+      port: daemonPort,
+      path: "/workroom/status",
+      method: "POST",
+      headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(payload) },
+    });
+    req.on("error", () => { /* non-fatal */ });
+    req.write(payload);
+    req.end();
+  } catch { /* non-fatal */ }
+}
+
 // ─── Constants ────────────────────────────────────────────────────────────────
 
 const WORKROOM_IMAGE = "arc402-workroom";
@@ -232,6 +272,8 @@ export function registerWorkroomCommands(program: Command): void {
         console.log(`  Policy hash: ${getPolicyHash()}`);
         console.log(`  Relay port: 4402`);
         console.log(`  Logs: arc402 workroom logs`);
+        // Notify local daemon of workroom entry
+        notifyDaemonWorkroomStatus("entered");
       } else {
         console.error("Workroom started but exited immediately. Check logs:");
         console.error("  docker logs arc402-workroom");
@@ -249,6 +291,8 @@ export function registerWorkroomCommands(program: Command): void {
         return;
       }
       console.log("Stopping ARC-402 Workroom...");
+      // Notify daemon before stopping (daemon may be inside container)
+      notifyDaemonWorkroomStatus("exited");
       runCmd("docker", ["stop", WORKROOM_CONTAINER]);
       console.log("✓ Workroom stopped");
     });

package/src/daemon/index.ts

@@ -10,6 +10,7 @@
 import * as fs from "fs";
 import * as path from "path";
 import * as net from "net";
+import * as http from "http";
 import { ethers } from "ethers";
 import Database from "better-sqlite3";
 
@@ -549,6 +550,350 @@ export async function runDaemon(foreground = false): Promise<void> {
   // ── Start IPC socket ─────────────────────────────────────────────────────
   const ipcServer = startIpcServer(ipcCtx, log);
 
+  // ── Start HTTP relay server (public endpoint) ────────────────────────────
+  const httpPort = config.relay.listen_port ?? 4402;
+
+  const httpServer = http.createServer(async (req, res) => {
+    // CORS headers
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+    if (req.method === "OPTIONS") { res.writeHead(204); res.end(); return; }
+
+    const url = new URL(req.url || "/", `http://localhost:${httpPort}`);
+    const pathname = url.pathname;
+
+    // Health / info
+    if (pathname === "/" || pathname === "/health") {
+      const info = {
+        protocol: "arc-402",
+        version: "0.3.0",
+        agent: config.wallet.contract_address,
+        status: "online",
+        capabilities: config.policy.allowed_capabilities,
+        uptime: Math.floor((Date.now() - ipcCtx.startTime) / 1000),
+      };
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(info));
+      return;
+    }
+
+    // Agent info
+    if (pathname === "/agent") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        wallet: config.wallet.contract_address,
+        owner: config.wallet.owner_address,
+        machineKey: machineKeyAddress,
+        chainId: config.network.chain_id,
+        bundlerMode: config.bundler.mode,
+        relay: config.relay.enabled,
+      }));
+      return;
+    }
+
+    // Receive hire proposal
+    if (pathname === "/hire" && req.method === "POST") {
+      let body = "";
+      req.on("data", (chunk: Buffer) => { body += chunk.toString(); });
+      req.on("end", async () => {
+        try {
+          const msg = JSON.parse(body) as Record<string, unknown>;
+
+          // Feed into the hire listener's message handler
+          const proposal = {
+            messageId: String(msg.messageId ?? msg.id ?? `http_${Date.now()}`),
+            hirerAddress: String(msg.hirerAddress ?? msg.hirer_address ?? msg.from ?? ""),
+            capability: String(msg.capability ?? ""),
+            priceEth: String(msg.priceEth ?? msg.price_eth ?? "0"),
+            deadlineUnix: Number(msg.deadlineUnix ?? msg.deadline ?? 0),
+            specHash: String(msg.specHash ?? msg.spec_hash ?? ""),
+            agreementId: msg.agreementId ? String(msg.agreementId) : undefined,
+            signature: msg.signature ? String(msg.signature) : undefined,
+          };
+
+          // Dedup
+          const existing = db.getHireRequest(proposal.messageId);
+          if (existing) {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ status: existing.status, id: proposal.messageId }));
+            return;
+          }
+
+          // Policy check
+          const { evaluatePolicy } = await import("./hire-listener");
+          const activeCount = db.countActiveHireRequests();
+          const policyResult = evaluatePolicy(proposal, config, activeCount);
+
+          if (!policyResult.allowed) {
+            db.insertHireRequest({
+              id: proposal.messageId,
+              agreement_id: proposal.agreementId ?? null,
+              hirer_address: proposal.hirerAddress,
+              capability: proposal.capability,
+              price_eth: proposal.priceEth,
+              deadline_unix: proposal.deadlineUnix,
+              spec_hash: proposal.specHash,
+              status: "rejected",
+              reject_reason: policyResult.reason ?? "policy_violation",
+            });
+            log({ event: "http_hire_rejected", id: proposal.messageId, reason: policyResult.reason });
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ status: "rejected", reason: policyResult.reason, id: proposal.messageId }));
+            return;
+          }
+
+          const status = config.policy.auto_accept ? "accepted" : "pending_approval";
+          db.insertHireRequest({
+            id: proposal.messageId,
+            agreement_id: proposal.agreementId ?? null,
+            hirer_address: proposal.hirerAddress,
+            capability: proposal.capability,
+            price_eth: proposal.priceEth,
+            deadline_unix: proposal.deadlineUnix,
+            spec_hash: proposal.specHash,
+            status,
+            reject_reason: null,
+          });
+
+          log({ event: "http_hire_received", id: proposal.messageId, hirer: proposal.hirerAddress, status });
+
+          if (config.notifications.notify_on_hire_request) {
+            await notifier.notifyHireRequest(proposal.messageId, proposal.hirerAddress, proposal.priceEth, proposal.capability);
+          }
+
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ status, id: proposal.messageId }));
+        } catch (err) {
+          log({ event: "http_hire_error", error: String(err) });
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "invalid_request" }));
+        }
+      });
+      return;
+    }
+
+    // Handshake acknowledgment endpoint
+    if (pathname === "/handshake" && req.method === "POST") {
+      let body = "";
+      req.on("data", (chunk: Buffer) => { body += chunk.toString(); });
+      req.on("end", () => {
+        try {
+          const msg = JSON.parse(body);
+          log({ event: "handshake_received", from: msg.from, type: msg.type, note: msg.note });
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ received: true, agent: config.wallet.contract_address }));
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "invalid_request" }));
+        }
+      });
+      return;
+    }
+
+    // POST /hire/accepted — provider accepted, client notified
+    if (pathname === "/hire/accepted" && req.method === "POST") {
+      let body = "";
+      req.on("data", (chunk: Buffer) => { body += chunk.toString(); });
+      req.on("end", async () => {
+        try {
+          const msg = JSON.parse(body) as Record<string, unknown>;
+          const agreementId = String(msg.agreementId ?? msg.agreement_id ?? "");
+          const from = String(msg.from ?? "");
+          log({ event: "hire_accepted_inbound", agreementId, from });
+          if (config.notifications.notify_on_hire_accepted) {
+            await notifier.notifyHireAccepted(agreementId, agreementId);
+          }
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ received: true, agent: config.wallet.contract_address }));
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "invalid_request" }));
+        }
+      });
+      return;
+    }
+
+    // POST /message — off-chain negotiation message
+    if (pathname === "/message" && req.method === "POST") {
+      let body = "";
+      req.on("data", (chunk: Buffer) => { body += chunk.toString(); });
+      req.on("end", () => {
+        try {
+          const msg = JSON.parse(body) as Record<string, unknown>;
+          const from = String(msg.from ?? "");
+          const to = String(msg.to ?? "");
+          const content = String(msg.content ?? "");
+          const timestamp = Number(msg.timestamp ?? Date.now());
+          log({ event: "message_received", from, to, timestamp, content_len: content.length });
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ received: true, agent: config.wallet.contract_address }));
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "invalid_request" }));
+        }
+      });
+      return;
+    }
+
+    // POST /delivery — provider committed a deliverable
+    if (pathname === "/delivery" && req.method === "POST") {
+      let body = "";
+      req.on("data", (chunk: Buffer) => { body += chunk.toString(); });
+      req.on("end", async () => {
+        try {
+          const msg = JSON.parse(body) as Record<string, unknown>;
+          const agreementId = String(msg.agreementId ?? msg.agreement_id ?? "");
+          const deliverableHash = String(msg.deliverableHash ?? msg.deliverable_hash ?? "");
+          const from = String(msg.from ?? "");
+          log({ event: "delivery_received", agreementId, deliverableHash, from });
+          // Update DB: mark delivered
+          const active = db.listActiveHireRequests();
+          const found = active.find(r => r.agreement_id === agreementId);
+          if (found) db.updateHireRequestStatus(found.id, "delivered");
+          if (config.notifications.notify_on_delivery) {
+            await notifier.notifyDelivery(agreementId, deliverableHash, "");
+          }
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ received: true, agent: config.wallet.contract_address }));
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "invalid_request" }));
+        }
+      });
+      return;
+    }
+
+    // POST /delivery/accepted — client accepted delivery, payment releasing
+    if (pathname === "/delivery/accepted" && req.method === "POST") {
+      let body = "";
+      req.on("data", (chunk: Buffer) => { body += chunk.toString(); });
+      req.on("end", () => {
+        try {
+          const msg = JSON.parse(body) as Record<string, unknown>;
+          const agreementId = String(msg.agreementId ?? msg.agreement_id ?? "");
+          const from = String(msg.from ?? "");
+          log({ event: "delivery_accepted_inbound", agreementId, from });
+          // Update DB: mark complete
+          const all = db.listActiveHireRequests();
+          const found = all.find(r => r.agreement_id === agreementId);
+          if (found) db.updateHireRequestStatus(found.id, "complete");
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ received: true, agent: config.wallet.contract_address }));
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "invalid_request" }));
+        }
+      });
+      return;
+    }
+
+    // POST /dispute — dispute raised against this agent
+    if (pathname === "/dispute" && req.method === "POST") {
+      let body = "";
+      req.on("data", (chunk: Buffer) => { body += chunk.toString(); });
+      req.on("end", async () => {
+        try {
+          const msg = JSON.parse(body) as Record<string, unknown>;
+          const agreementId = String(msg.agreementId ?? msg.agreement_id ?? "");
+          const reason = String(msg.reason ?? "");
+          const from = String(msg.from ?? "");
+          log({ event: "dispute_received", agreementId, reason, from });
+          if (config.notifications.notify_on_dispute) {
+            await notifier.notifyDispute(agreementId, from);
+          }
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ received: true, agent: config.wallet.contract_address }));
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "invalid_request" }));
+        }
+      });
+      return;
+    }
+
+    // POST /dispute/resolved — dispute resolved by arbitrator
+    if (pathname === "/dispute/resolved" && req.method === "POST") {
+      let body = "";
+      req.on("data", (chunk: Buffer) => { body += chunk.toString(); });
+      req.on("end", () => {
+        try {
+          const msg = JSON.parse(body) as Record<string, unknown>;
+          const agreementId = String(msg.agreementId ?? msg.agreement_id ?? "");
+          const outcome = String(msg.outcome ?? "");
+          const from = String(msg.from ?? "");
+          log({ event: "dispute_resolved_inbound", agreementId, outcome, from });
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ received: true, agent: config.wallet.contract_address }));
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "invalid_request" }));
+        }
+      });
+      return;
+    }
+
+    // POST /workroom/status — workroom lifecycle events
+    if (pathname === "/workroom/status" && req.method === "POST") {
+      let body = "";
+      req.on("data", (chunk: Buffer) => { body += chunk.toString(); });
+      req.on("end", () => {
+        try {
+          const msg = JSON.parse(body) as Record<string, unknown>;
+          const event = String(msg.event ?? "");
+          const agentAddress = String(msg.agentAddress ?? config.wallet.contract_address);
+          const jobId = msg.jobId ? String(msg.jobId) : undefined;
+          const timestamp = Number(msg.timestamp ?? Date.now());
+          log({ event: "workroom_lifecycle", workroom_event: event, agentAddress, jobId, timestamp });
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ received: true, agent: config.wallet.contract_address }));
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "invalid_request" }));
+        }
+      });
+      return;
+    }
+
+    // GET /capabilities — agent capabilities from config
+    if (pathname === "/capabilities" && req.method === "GET") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        capabilities: config.policy.allowed_capabilities,
+        max_price_eth: config.policy.max_price_eth,
+        auto_accept: config.policy.auto_accept,
+        max_concurrent_agreements: config.relay.max_concurrent_agreements,
+      }));
+      return;
+    }
+
+    // GET /status — health with active agreement count
+    if (pathname === "/status" && req.method === "GET") {
+      const activeList = db.listActiveHireRequests();
+      const pendingList = db.listPendingHireRequests();
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        protocol: "arc-402",
+        version: "0.3.0",
+        agent: config.wallet.contract_address,
+        status: "online",
+        uptime: Math.floor((Date.now() - ipcCtx.startTime) / 1000),
+        active_agreements: activeList.length,
+        pending_approval: pendingList.length,
+        capabilities: config.policy.allowed_capabilities,
+      }));
+      return;
+    }
+
+    // 404
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "not_found" }));
+  });
+
+  httpServer.listen(httpPort, "0.0.0.0", () => {
+    log({ event: "http_server_started", port: httpPort });
+  });
+
   // ── Step 12: Startup complete ────────────────────────────────────────────
   const subsystems = [];
   if (config.relay.enabled) subsystems.push("relay");
@@ -573,7 +918,8 @@ export async function runDaemon(foreground = false): Promise<void> {
     clearInterval(timeoutInterval);
     clearInterval(balanceInterval);
 
-    // Close IPC
+    // Close HTTP + IPC
+    httpServer.close();
     ipcServer.close();
     if (fs.existsSync(DAEMON_SOCK)) fs.unlinkSync(DAEMON_SOCK);
 

package/src/endpoint-notify.ts

@@ -0,0 +1,46 @@
+/**
+ * Shared endpoint-notify helper for CLI commands.
+ * Resolves an agent's registered HTTP endpoint from AgentRegistry
+ * and POSTs lifecycle events after onchain transactions.
+ */
+import { ethers } from "ethers";
+import { AGENT_REGISTRY_ABI } from "./abis";
+
+export const DEFAULT_REGISTRY_ADDRESS = "0xD5c2851B00090c92Ba7F4723FB548bb30C9B6865";
+
+/**
+ * Reads an agent's public HTTP endpoint from AgentRegistry.
+ * Returns empty string if not registered or no endpoint.
+ */
+export async function resolveAgentEndpoint(
+  address: string,
+  provider: ethers.Provider,
+  registryAddress = DEFAULT_REGISTRY_ADDRESS
+): Promise<string> {
+  const registry = new ethers.Contract(registryAddress, AGENT_REGISTRY_ABI, provider);
+  const agentData = await registry.getAgent(address);
+  return (agentData.endpoint as string) ?? "";
+}
+
+/**
+ * POSTs JSON payload to {endpoint}{path}. Returns true on success.
+ * Never throws — logs a warning on failure.
+ */
+export async function notifyAgent(
+  endpoint: string,
+  path: string,
+  payload: Record<string, unknown>
+): Promise<boolean> {
+  if (!endpoint) return false;
+  try {
+    const res = await fetch(`${endpoint}${path}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+    });
+    return res.ok;
+  } catch (err) {
+    console.warn(`Warning: endpoint notify failed (${endpoint}${path}): ${err instanceof Error ? err.message : String(err)}`);
+    return false;
+  }
+}

package/src/index.ts

@@ -30,6 +30,8 @@ import { registerContractInteractionCommands } from "./commands/contract-interac
 import { registerWatchtowerCommands } from "./commands/watchtower";
 import { registerColdStartCommands } from "./commands/coldstart";
 import { registerMigrateCommands } from "./commands/migrate";
+import { registerFeedCommand } from "./commands/feed";
+import { registerArenaCommands } from "./commands/arena";
 import reputation from "./commands/reputation.js";
 import policy from "./commands/policy.js";
 
@@ -70,6 +72,8 @@ registerContractInteractionCommands(program);
 registerWatchtowerCommands(program);
 registerColdStartCommands(program);
 registerMigrateCommands(program);
+registerFeedCommand(program);
+registerArenaCommands(program);
 program.addCommand(reputation);
 program.addCommand(policy);
 program.parse(process.argv);