@arcdot/agent 0.1.0

package/dist/index.cjs

@@ -0,0 +1,678 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ARC_CHAIN_ID: () => ARC_CHAIN_ID,
+  ARC_RPC_URL_DEFAULT: () => ARC_RPC_URL_DEFAULT,
+  GATEWAY_FEE_WEI_DEFAULT: () => GATEWAY_FEE_WEI_DEFAULT,
+  callMcpToolWithAutoSettle: () => callMcpToolWithAutoSettle,
+  createArcdotAgent: () => createArcdotAgent,
+  createWallet: () => createWallet,
+  fetchService: () => fetchService,
+  getNativeBalance: () => getNativeBalance,
+  isGateway402Body: () => isGateway402Body,
+  loadWallet: () => loadWallet,
+  makePaymentId: () => makePaymentId,
+  mcpRpc: () => mcpRpc,
+  parseMcpPaymentNeeded: () => parseMcpPaymentNeeded,
+  parsePaymentRequired: () => parsePaymentRequired,
+  paymentDepositArgs: () => paymentDepositArgs,
+  resolveGateway: () => resolveGateway,
+  resolvePrivateKey: () => resolvePrivateKey,
+  runMcpProxy: () => runMcpProxy,
+  settlePayment: () => settlePayment,
+  slugFromToolName: () => slugFromToolName,
+  toolNameForSlug: () => toolNameForSlug,
+  unlockWithAutoSettle: () => unlockWithAutoSettle,
+  walletAccountFromKey: () => walletAccountFromKey,
+  walletPath: () => walletPath
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/constants.ts
+var ARC_CHAIN_ID = 5042;
+var ARC_RPC_URL_DEFAULT = "https://rpc.mainnet.arc.io";
+var ARC_EXPLORER = "https://explorer.arc.io";
+var GATEWAY_FEE_WEI_DEFAULT = 10000000000000000n;
+
+// src/wallet/store.ts
+var import_node_fs = require("fs");
+var import_node_os = require("os");
+var import_node_path = require("path");
+var import_accounts = require("viem/accounts");
+function walletDir() {
+  return process.env.ARCDOT_HOME?.trim() || (0, import_node_path.join)((0, import_node_os.homedir)(), ".arcdot");
+}
+function walletPath() {
+  return (0, import_node_path.join)(walletDir(), "wallet.json");
+}
+function isHexKey(key) {
+  return /^0x[a-fA-F0-9]{64}$/.test(key);
+}
+function resolvePrivateKey() {
+  const fromEnv = process.env.ARCDOT_PRIVATE_KEY?.trim() || process.env.AGENT_PRIVATE_KEY?.trim();
+  if (fromEnv) {
+    if (!isHexKey(fromEnv)) {
+      throw new Error(
+        "ARCDOT_PRIVATE_KEY / AGENT_PRIVATE_KEY must be a 0x-prefixed 32-byte hex key."
+      );
+    }
+    return fromEnv;
+  }
+  const stored = loadWallet();
+  if (!stored) {
+    throw new Error(
+      "No agent wallet found. Run: npx @arcdot/agent wallet create"
+    );
+  }
+  return stored.privateKey;
+}
+function loadWallet() {
+  const path = walletPath();
+  if (!(0, import_node_fs.existsSync)(path)) return null;
+  const raw = JSON.parse((0, import_node_fs.readFileSync)(path, "utf8"));
+  if (!raw.address || !isHexKey(raw.privateKey)) {
+    throw new Error(`Corrupt wallet file at ${path}`);
+  }
+  return raw;
+}
+function createWallet(opts) {
+  const path = walletPath();
+  if ((0, import_node_fs.existsSync)(path) && !opts?.force) {
+    throw new Error(
+      `Wallet already exists at ${path}. Pass --force to overwrite, or use wallet address.`
+    );
+  }
+  (0, import_node_fs.mkdirSync)(walletDir(), { recursive: true });
+  const privateKey = (0, import_accounts.generatePrivateKey)();
+  const account = (0, import_accounts.privateKeyToAccount)(privateKey);
+  const wallet = {
+    address: account.address,
+    privateKey,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  (0, import_node_fs.writeFileSync)(path, JSON.stringify(wallet, null, 2) + "\n", {
+    encoding: "utf8",
+    mode: 384
+  });
+  try {
+    (0, import_node_fs.chmodSync)(path, 384);
+  } catch {
+  }
+  return wallet;
+}
+function walletAccountFromKey(privateKey) {
+  return (0, import_accounts.privateKeyToAccount)(privateKey);
+}
+
+// src/settle/pay.ts
+var import_viem4 = require("viem");
+var import_accounts2 = require("viem/accounts");
+
+// src/arc/chain.ts
+var import_viem = require("viem");
+function resolveRpcUrl(override) {
+  return override || process.env.ARC_RPC_URL || process.env.NEXT_PUBLIC_ARC_RPC_URL || ARC_RPC_URL_DEFAULT;
+}
+function arcMainnet(rpcUrl) {
+  return (0, import_viem.defineChain)({
+    id: ARC_CHAIN_ID,
+    name: "Arc",
+    nativeCurrency: { name: "USDC", symbol: "USDC", decimals: 18 },
+    rpcUrls: {
+      default: { http: [resolveRpcUrl(rpcUrl)] }
+    },
+    blockExplorers: {
+      default: { name: "Arc Explorer", url: ARC_EXPLORER }
+    }
+  });
+}
+var promptGatewayAbi = [
+  {
+    type: "function",
+    name: "depositPayment",
+    stateMutability: "payable",
+    inputs: [
+      { name: "paymentId", type: "bytes32" },
+      { name: "seller", type: "address" }
+    ],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "minFee",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+
+// src/auth/challenge.ts
+var import_viem2 = require("viem");
+function hashGatewayInput(input) {
+  return (0, import_viem2.keccak256)((0, import_viem2.stringToBytes)(JSON.stringify(input ?? null)));
+}
+function buildAuthChallenge(msg) {
+  return [
+    "arcdot.gateway",
+    `chainId:${msg.chainId}`,
+    `gateway:${msg.gateway.toLowerCase()}`,
+    `txHash:${msg.txHash.toLowerCase()}`,
+    `feeWei:${msg.feeWei}`,
+    `service:${msg.service}`,
+    `inputHash:${msg.inputHash.toLowerCase()}`,
+    `issuedAt:${msg.issuedAt}`,
+    `expiresAt:${msg.expiresAt}`
+  ].join("\n");
+}
+function buildGatewayAuthMessage(params) {
+  return {
+    domain: "arcdot.gateway",
+    chainId: ARC_CHAIN_ID,
+    gateway: params.gateway,
+    txHash: params.txHash,
+    feeWei: params.feeWei.toString(),
+    service: params.service,
+    inputHash: hashGatewayInput(params.input),
+    issuedAt: params.issuedAt,
+    expiresAt: params.expiresAt
+  };
+}
+
+// src/settle/paymentId.ts
+var import_viem3 = require("viem");
+function makePaymentId(params) {
+  return (0, import_viem3.keccak256)(
+    (0, import_viem3.encodeAbiParameters)(
+      [
+        { type: "address" },
+        { type: "string" },
+        { type: "uint256" }
+      ],
+      [params.payer, params.service, BigInt(params.nonce)]
+    )
+  );
+}
+
+// src/settle/pay.ts
+async function settlePayment(params) {
+  const account = (0, import_accounts2.privateKeyToAccount)(params.privateKey);
+  const chain = arcMainnet(params.rpcUrl);
+  const rpcUrl = resolveRpcUrl(params.rpcUrl);
+  const publicClient = (0, import_viem4.createPublicClient)({
+    chain,
+    transport: (0, import_viem4.http)(rpcUrl)
+  });
+  const walletClient = (0, import_viem4.createWalletClient)({
+    account,
+    chain,
+    transport: (0, import_viem4.http)(rpcUrl)
+  });
+  const paymentId = makePaymentId({
+    payer: account.address,
+    service: params.service,
+    nonce: Date.now()
+  });
+  const txHash = await walletClient.writeContract({
+    address: params.gateway,
+    abi: promptGatewayAbi,
+    functionName: "depositPayment",
+    args: [paymentId, params.seller],
+    value: params.feeWei,
+    chain,
+    account
+  });
+  await publicClient.waitForTransactionReceipt({ hash: txHash });
+  const now = Math.floor(Date.now() / 1e3);
+  const authMessage = buildGatewayAuthMessage({
+    gateway: params.gateway,
+    txHash,
+    feeWei: params.feeWei,
+    service: params.service,
+    input: params.input,
+    issuedAt: now,
+    expiresAt: now + 120
+  });
+  const signature = await walletClient.signMessage({
+    account,
+    message: buildAuthChallenge(authMessage)
+  });
+  return {
+    paymentId,
+    feeWei: params.feeWei,
+    proof: {
+      txHash,
+      address: account.address,
+      signature,
+      issuedAt: now,
+      expiresAt: now + 120
+    }
+  };
+}
+async function getNativeBalance(address, rpcUrl) {
+  const publicClient = (0, import_viem4.createPublicClient)({
+    chain: arcMainnet(rpcUrl),
+    transport: (0, import_viem4.http)(resolveRpcUrl(rpcUrl))
+  });
+  const wei = await publicClient.getBalance({ address });
+  return { wei, formatted: (0, import_viem4.formatEther)(wei) };
+}
+
+// src/client/paymentParse.ts
+function isGateway402Body(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  if (v.ok !== false || v.status !== 402) return false;
+  const err = v.error;
+  if (!err || typeof err !== "object") return false;
+  return Boolean(err.payment);
+}
+function parsePaymentRequired(body) {
+  if (!isGateway402Body(body)) return null;
+  const payment = body.error.payment;
+  if (!payment?.gateway || !payment.feeWei) return null;
+  return payment;
+}
+function parseMcpPaymentNeeded(toolResult) {
+  const text = extractMcpText(toolResult);
+  if (!text) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  const obj = parsed;
+  const err = obj.error;
+  if (obj.status === 402 || err?.code === "PAYMENT_REQUIRED") {
+    const payment = err?.payment;
+    if (!payment?.gateway || !payment.feeWei) return null;
+    const slug = err?.service?.slug || (typeof obj.service === "string" ? obj.service : "") || "";
+    return { payment, serviceSlug: slug, raw: parsed };
+  }
+  return null;
+}
+function extractMcpText(toolResult) {
+  if (!toolResult || typeof toolResult !== "object") return null;
+  const r = toolResult;
+  if (Array.isArray(r.content)) {
+    const texts = r.content.filter((c) => c?.type === "text" && typeof c.text === "string").map((c) => c.text);
+    if (texts.length) return texts.join("\n");
+  }
+  if (typeof toolResult.text === "string") {
+    return toolResult.text;
+  }
+  return null;
+}
+function paymentDepositArgs(payment) {
+  if (!payment.seller) {
+    throw new Error("Payment instructions missing seller address");
+  }
+  return {
+    feeWei: BigInt(payment.feeWei),
+    seller: payment.seller,
+    gateway: payment.gateway
+  };
+}
+
+// src/client/gateway.ts
+async function fetchService(origin, slug) {
+  const res = await fetch(new URL(`/api/services/${slug}`, origin));
+  const json = await res.json();
+  if (!res.ok || !json.service) {
+    throw new Error(json.error || `Service not found: ${slug}`);
+  }
+  const sellerRaw = json.service.seller || json.service.owner_address;
+  if (!sellerRaw || !/^0x[a-fA-F0-9]{40}$/.test(sellerRaw)) {
+    throw new Error("Service is missing a valid seller address");
+  }
+  return {
+    slug: json.service.slug,
+    price_wei: json.service.price_wei,
+    seller: sellerRaw,
+    title: json.service.title
+  };
+}
+async function resolveGateway(origin, override) {
+  if (override && override.length === 42) return override;
+  if (process.env.ARCDOT_GATEWAY?.startsWith("0x")) {
+    return process.env.ARCDOT_GATEWAY;
+  }
+  const res = await fetch(new URL("/api/services", origin));
+  const json = await res.json();
+  if (json.gateway && json.gateway.length === 42) {
+    return json.gateway;
+  }
+  throw new Error(
+    "Gateway address not configured on host. Set ARCDOT_GATEWAY or deploy PromptGateway."
+  );
+}
+async function postGatewayPaid(params) {
+  const body = {
+    service: params.service,
+    input: params.input,
+    clientRequestId: params.clientRequestId,
+    auth: {
+      issuedAt: params.proof.issuedAt,
+      expiresAt: params.proof.expiresAt
+    }
+  };
+  const res = await fetch(new URL("/api/gateway", params.origin), {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Arc-Tx-Hash": params.proof.txHash,
+      "X-Arc-Address": params.proof.address,
+      "X-Arc-Signature": params.proof.signature
+    },
+    body: JSON.stringify(body)
+  });
+  const json = await res.json();
+  if (res.status === 200 && json?.ok === true) {
+    return { ok: true, status: 200, body: json };
+  }
+  return { ok: false, status: res.status, body: json };
+}
+async function unlockWithAutoSettle(params) {
+  const privateKey = params.privateKey ?? resolvePrivateKey();
+  const origin = params.origin.replace(/\/$/, "");
+  const probe = await fetch(new URL("/api/gateway", origin), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      service: params.service,
+      input: params.input,
+      clientRequestId: params.clientRequestId
+    })
+  });
+  const probeJson = await probe.json();
+  if (probe.status === 200 && probeJson?.ok === true) {
+    return {
+      gateway: { ok: true, status: 200, body: probeJson },
+      settled: false
+    };
+  }
+  const payment = parsePaymentRequired(probeJson);
+  const service = await fetchService(origin, params.service);
+  const gatewayAddr = params.gateway || (payment ? payment.gateway : await resolveGateway(origin));
+  let feeWei = BigInt(service.price_wei);
+  let seller = service.seller;
+  if (payment) {
+    const args = paymentDepositArgs(payment);
+    feeWei = args.feeWei;
+    seller = args.seller;
+  }
+  if (feeWei <= 0n) feeWei = GATEWAY_FEE_WEI_DEFAULT;
+  const settled = await settlePayment({
+    privateKey,
+    gateway: gatewayAddr,
+    seller,
+    service: params.service,
+    feeWei,
+    input: params.input,
+    rpcUrl: params.rpcUrl
+  });
+  const gateway = await postGatewayPaid({
+    origin,
+    service: params.service,
+    input: params.input,
+    proof: settled.proof,
+    feeWei: settled.feeWei,
+    clientRequestId: params.clientRequestId
+  });
+  return {
+    gateway,
+    txHash: settled.proof.txHash,
+    paymentId: settled.paymentId,
+    settled: true
+  };
+}
+
+// src/mcp/toolNames.ts
+function toolNameForSlug(slug) {
+  return `arcdot_${slug.replace(/-/g, "_")}`;
+}
+function slugFromToolName(name) {
+  if (!name.startsWith("arcdot_")) return null;
+  if (name === "arcdot_catalog" || name === "arcdot_health") return null;
+  return name.slice("arcdot_".length).replace(/_/g, "-");
+}
+
+// src/client/mcp.ts
+async function mcpRpc(origin, method, params, id = 1) {
+  const endpoint = new URL("/api/mcp", origin.replace(/\/$/, ""));
+  const res = await fetch(endpoint, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id,
+      method,
+      params: params ?? {}
+    })
+  });
+  return await res.json();
+}
+async function callMcpToolWithAutoSettle(params) {
+  const origin = params.origin.replace(/\/$/, "");
+  const args = { ...params.arguments ?? {} };
+  const first = await mcpRpc(origin, "tools/call", {
+    name: params.name,
+    arguments: args
+  });
+  if (first.error) return first;
+  const needed = parseMcpPaymentNeeded(first.result);
+  if (!needed) return first;
+  const privateKey = params.privateKey ?? resolvePrivateKey();
+  const deposit = paymentDepositArgs(needed.payment);
+  const slug = needed.serviceSlug || slugFromToolName(params.name) || String(args.service ?? "");
+  if (!slug) {
+    throw new Error(
+      `Cannot settle: missing service slug for tool ${params.name}`
+    );
+  }
+  const input = {
+    prompt: typeof args.prompt === "string" ? args.prompt : JSON.stringify(args)
+  };
+  const gateway = params.gateway || deposit.gateway || await resolveGateway(origin);
+  const settled = await settlePayment({
+    privateKey,
+    gateway,
+    seller: deposit.seller,
+    service: slug,
+    feeWei: deposit.feeWei,
+    input,
+    rpcUrl: params.rpcUrl
+  });
+  const retryArgs = {
+    ...args,
+    payment: {
+      txHash: settled.proof.txHash,
+      address: settled.proof.address,
+      signature: settled.proof.signature,
+      issuedAt: settled.proof.issuedAt,
+      expiresAt: settled.proof.expiresAt
+    }
+  };
+  return mcpRpc(origin, "tools/call", {
+    name: params.name,
+    arguments: retryArgs
+  }, 2);
+}
+
+// src/createAgent.ts
+async function createArcdotAgent(options) {
+  const origin = options.origin.replace(/\/$/, "");
+  const privateKey = options.privateKey ?? resolvePrivateKey();
+  return {
+    origin,
+    async unlock(params) {
+      return unlockWithAutoSettle({
+        origin,
+        service: params.service,
+        input: params.input,
+        privateKey,
+        rpcUrl: options.rpcUrl,
+        gateway: options.gateway,
+        clientRequestId: params.clientRequestId
+      });
+    },
+    async callMcpTool(name, args) {
+      const res = await callMcpToolWithAutoSettle({
+        origin,
+        name,
+        arguments: args,
+        privateKey,
+        rpcUrl: options.rpcUrl,
+        gateway: options.gateway
+      });
+      if (res.error) {
+        throw new Error(res.error.message);
+      }
+      return res.result;
+    },
+    async listMcpTools() {
+      const res = await mcpRpc(origin, "tools/list");
+      if (res.error) throw new Error(res.error.message);
+      return res.result;
+    }
+  };
+}
+
+// src/mcp/proxy.ts
+var import_node_readline = require("readline");
+function write(msg) {
+  process.stdout.write(JSON.stringify(msg) + "\n");
+}
+function ok(id, result) {
+  write({ jsonrpc: "2.0", id: id ?? null, result });
+}
+function fail(id, code, message) {
+  write({
+    jsonrpc: "2.0",
+    id: id ?? null,
+    error: { code, message }
+  });
+}
+async function runMcpProxy(origin) {
+  const base = origin.replace(/\/$/, "");
+  const rl = (0, import_node_readline.createInterface)({ input: process.stdin, crlfDelay: Infinity });
+  console.error(`[arcdot] MCP proxy \u2192 ${base}/api/mcp`);
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let msg;
+    try {
+      msg = JSON.parse(trimmed);
+    } catch {
+      fail(null, -32700, "Parse error");
+      continue;
+    }
+    const id = msg.id;
+    const method = msg.method;
+    if (method === "notifications/initialized" || id === void 0) {
+      if (method && method.startsWith("notifications/")) continue;
+    }
+    try {
+      if (method === "initialize") {
+        const remote = await mcpRpc(base, "initialize", msg.params);
+        if (remote.error) {
+          fail(id, remote.error.code, remote.error.message);
+        } else {
+          const result = remote.result;
+          ok(id, result ?? {
+            protocolVersion: "2024-11-05",
+            capabilities: { tools: {} },
+            serverInfo: { name: "arcdot-proxy", version: "0.1.0" }
+          });
+        }
+        continue;
+      }
+      if (method === "ping") {
+        ok(id, {});
+        continue;
+      }
+      if (method === "tools/list") {
+        const remote = await mcpRpc(base, "tools/list", msg.params);
+        if (remote.error) fail(id, remote.error.code, remote.error.message);
+        else ok(id, remote.result);
+        continue;
+      }
+      if (method === "tools/call") {
+        const p = msg.params;
+        if (!p?.name) {
+          fail(id, -32602, "tools/call requires params.name");
+          continue;
+        }
+        const remote = await callMcpToolWithAutoSettle({
+          origin: base,
+          name: p.name,
+          arguments: p.arguments
+        });
+        if (remote.error) fail(id, remote.error.code, remote.error.message);
+        else ok(id, remote.result);
+        continue;
+      }
+      if (method) {
+        const remote = await mcpRpc(base, method, msg.params);
+        if (remote.error) fail(id, remote.error.code, remote.error.message);
+        else ok(id, remote.result);
+        continue;
+      }
+      fail(id, -32600, "Invalid Request");
+    } catch (err) {
+      fail(
+        id,
+        -32e3,
+        err instanceof Error ? err.message : "Proxy error"
+      );
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ARC_CHAIN_ID,
+  ARC_RPC_URL_DEFAULT,
+  GATEWAY_FEE_WEI_DEFAULT,
+  callMcpToolWithAutoSettle,
+  createArcdotAgent,
+  createWallet,
+  fetchService,
+  getNativeBalance,
+  isGateway402Body,
+  loadWallet,
+  makePaymentId,
+  mcpRpc,
+  parseMcpPaymentNeeded,
+  parsePaymentRequired,
+  paymentDepositArgs,
+  resolveGateway,
+  resolvePrivateKey,
+  runMcpProxy,
+  settlePayment,
+  slugFromToolName,
+  toolNameForSlug,
+  unlockWithAutoSettle,
+  walletAccountFromKey,
+  walletPath
+});
+//# sourceMappingURL=index.cjs.map